@nestjs/common#ExecutionContext TypeScript Examples

async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();

    const authorization = request.headers['authorization'];
    if (authorization && authorization.startsWith('Bearer ')) {
      const token = authorization.substring(7, authorization.length);

      request.user = await admin.auth().verifyIdToken(token);
      return !!request.user;
    }
    return false;
  }

extractRequest = (context: ExecutionContext): [any, any] => {
  let request: any, response: any;

  // Check if request is coming from graphql or http
  if (context.getType() === 'http') {
    // http request
    const httpContext = context.switchToHttp();

    request = httpContext.getRequest();
    response = httpContext.getResponse();
  } else if (context.getType<GqlContextType>() === 'graphql') {
    let gql: any;
    // Check if graphql is installed
    try {
      gql = require('@nestjs/graphql');
    } catch (er) {
      throw new Error('@nestjs/graphql is not installed, cannot proceed');
    }

    // graphql request
    const gqlContext = gql.GqlExecutionContext.create(context).getContext();

    request = gqlContext.req;
    response = gqlContext.res;
  }

  return [request, response];
}

intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const now = Date.now();
    return next
      .handle()
      .pipe(
        tap(() =>
          this.logger.log(
            context.switchToHttp().getRequest().route.path,
            context.getHandler().name,
            Date.now() - now + 'ms',
          ),
        ),
      );
  }

export function GCloudStorageFilesInterceptor(
  fieldName: string,
  localOptions?: MulterOptions,
  gcloudStorageOptions?: Partial<GCloudStoragePerRequestOptions>,
): Type<NestInterceptor> {
  @Injectable()
  class MixinInterceptor implements NestInterceptor {
    public interceptor: NestInterceptor;

    constructor(private readonly gcloudStorage: GCloudStorageService) {
      this.interceptor = new (FilesInterceptor(fieldName, 20, localOptions))();
    }

    async intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>> {
      (await this.interceptor.intercept(context, next)) as Observable<any>;

      const request = context.switchToHttp().getRequest();

      const files = request[fieldName];

      if (!files.length) {
        Logger.error(
          'GCloudStorageFilesInterceptor',
          `Can not intercept field "${fieldName}". Did you specify the correct field name in @GCloudStorageFilesInterceptor('${fieldName}')?`,
        );
        return;
      }

      for (const file of files) file.storageUrl = await this.gcloudStorage.upload(file, gcloudStorageOptions);

      return next.handle();
    }
  }

  const Interceptor = mixin(MixinInterceptor);
  return Interceptor as Type<NestInterceptor>;
}

async canActivate(context: ExecutionContext): Promise<boolean> {
        if (getStoreItem('cmsSettings')?.installed === false) return true;

        const request: TRequestWithUser = context.switchToHttp().getRequest();
        if (!request.user?.id) return false;

        const roles = this.reflector.get<TAuthRole[]>('roles', context.getHandler());
        return matchRoles(request.user, roles);
    }

static create(context: ExecutionContext): GqlExecutionContext {
    const type = context.getType();
    const gqlContext = new GqlExecutionContext(
      context.getArgs(),
      context.getClass(),
      context.getHandler(),
    );
    gqlContext.setType(type);
    return gqlContext;
  }

canActivate(context: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!roles) {
      return true;
    }
    const request = context.switchToHttp().getRequest();
    const user = request.user;
    return true;
    // matchRoles를 구현하면 Role 체크가 가능하다.
    // return matchRoles(roles, user.roles);
  }

async canActivate(
    context: ExecutionContext,
  ): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const user = (request as any).user;
    const body = (request as any).body;
    console.log({ params: request.params, body, user, IsOwnerGuard: true });
    return this.canI(+request.params.id, +user.id);
  }

async canActivate(context: ExecutionContext): Promise<boolean> {
    const roles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!roles) {
      return true;
    }
    const request: Request = context.switchToHttp().getRequest();
    const user = request.user as UserDocument;

    return user.role === RolesEnum.admin || roles.includes(user.role);
  }

intercept(
    _context: ExecutionContext,
    next: CallHandler,
  ): Observable<ExceptionBase> {
    return next.handle().pipe(
      catchError(err => {
        /**
         * Custom exceptions are converted to nest.js exceptions.
         * This way we are not tied to a framework or HTTP protocol.
         */
        if (err instanceof NotFoundException) {
          throw new NestNotFoundException(err.message);
        }
        if (err instanceof ConflictException) {
          throw new NestConflictException(err.message);
        }
        return throwError(err);
      }),
    );
  }

/**
   * getRequest return ExecutionContext as GqlExecutionContext request
   *
   * @param context
   */
  getRequest(context: ExecutionContext) {
    const ctx = GqlExecutionContext.create(context)

    return ctx.getContext().req
  }

async canActivate(context: ExecutionContext) {
    const request = context.switchToHttp().getRequest();

    if (request?.user) {
      const { id } = request.user;
      const user = await this.userService.getUserById(id);
      return user.role === UserRoles.ADMIN;
    }

    return false;
  }

canActivate(
    context: ExecutionContext
  ): boolean | Promise<boolean> | Observable<any> {
    const isPublic = this.reflector.get<boolean>(
      IS_PUBLIC_KEY,
      context.getHandler()
    );

    if (isPublic) {
      return true;
    }

    return super.canActivate(context);
  }

async canActivate(context: ExecutionContext): Promise<boolean> {
    const isPublic: boolean = this.reflector.get<boolean>(META_PUBLIC, context.getHandler())

    if (isPublic) {
      return true
    }

    const request = extractRequest(context)
    const jwt = this.extractJwt(request.headers)

    try {
      const result = await this.keycloak.connect.grantManager.validateAccessToken(jwt)

      if (typeof result === 'string') {
        request.user = await this.keycloak.connect.grantManager.userInfo<string, KeycloakUser>(jwt)
        request.accessToken = jwt
        return true
      }
    } catch (error) {
      this.logger.warn(`Error occurred validating token`, error)
    }

    throw new UnauthorizedException()
  }

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

    if (isPublic) {
      return true;
    }

    const request = context.switchToHttp().getRequest();
    const { user }: { user: User } = request;
    const { collectionId }: { collectionId: string } = request.params;

    if (!Number.isNaN(parseInt(collectionId, 10))) {
      const hasCollection = await this.collectionRepository.findOne({
        where: {
          id: collectionId,
          user,
        },
      });

      return !!hasCollection;
    }

    return false;
  }

export declare class ExecutionContextHost implements ExecutionContext {
    private readonly args;
    private readonly constructorRef;
    private readonly handler;
    private contextType;
    constructor(args: any[], constructorRef?: Type<any>, handler?: Function);
    setType<TContext extends string = ContextType>(type: TContext): void;
    getType<TContext extends string = ContextType>(): TContext;
    getClass<T = any>(): Type<T>;
    getHandler(): Function;
    getArgs<T extends Array<any> = any[]>(): T;
    getArgByIndex<T = any>(index: number): T;
    switchToRpc(): RpcArgumentsHost;
    switchToHttp(): HttpArgumentsHost;
    switchToWs(): WsArgumentsHost;
}

RecaptchaResult = createParamDecorator((data, context: ExecutionContext) => {
    switch (context.getType<'http' | 'graphql'>()) {
        case 'http':
            return context.switchToHttp().getRequest().recaptchaValidationResult;
        case 'graphql':
            const graphqlModule = loadModule('@nestjs/graphql', true);
            return graphqlModule.GqlExecutionContext.create(context).getContext().req?.connection?._httpMessage?.req?.recaptchaValidationResult;
        default:
            return null;
    }
})

canActivate(context: ExecutionContext): boolean {
    const roles = this.reflector.get<UserRole[]>(
      UserRole,
      context.getHandler()
    );
    if (!roles || !configuration().isAuthEnabled) return true;

    const request = context.switchToHttp().getRequest<Request>();
    const { role } = request.user as JwtPayload;
    return roles.includes(role);
  }

canActivate(context: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!roles) {
      return true;
    }
    const request = context.switchToHttp().getRequest();
    const user = request['user'];
    const hasRole = () => roles.includes(user.role);
    return user && user.role && hasRole();
  }

Tracing = createParamDecorator(
  (key: keyof TracingData, context: ExecutionContext) => {
    const contextType = context.getType<GqlContextType>();
    let tracingData: TracingData;
    if (contextType === 'graphql') {
      const ctx = GqlExecutionContext.create(context);
      tracingData = ctx.getContext<TracingObject>().tracing;
    }
    if (contextType === 'http') {
      const ctx = context.switchToHttp();
      tracingData = ctx.getRequest<TracingObject>().tracing;
    }
    if (contextType === 'rpc') {
      const ctx = context.switchToRpc();
      tracingData = ctx.getContext<TracingObject>().tracing;
    }
    return key ? tracingData && tracingData[key] : tracingData;
  },
)

async canActivate(context: ExecutionContext): Promise<boolean> {
    const ability = this.reflector.get<AbilityMetadata | undefined>(CASL_META_ABILITY, context.getHandler());
    const request = await ContextProxy.create(context).getRequest();
    const { getUserHook } = CaslConfig.getRootOptions();
    const req = new RequestProxy(request);

    req.setUserHook(await userHookFactory(this.moduleRef, getUserHook));
    req.setSubjectHook(await subjectHookFactory(this.moduleRef, ability?.subjectHook));

    return await this.accessService.canActivateAbility(request, ability);
  }

describe('LocalAuthGuard', () => {
  let guard: LocalAuthGuard;
  beforeEach(() => {
    guard = new LocalAuthGuard();
  });
  it('should be defined', () => {
    expect(guard).toBeDefined();
  });
  it('should return true for `canActivate`', async () => {
    AuthGuard('local').prototype.canActivate = jest.fn(() =>
      Promise.resolve(true),
    );
    AuthGuard('local').prototype.logIn = jest.fn(() => Promise.resolve());
    expect(await guard.canActivate({} as ExecutionContext)).toBe(true);
  });

});

canActivate(context: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>('roles', context.getHandler())
    if (!roles) {
      return true
    }
    const request = context.switchToHttp().getRequest()
    const user = request.user
    return roles.includes(user.role)
  }

canActivate(context: ExecutionContext): boolean {
    const request: ExtRequest = context.switchToHttp().getRequest()

    if (request.user && request.user.id > 0) {
      return true
    } else {
      throw new HttpException(INVALID_AUTH_INFO, HttpStatus.UNAUTHORIZED)
    }
  }

intercept(
    context: ExecutionContext,
    next: CallHandler<unknown>,
  ): Observable<unknown> {
    const start = new Date().getTime();
    return next.handle().pipe(
      tap(() => {
        const duration = new Date().getTime() - start;

        const request = context.switchToHttp().getRequest<Request>();
        if (!request) {
          return;
        }

        this.datadogService.timing('requests.success', duration, {
          method: request.method,
          path: request.path,
        });
      }),
      catchError((error: Error) => {
        let method = 'no-method';
        let path = 'no-path';

        const request = context.switchToHttp().getRequest<Request>();
        if (request) {
          method = request.method;
          path = request.path;
        }

        this.datadogService.increment('requests.error', 1, {
          method,
          path,
          type: error.constructor.name,
        });

        return throwError(() => error);
      }),
    );
  }

intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const req = context.getArgByIndex(0);
    this.logger.debug(
      `${context.getType()}: ${req.socket.remoteAddress} => Request: ${
        req.url
      }`,
    );

    const response: Response = context.switchToHttp().getResponse();

    response.setHeader('X-Powered-By', 'EmuTypekov');
    response.setHeader('Set-Cookie', 'PHPSESSID=undefined');

    return next.handle().pipe(
      map((body) => {
        return body;
      }),
    );
  }

intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest()
    const method = request.method
    const url = request.originalUrl
    const requestID = request.headers[REQUEST_ID_TOKEN_HEADER]

    this.appLogger.log({ method, requestID, url })

    const now = Date.now()
    return next.handle().pipe(
      tap(() => {
        const response = context.switchToHttp().getResponse()
        const statusCode = response.statusCode

        const responseTime = Date.now() - now
        this.appLogger.log({ method, requestID, url, statusCode, responseTime })
      })
    )
  }

canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.getAllAndOverride<ROLE[]>(ROLES_KEY, [
      context.getHandler(),
      context.getClass(),
    ]);

    if (!requiredRoles) {
      return true;
    }
    const { user } = context.switchToHttp().getRequest();

    if (requiredRoles.some((role) => user.roles?.includes(role))) {
      return true;
    }

    throw new UnauthorizedException(
      `User with roles ${user.roles} does not have access to this route with roles ${requiredRoles}`,
    );
  }

intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const now = Date.now();
    const req = context.switchToHttp().getRequest();

    const method = req.method;
    const url = req.url;

    return next
      .handle()
      .pipe(
        tap(() =>
          Logger.log(
            `${method} ${url} ${Date.now() - now}ms`,
            context.getClass().name,
          ),
        ),
      );
  }