app.post('/login/password',
  passport.authenticate('local', { failureRedirect: '/login', failureMessage: true }),
  function(req, res) {
    res.redirect('/~' + req.user.username);
  });

$ npm install passport-local

var LocalStrategy = require('passport-local');

var strategy = new LocalStrategy(function verify(username, password, cb) {
  db.get('SELECT * FROM users WHERE username = ?', [ username ], function(err, user) {
    if (err) { return cb(err); }
    if (!user) { return cb(null, false, { message: 'Incorrect username or password.' }); }

    crypto.pbkdf2(password, user.salt, 310000, 32, 'sha256', function(err, hashedPassword) {
      if (err) { return cb(err); }
      if (!crypto.timingSafeEqual(user.hashed_password, hashedPassword)) {
        return cb(null, false, { message: 'Incorrect username or password.' });
      }
      return cb(null, user);
    });
  });
});

  db.get('SELECT * FROM users WHERE username = ?', [ username ], function(err, user) { ... }

    if (err) { return cb(err); }
    if (!user) { return cb(null, false, { message: 'Incorrect username or password.' }); }

    crypto.pbkdf2(password, user.salt, 310000, 32, 'sha256', function(err, hashedPassword) {
      if (err) { return cb(err); }
      if (!crypto.timingSafeEqual(user.hashed_password, hashedPassword)) {
        return cb(null, false, { message: 'Incorrect username or password.' });
      }
      return cb(null, user);
    });

const passport = require('passport')
passport.use(strategy)

app.post('/login/password',
  passport.authenticate('local', { failureRedirect: '/login', failureMessage: true }),
  function(req, res) {
    res.redirect('/~' + req.user.username);
  });

var passport = require('passport');

passport.use('password', strategy);

app.post('/login/password',
  passport.authenticate('password', { failureRedirect: '/login', failureMessage: true }),
  function(req, res) {
    res.redirect('/~' + req.user.username);
  });

var session = require('express-session');

app.use(session({
  secret: 'keyboard cat',
  resave: false,
  saveUninitialized: false,
  cookie: { secure: true }
}));
app.use(passport.session());

passport.serializeUser(function(user, cb) { // <-- 여기의 user 는
                                            //     strategy 에서 인증된 user 이다.
                                            //     즉, strategy 성공시 호출된다.
                                            //     serializeUser 는 처음 로그인시에만 호출된다.
  process.nextTick(function() {
    return cb(null, {
      id: user.id,
      username: user.username,
      picture: user.picture
    }); // <-- `session` 에 고유식별자를 등록한다.
  });
});

passport.deserializeUser(function(user, cb) { // <-- 여기의 user 는 
                                              //     session 객체에서 가져온 user 값이다.
                                              //     deserializeUser 는 페이지 방문시 매번 호출된다.
  process.nextTick(function() {
    return cb(null, user);
  });
});

passport.serializeUser(function(user, cb) {
  process.nextTick(function() {
    return cb(null, user.id); // session 객체에 user.id 를 저장
  });
});

passport.deserializeUser(function(id, cb) { // session 에서 id 값을 가져온다
  db.get('SELECT * FROM users WHERE id = ?', [ id ], function(err, user) {
    if (err) { return cb(err); }
    return cb(null, user); // user 값을 db 에서 조회하여 req.user 에 할당한다.
  });
});

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

{
  "alg": "HS256", // <-- 서명된 알고리즘 ex) HMAC, SHA256, RSA
  "typ": "JWT" // <-- Type
}

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true,
  "https://www.MyNamespaceUrl.com/logindId": "idid" // <-- NameSpace URL 형태로 정의
}

{
  "test_user_id": "ad11dacff12", // <-- 협의된 custom claim
  "test_user_name": "Jhon Doe" // <-- 협의된 custom claim
}

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  your-256-bit-secret
)

// JWT Encoded

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

// JWT Decoded
---
Header
{
  "alg": "HS256",
  "typ": "JWT"
}
---
Payload
{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}
---
Signature
HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  your-256-bit-secret
)
---

Authorization: Bearer <token>

$ npm i passport-jwt

new JwtStrategy(options, verify)

var JwtStrategy = require('passport-jwt').Strategy, 
    // <-- Stragy constructor 를 가져온다
    ExtractJwt = require('passport-jwt').ExtractJwt;
    // <-- header 에서 JWT 를 추출하기 위한 함수를 제공하는 ExtractJwt 를 가져온다
var opts = {}
opts.jwtFromRequest = ExtractJwt.fromAuthHeaderAsBearerToken();
    // <-- ExtractJwt.fromAuthHeaderAsBearerToken 를 통해 
    //     request 객체를 인수로 받아 실행하는 함수를 가진다.
opts.secretOrKey = 'secret';
opts.issuer = 'accounts.examplesoft.com';
opts.audience = 'yoursite.net';
passport.use(new JwtStrategy(opts, function(jwt_payload, done) {
  // JwtStrategy 를 생성하며, 인자로 첫번째로 opts 를, 두번째로 `verify callback` 함수를 전달
  // verify callback 함수에서 `jwt_payload` 는 `decoded JWT Payload` 가 존재한다.
    User.findOne({id: jwt_payload.sub}, function(err, user) {
      // `decoded JWT Payload` 의 `sub` 를 가져오고, `DB` 에서 조회한다.
      //  여기서 `sub` 는 `ID` 값이다.
        if (err) { // error 가 있다면
            return done(err, false); // DB 상 `error` 발생시, `Error` 를 전달
        }
        if (user) { // user 가 있다면
            return done(null, user); // done 값에 user 전달
        } else {
            return done(null, false); // 없다면, false 전달
                                      // 혹은 새로운 User 생성 로직을 써도 괜찮다
        }
    });
}));

function fromAuthHeaderAsBearerToken() {
  return function (req) {
    let token = null;
    if (req.headers && req.headers.authorization) {
      const parts = req.headers.authorization.split(' ');
      if (parts.length === 2 && parts[0] === 'Bearer') {
        token = parts[1];
      }
    }
    return token;
  };
}

app.post('/profile', passport.authenticate('jwt', { session: false }), 
// <-- stateless 인 jwt 는 session 을 사용하지 않으므로, 옵션으로 session 값을 false 로 준다.
    function(req, res) {
        res.send(req.user.profile);
    }
);

// nestjs/common 의 Type 
export interface Type<T = any> extends Function {
  new (...args: any[]): T;
}

class MyClass {
  constructor(public name: string) {}
}

// Type<T>를 사용하여 MyClass의 타입을 지정
const myClassType: Type<MyClass> = MyClass;

// Type<T>로 생성된 타입을 사용하여 객체 인스턴스를 생성
const myInstance: MyClass = new myClassType('example');

// 객체 인스턴스의 프로퍼티에 접근
console.log(myInstance.name); // 출력: "example"

import { Abstract } from '../abstract.interface';
import { Type } from '../type.interface';
import { DynamicModule } from './dynamic-module.interface';
import { ForwardReference } from './forward-reference.interface';
import { Provider } from './provider.interface';

/**
 * Interface defining the property object that describes the module.
 *
 * @see [Modules](https://docs.nestjs.com/modules)
 *
 * @publicApi
 */
export interface ModuleMetadata {
  /**
   * Optional list of imported modules that export the providers which are
   * required in this module.
   */
  imports?: Array<
    Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference
  >;
  /**
   * Optional list of controllers defined in this module which have to be
   * instantiated.
   */
  controllers?: Type<any>[];
  /**
   * Optional list of providers that will be instantiated by the Nest injector
   * and that may be shared at least across this module.
   */
  providers?: Provider[];
  /**
   * Optional list of the subset of providers that are provided by this module
   * and should be available in other modules which import this module.
   */
  exports?: Array<
    | DynamicModule
    | Promise<DynamicModule>
    | string
    | symbol
    | Provider
    | ForwardReference
    | Abstract<any>
    | Function
  >;
}

// auth-module.options.ts 
import { ModuleMetadata, Type } from '@nestjs/common';

export interface IAuthModuleOptions<T = any> {
  defaultStrategy?: string | string[]; // 사용될 기본 Strategy 
  session?: boolean; // session 을 사용할지 안할지 boolean 값
  property?: string; // request 객체에 저장될 property name 지정
  [key: string]: any; // 그 외...
}

export interface AuthOptionsFactory {
  createAuthOptions(): Promise<IAuthModuleOptions> | IAuthModuleOptions;
} // createAuthOptions 함수를 가진 인터페이스로 반환값은 IAuthModuleOptions 이다.

export interface AuthModuleAsyncOptions
  extends Pick<ModuleMetadata, 'imports'> {
    // 다른 모듈을 확장할 수 있도록
    // ModuleMetadata 중 imports 를 가져와 확장시킨다.
    // 밑은 나머지 추가적인 함수들이다.
  
  useExisting?: Type<AuthOptionsFactory>;
  // 기존에 존재하는 `AuthOptionsFactory` 클래스 타입을 사용하여 옵션을 생성 
  useClass?: Type<AuthOptionsFactory>;
  // 새로운 `AuthOptionsFactory` 클래스 타입을 생성하여 옵션을 생성
  useFactory?: (
    ...args: any[]
  ) => Promise<IAuthModuleOptions> | IAuthModuleOptions;
  // factory 함수를 사용하여 옵션을 생성
  // factory 함수는 paramter 를 받아 `IAuthModuleOptions` 을 생성한다.
  inject?: any[];
  // 의존성 주입을 위한 token 배열
  // 이 주입된 token 을 사용하여 위의 클래스 생성자에서 받아 처리 가능하다
}

export class AuthModuleOptions implements IAuthModuleOptions {
  defaultStrategy?: string | string[];
  session?: boolean;
  property?: string;
} // IAuthModuleOptions 을 구현한 클래스

// passport.module.ts
import { DynamicModule, Module, Provider } from '@nestjs/common';
import {
  AuthModuleAsyncOptions,
  AuthModuleOptions,
  AuthOptionsFactory,
  IAuthModuleOptions
} from './interfaces/auth-module.options';

@Module({})
export class PassportModule {
  static register(options: IAuthModuleOptions): DynamicModule { 
    //<-- options 를 받아 provider 에 제공되도록 하는 `static register` 
    //    함수를 제공한다.
    //    이 함수는 동기적으로 작동한다.
    return {
      module: PassportModule,
      providers: [{ provide: AuthModuleOptions, useValue: options }],
      exports: [AuthModuleOptions]
    };
    // <-- return 값으로 module 을 반환하며, `options` 를 값으로하는 `provider` 를
    //     주입하며, 필요시 해당 `Provider` 를 `exports` 해서 사용할수 있도록 만든다 
  }

  static registerAsync(options: AuthModuleAsyncOptions): DynamicModule {
    //<-- options 를 받아 provider 에 제공되도록 하는 `static register` 
    //    함수를 제공한다.
    //    이 함수는 비동기적으로 작동한다.
    return {
      module: PassportModule,
      imports: options.imports || [],
      providers: this.createAsyncProviders(options),
      exports: [AuthModuleOptions]
    };
  }

// 밑은 provider 를 만들어주는 함수같다
  private static createAsyncProviders(
    options: AuthModuleAsyncOptions
    /*
    export interface AuthModuleAsyncOptions
      extends Pick<ModuleMetadata, 'imports'> {
      useExisting?: Type<AuthOptionsFactory>;
      useClass?: Type<AuthOptionsFactory>;
      useFactory?: (
        ...args: any[]
      ) => Promise<IAuthModuleOptions> | IAuthModuleOptions;
      inject?: any[];
    }
    이 AuthModuleAsyncOPtions 는 module 의 custom provider 모음을 
    제공하는 함수인듯 하다.
    
    아직, custom provider 에 익숙치 않은 듯하다.
    많이 사용하면서 익숙해지고 다시 살펴보아야 겠다.
   */
  ): Provider[] {
    if (options.useExisting || options.useFactory) {
      return [this.createAsyncOptionsProvider(options)];
    }
    return [
      this.createAsyncOptionsProvider(options),
      {
        provide: options.useClass,
        useClass: options.useClass
      }
    ];
  }

// 실제 options 를 받아서 provider 를 직접 생성하는 함수이다.
  private static createAsyncOptionsProvider(
    options: AuthModuleAsyncOptions
  ): Provider {
    if (options.useFactory) {
      return {
        provide: AuthModuleOptions,
        useFactory: options.useFactory,
        inject: options.inject || []
      };
    }
    return {
      provide: AuthModuleOptions,
      useFactory: async (optionsFactory: AuthOptionsFactory) =>
        await optionsFactory.createAuthOptions(),
      inject: [options.useExisting || options.useClass]
    };
  }
}

import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LocalStrategy } from './local.strategy';
import { JwtStrategy } from './jwt.strategy';
import { UsersModule } from '../users/users.module';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';
import { jwtConstants } from './constants';

@Module({
  imports: [
    UsersModule,
    PassportModule,
    JwtModule.register({
      secret: jwtConstants.secret,
      signOptions: { expiresIn: '60s' },
    }),
  ],
  providers: [AuthService, LocalStrategy, JwtStrategy],
  exports: [AuthService],
})
export class AuthModule {}

// passport/lib/options.ts

export const defaultOptions = {
  session: false,
  property: 'user'
};

import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';
import { jwtConstants } from './constants';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: jwtConstants.secret,
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

// passport/lib/passport/passport.strategy.ts
import * as passport from 'passport';
import { Type } from '../interfaces';

export function PassportStrategy<T extends Type<any> = any>(
  Strategy: T,
  name?: string | undefined
): {
  new (...args): InstanceType<T>;
} {
  abstract class MixinStrategy extends Strategy {
    abstract validate(...args: any[]): any;

    constructor(...args: any[]) {
      const callback = async (...params: any[]) => {
        const done = params[params.length - 1];
        try {
          const validateResult = await this.validate(...params);
          if (Array.isArray(validateResult)) {
            done(null, ...validateResult);
          } else {
            done(null, validateResult);
          }
        } catch (err) {
          done(err, null);
        }
      };
      /**
       * Commented out due to the regression it introduced
       * Read more here: https://github.com/nestjs/passport/issues/446
        const validate = new.target?.prototype?.validate;
        if (validate) {
          Object.defineProperty(callback, 'length', {
            value: validate.length + 1
          });
        }
      */
      super(...args, callback);

      const passportInstance = this.getPassportInstance();
      if (name) {
        passportInstance.use(name, this as any);
      } else {
        passportInstance.use(this as any);
      }
    }

    getPassportInstance() {
      return passport;
    }
  }
  return MixinStrategy;
}

export function PassportStrategy<T extends Type<any> = any>(
  Strategy: T, // <-- 이부분
  name?: string | undefined
): {
  new (...args): InstanceType<T>;
} { ... }

export function PassportStrategy<T extends Type<any> = any>(
  Strategy: T, 
  name?: string | undefined
): {
  new (...args): InstanceType<T>; // <-- 이부분
} { ... }

import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';
import { jwtConstants } from './constants';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {...}

import * as passport from 'passport';
import { Type } from '../interfaces';

export function PassportStrategy<T extends Type<any> = any>(
  Strategy: T,
  name?: string | undefined
): {
  new (...args): InstanceType<T>;
} {
  abstract class MixinStrategy extends Strategy {
    ...
  }
  return MixinStrategy;
}

import * as passport from 'passport';
import { Type } from '../interfaces';

export function PassportStrategy<T extends Type<any> = any>(
  Strategy: T,
  name?: string | undefined
): {
  new (...args): InstanceType<T>;
} {
  abstract class MixinStrategy extends Strategy {
    ...

    getPassportInstance() {
      return passport
    }
  }
  return MixinStrategy;
}

mport * as passport from 'passport';
import { Type } from '../interfaces';

export function PassportStrategy<T extends Type<any> = any>(
  Strategy: T,
  name?: string | undefined
): {
  new (...args): InstanceType<T>;
} {
  abstract class MixinStrategy extends Strategy {
    abstract validate(...args: any[]): any;

    constructor(...args: any[]) {
      const callback = async (...params: any[]) => {
        const done = params[params.length - 1];
        try {
          const validateResult = await this.validate(...params);
          if (Array.isArray(validateResult)) {
            done(null, ...validateResult);
          } else {
            done(null, validateResult);
          }
        } catch (err) {
          done(err, null);
        }
      };
      /**
       * Commented out due to the regression it introduced
       * Read more here: https://github.com/nestjs/passport/issues/446
        const validate = new.target?.prototype?.validate;
        if (validate) {
          Object.defineProperty(callback, 'length', {
            value: validate.length + 1
          });
        }
      */
      super(...args, callback);

      const passportInstance = this.getPassportInstance();
      if (name) {
        passportInstance.use(name, this as any);
      } else {
        passportInstance.use(this as any);
      }
    }

    getPassportInstance() {
      return passport;
    }
  }
  return MixinStrategy;
}

    constructor(...args: any[]) {
      const callback = async (...params: any[]) => {
        const done = params[params.length - 1];
        try {
          const validateResult = await this.validate(...params);
          if (Array.isArray(validateResult)) {
            done(null, ...validateResult);
          } else {
            done(null, validateResult);
          }
        } catch (err) {
          done(err, null);
        }
      };
      super(...args, callback);

      const passportInstance = this.getPassportInstance();
      if (name) {
        passportInstance.use(name, this as any);
      } else {
        passportInstance.use(this as any);
      }
    }

mport * as passport from 'passport';
import { Type } from '../interfaces';

export function PassportStrategy<T extends Type<any> = any>(
  Strategy: T,
  name?: string | undefined
): {
  new (...args): InstanceType<T>;
} {
  abstract class MixinStrategy extends Strategy {
    abstract validate(...args: any[]): any; // <-- 여기

    constructor(...args: any[]) {
      ...
    }

    getPassportInstance() {
      return passport;
    }
  }
  return MixinStrategy;
}

    constructor(...args: any[]) {
      // callback 생성
      const callback = async (...params: any[]) => {
        const done = params[params.length - 1];
        try {
          const validateResult = await this.validate(...params);
          if (Array.isArray(validateResult)) {
            done(null, ...validateResult);
          } else {
            done(null, validateResult);
          }
        } catch (err) {
          done(err, null);
        }
      };
      // 부모 Strategy Class 에 인자와, callback 전달
      super(...args, callback);

      // Strategy 등록
      const passportInstance = this.getPassportInstance();
      if (name) {
        passportInstance.use(name, this as any);
      } else {
        passportInstance.use(this as any);
      }
    }

import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';
import { jwtConstants } from './constants';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: jwtConstants.secret,
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

@Injectable()
export class AuthAGuard implements CanActive {
  constructor(private readonly authSrevice: AuthService) {}

  canActive(context: ExecutionContext) {
    const user = this.authService.getCurrentUser();
    if (!user) {
      return false
    }
    return true;
  }
}

// nest/packages/commons/interface/features/can-active.interface.ts

import { Observable } from 'rxjs';
import { ExecutionContext } from './execution-context.interface';

/**
 * Interface defining the `canActivate()` function that must be implemented
 * by a guard.  Return value indicates whether or not the current request is
 * allowed to proceed.  Return can be either synchronous (`boolean`)
 * or asynchronous (`Promise` or `Observable`).
 *
 * @see [Guards](https://docs.nestjs.com/guards)
 *
 * @publicApi
 */
export interface CanActivate {
  /**
   * @param context Current execution context. Provides access to details about
   * the current request pipeline.
   *
   * @returns Value indicating whether or not the current request is allowed to
   * proceed.
   */
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean>;
}

import { Type } from '../index';
import { ArgumentsHost } from './arguments-host.interface';

/**
 * Interface describing details about the current request pipeline.
 *
 * @see [Execution Context](https://docs.nestjs.com/guards#execution-context)
 *
 * @publicApi
 */
export interface ExecutionContext extends ArgumentsHost {
  /**
   * Returns the *type* of the controller class which the current handler belongs to.
   */
  getClass<T = any>(): Type<T>;
  /**
   * Returns a reference to the handler (method) that will be invoked next in the
   * request pipeline.
   */
  getHandler(): Function;
}

export type ContextType = 'http' | 'ws' | 'rpc';

/**
 * Methods to obtain request and response objects.
 *
 * @publicApi
 */
export interface HttpArgumentsHost {
  /**
   * Returns the in-flight `request` object.
   */
  getRequest<T = any>(): T;
  /**
   * Returns the in-flight `response` object.
   */
  getResponse<T = any>(): T;
  getNext<T = any>(): T;
}

/**
 * Methods to obtain WebSocket data and client objects.
 *
 * @publicApi
 */
export interface WsArgumentsHost {
  /**
   * Returns the data object.
   */
  getData<T = any>(): T;
  /**
   * Returns the client object.
   */
  getClient<T = any>(): T;
}

/**
 * Methods to obtain RPC data object.
 *
 * @publicApi
 */
export interface RpcArgumentsHost {
  /**
   * Returns the data object.
   */
  getData<T = any>(): T;

  /**
   * Returns the context object.
   */
  getContext<T = any>(): T;
}

/**
 * Provides methods for retrieving the arguments being passed to a handler.
 * Allows choosing the appropriate execution context (e.g., Http, RPC, or
 * WebSockets) to retrieve the arguments from.
 *
 * @publicApi
 */
export interface ArgumentsHost {
  /**
   * Returns the array of arguments being passed to the handler.
   */
  getArgs<T extends Array<any> = any[]>(): T;
  /**
   * Returns a particular argument by index.
   * @param index index of argument to retrieve
   */
  getArgByIndex<T = any>(index: number): T;
  /**
   * Switch context to RPC.
   * @returns interface with methods to retrieve RPC arguments
   */
  switchToRpc(): RpcArgumentsHost;
  /**
   * Switch context to HTTP.
   * @returns interface with methods to retrieve HTTP arguments
   */
  switchToHttp(): HttpArgumentsHost;
  /**
   * Switch context to WebSockets.
   * @returns interface with methods to retrieve WebSockets arguments
   */
  switchToWs(): WsArgumentsHost;
  /**
   * Returns the current execution context type (string)
   */
  getType<TContext extends string = ContextType>(): TContext;
}

import {
  CanActivate,
  ExecutionContext,
  Inject,
  Logger,
  mixin,
  Optional,
  UnauthorizedException
} from '@nestjs/common';
import * as passport from 'passport';
import { Type } from './interfaces';
import {
  AuthModuleOptions,
  IAuthModuleOptions
} from './interfaces/auth-module.options';
import { defaultOptions } from './options';
import { memoize } from './utils/memoize.util';

export type IAuthGuard = CanActivate & {
  logIn<TRequest extends { logIn: Function } = any>(
    request: TRequest
  ): Promise<void>;
  handleRequest<TUser = any>(
    err,
    user,
    info,
    context: ExecutionContext,
    status?
  ): TUser;
  getAuthenticateOptions(
    context: ExecutionContext
  ): IAuthModuleOptions | undefined;
};
export const AuthGuard: (type?: string | string[]) => Type<IAuthGuard> =
  memoize(createAuthGuard);

const NO_STRATEGY_ERROR = `In order to use "defaultStrategy", please, ensure to import PassportModule in each place where AuthGuard() is being used. Otherwise, passport won't work correctly.`;
const authLogger = new Logger('AuthGuard');

function createAuthGuard(type?: string | string[]): Type<CanActivate> {
  class MixinAuthGuard<TUser = any> implements CanActivate {
    @Optional()
    @Inject(AuthModuleOptions)
    protected options: AuthModuleOptions = {};

    constructor(@Optional() options?: AuthModuleOptions) {
      this.options = options ?? this.options;
      if (!type && !this.options.defaultStrategy) {
        authLogger.error(NO_STRATEGY_ERROR);
      }
    }

    async canActivate(context: ExecutionContext): Promise<boolean> {
      const options = {
        ...defaultOptions,
        ...this.options,
        ...(await this.getAuthenticateOptions(context))
      };
      const [request, response] = [
        this.getRequest(context),
        this.getResponse(context)
      ];
      const passportFn = createPassportContext(request, response);
      const user = await passportFn(
        type || this.options.defaultStrategy,
        options,
        (err, user, info, status) =>
          this.handleRequest(err, user, info, context, status)
      );
      request[options.property || defaultOptions.property] = user;
      return true;
    }

    getRequest<T = any>(context: ExecutionContext): T {
      return context.switchToHttp().getRequest();
    }

    getResponse<T = any>(context: ExecutionContext): T {
      return context.switchToHttp().getResponse();
    }

    async logIn<TRequest extends { logIn: Function } = any>(
      request: TRequest
    ): Promise<void> {
      const user = request[this.options.property || defaultOptions.property];
      await new Promise<void>((resolve, reject) =>
        request.logIn(user, (err) => (err ? reject(err) : resolve()))
      );
    }

    handleRequest(err, user, info, context, status): TUser {
      if (err || !user) {
        throw err || new UnauthorizedException();
      }
      return user;
    }

    getAuthenticateOptions(
      context: ExecutionContext
    ): Promise<IAuthModuleOptions> | IAuthModuleOptions | undefined {
      return undefined;
    }
  }
  const guard = mixin(MixinAuthGuard);
  return guard;
}

const createPassportContext =
  (request, response) => (type, options, callback: Function) =>
    new Promise<void>((resolve, reject) =>
      passport.authenticate(type, options, (err, user, info, status) => {
        try {
          request.authInfo = info;
          return resolve(callback(err, user, info, status));
        } catch (err) {
          reject(err);
        }
      })(request, response, (err) => (err ? reject(err) : resolve()))
    );

import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

import { Controller, Get, Request, Post, UseGuards } from '@nestjs/common';
import { JwtAuthGuard } from './auth/jwt-auth.guard';
import { LocalAuthGuard } from './auth/local-auth.guard';
import { AuthService } from './auth/auth.service';

@Controller()
export class AppController {
  constructor(private authService: AuthService) {}

  @UseGuards(JwtAuthGuard)
  @Get('profile')
  getProfile(@Request() req) {
    return req.user;
  }
}