@nestjs/passport#AuthGuard TypeScript Examples

@Injectable()
export class FtAuthGuard extends AuthGuard('42') {
  handleRequest(err, user, info, context: ExecutionContext) {
    if (err || !user) {
      const res = context.switchToHttp().getResponse();
      return res.redirect('/');
    }
    return user;
  }
}

@Injectable()
export default class GoogleAuthGuard extends AuthGuard('google') {
  async canActivate(context: ExecutionContext): Promise<boolean | never> {
    const can = await super.canActivate(context);

    if (can) {
      const request = context.switchToHttp().getRequest();

      await super.logIn(request);
    }

    return true;
  }

  static getRequest(context: ExecutionContext) {
    return context.switchToHttp().getRequest();
  }
}

@UseGuards(AuthGuard('jwt'))
@ApiBearerAuth()
@Controller('global-search')
@ApiTags('GlobalSearch')
export class GlobalSearchController {
  constructor(private globalSearchService: GlobalSearchService) {}

  @ApiResponse({
    status: 200,
    type: ModuleSearchParentRecordDto,
    isArray: true,
  })
  @Get('/search-module-1/:modulePartialName/:page/:pageSize')
  async searchForModuleStep1(
    @Param('modulePartialName') modulePartialName: string,
    @Param('page') page: number = 0,
    @Param('pageSize') pageSize: number = 50,
  ): Promise<GetManyDefaultResponse<ModuleSearchParentRecordDto>> {
    return await this.globalSearchService.searchForModule(modulePartialName, page, pageSize);
  }

  @ApiResponse({
    status: 200,
    type: ModuleSearchChildRecordDto,
    isArray: true,
  })
  @Get('/search-module-2/:projectId/:modulePartialName/:page/:pageSize')
  async searchForModuleStep2(
    @Param('projectId') projectId: number,
    @Param('modulePartialName') modulePartialName: string,
    @Param('page') page: number = 0,
    @Param('pageSize') pageSize: number = 50,
  ): Promise<GetManyDefaultResponse<ModuleSearchChildRecordDto>> {
    return await this.globalSearchService.searchForModuleFromProject(projectId, modulePartialName, page, pageSize);
  }
}

/**
 * GqlAuthGuard translate GqlExecutionContext request => UseGuard
 *
 */
@Injectable()
export class GqlAuthGuard extends AuthGuard('jwt') {
  /**
   * getRequest return ExecutionContext as GqlExecutionContext request
   *
   * @param context
   */
  getRequest(context: ExecutionContext) {
    const ctx = GqlExecutionContext.create(context)

    return ctx.getContext().req
  }
}

@UseInterceptors(MorganInterceptor('combined'))
  @UseFilters(GithubAuthExceptionFilter)
  @Get('/github/callback')
  @UseGuards(AuthGuard('github'))
  async githubCallback(@Req() request: Request, @Res() response: Response) {
    const user: AuthUser = request.user as AuthUser;
    this.logger.log({
      level: 'info',
      message: `receive login callback from github account_id=${user.account.id}`
    });
    const token = await this.authService.prepareToken(user);
    response.redirect(301, `${this.host}?token=${token}`);
  }

@Injectable()
export class FirebaseAuthGuard extends AuthGuard('custom') {
  constructor(private reflector: Reflector) {
    super();
  }

  canActivate(context: ExecutionContext) {
    const isPublic = this.reflector.get<boolean>(
      'isPublic',
      context.getHandler(),
    );

    if (isPublic) {
      return true;
    }

    return super.canActivate(context);
  }
}

@Injectable()
export class JwtAuthGuard extends AuthGuard(AUTH_GUARD_TYPE) {
  canActivate(
    context: ExecutionContext
  ): boolean | Promise<boolean> | Observable<boolean> {
    // console.log(context.switchToHttp().getRequest().sessionID);
    return configuration().isAuthEnabled ? super.canActivate(context) : true;
  }
}

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    // Add your custom authentication logic here
    // for example, call super.logIn(request) to establish a session.
    return super.canActivate(context);
  }

  handleRequest(err, user, info) {
    // You can throw an exception based on either "info" or "err" arguments
    if (err || !user) {
      throw err || new UnauthorizedException();
    }
    return user;
  }
}

@Injectable()
export class JwtAuthGuard extends AuthGuard(STRATEGY_JWT_AUTH) {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    // Add your custom authentication logic here
    // for example, call super.logIn(request) to establish a session.
    return super.canActivate(context);
  }

  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  handleRequest(err, user, info) {
    // You can throw an exception based on either "info" or "err" arguments
    if (err || !user) {
      throw err || new UnauthorizedException(`${info}`);
    }
    return user;
  }
}

@Get('google/redirect')
  @UseGuards(AuthGuard('google'))
  async googleAuthRedirect(@Req() req, @Res() res) {
    const data = await this.authService.googleLogin(req);
    if (data) {
      res.redirect(
        process.env.FRONT_BASE_URL +
          '/aouth/google?token=' +
          data.token +
          '&type=' +
          data.type,
      );
    } else {
      throw new NotFoundException();
    }
  }

@Injectable()
export class GqlAuthGuard extends AuthGuard('jwt') {
  getRequest(context: ExecutionContext) {
    if (context.getType<any>() === 'graphql') {
      const ctx = GqlExecutionContext.create(context);

      if (!ctx.getContext().cache) {
        ctx.getContext().cache = new ContextCache()
      }
      return ctx.getContext().req;
    }

    return context.switchToHttp().getRequest()
  }

  handleRequest<T = UserEntity>(err, user: T): T {
    if (err) {
      throw new Error('invalid token')
    }

    return user
  }
}

@ApiOperation({ summary: 'Validate authentication token' })
  @ApiOkResponse({ description: 'Authentication token is valid' })
  @ApiUnauthorizedResponse({ description: 'The authentication token is invalid' })
  @UseGuards(AuthGuard())
  @ApiBearerAuth()
  @Get()
  @HttpCode(HttpStatus.OK)
  // eslint-disable-next-line @typescript-eslint/no-empty-function
  isAuthenticated(): void { }

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

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

@Injectable()
export default class JwtAccessGuard extends AuthGuard('accessToken') {}