@nestjs/core#Reflector TypeScript Examples

describe('AccessGuard', () => {
  const req = new Object();
  let abilityMetadata: unknown = {};
  let accessGuard: AccessGuard;
  let accessService: AccessService;

  beforeEach(async () => {
    CaslConfig.getRootOptions = jest.fn().mockImplementation(() => ({}));

    const moduleRef = await Test.createTestingModule({
      providers: [
        AccessGuard,
        { provide: Reflector, useValue: { get: jest.fn().mockImplementation(() => abilityMetadata) } },
        { provide: AccessService, useValue: { canActivateAbility: jest.fn() } },
      ],
    }).compile();

    accessService = moduleRef.get<AccessService>(AccessService);
    accessGuard = moduleRef.get<AccessGuard>(AccessGuard);
  });

  it('passes context request and ability to AccessService.canActivateAbility method', async () => {
    const context = new ExecutionContextHost([req, undefined, { req }]);
    await accessGuard.canActivate(context);
    expect(accessService.canActivateAbility).toBeCalledWith(req, abilityMetadata);
  });

  it('passes context request and ability to AccessService.canActivateAbility method', async () => {
    abilityMetadata = undefined;
    const context = new ExecutionContextHost([req, undefined, { req }]);
    await accessGuard.canActivate(context);
    expect(accessService.canActivateAbility).toBeCalledWith(req, abilityMetadata);
  });
});

constructor(
    @Inject(KEYCLOAK_INSTANCE)
    private singleTenant: KeycloakConnect.Keycloak,
    @Inject(KEYCLOAK_CONNECT_OPTIONS)
    private keycloakOpts: KeycloakConnectConfig,
    @Inject(KEYCLOAK_LOGGER)
    private logger: Logger,
    private multiTenant: KeycloakMultiTenantService,
    private readonly reflector: Reflector,
  ) {}

describe('Set recaptcha options decorator', () => {
    let controller: TestController;
    let reflector: Reflector;

    beforeAll(async () => {
        controller = new TestController();
        reflector = new Reflector();
    });

    test('Test options', () => {
        const executionContext = createExecutionContext(controller.submitWithSetRecaptchaOptionsDecorator, {});
        const handler = executionContext.getHandler();

        const options: VerifyResponseDecoratorOptions = reflector.get(RECAPTCHA_VALIDATION_OPTIONS, handler);

        expect(options.response).toBeUndefined();
        expect(options.action).toBe('TestOptions');
        expect(options.score).toBe(0.5);
    });
});

constructor(
    @Inject(KEYCLOAK_INSTANCE)
    private singleTenant: KeycloakConnect.Keycloak,
    @Inject(KEYCLOAK_CONNECT_OPTIONS)
    private keycloakOpts: KeycloakConnectConfig,
    @Inject(KEYCLOAK_LOGGER)
    private logger: Logger,
    private multiTenant: KeycloakMultiTenantService,
    private readonly reflector: Reflector,
  ) {}

static forRoot(options: GoogleRecaptchaModuleOptions): DynamicModule {
        const providers: Provider[] = [
            GoogleRecaptchaGuard,
            GoogleRecaptchaValidator,
            RecaptchaRequestResolver,
            {
                provide: RECAPTCHA_OPTIONS,
                useValue: options,
            },
        ];

        const httpModule = this.resolveHttpModule();

        const internalProviders: Provider[] = [
            Reflector,
            {
                provide: RECAPTCHA_HTTP_SERVICE,
                useFactory: (axiosInstance: axios.AxiosInstance) => new httpModule.HttpService(axiosInstance),
                inject: [
                    RECAPTCHA_AXIOS_INSTANCE,
                ],
            },
            {
                provide: RECAPTCHA_AXIOS_INSTANCE,
                useFactory: () => axios.default.create(this.transformAxiosConfig(options.axiosConfig)),
            },
        ];

        return {
            global: true,
            module: GoogleRecaptchaModule,
            imports: [
                httpModule.HttpModule,
            ],
            providers: providers.concat(internalProviders),
            exports: providers,
        }
    }

async function bootstrap(): Promise<void> {
  initializeTransactionalContext();
  patchTypeORMRepositoryWithBaseRepository();

  const app = await NestFactory.create<NestExpressApplication>(
    AppModule,
    new ExpressAdapter(),
    { cors: true },
  );

  app.enable('trust proxy');
  app.use(helmet());
  app.use(RateLimit({ windowMs: 15 * 60 * 1000, max: 200 }));
  app.use(compression());
  app.use(morgan('combined'));
  app.setGlobalPrefix('bank');

  const reflector = app.get(Reflector);

  app.useGlobalInterceptors(new ClassSerializerInterceptor(reflector));
  app.useGlobalFilters(
    new HttpExceptionFilter(reflector),
    new QueryFailedFilter(reflector),
  );
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      transform: true,
      dismissDefaultMessages: true,
      validationError: { target: false },
    }),
  );

  setupSwagger(app);

  const configService = app.get(ConfigService);
  await app.listen(configService.get('PORT'));
}

private readonly reflector = new Reflector();

constructor(
    @InjectTracer()
    private readonly tracer: Tracer,
    @InjectTracerProvider()
    private readonly tracerProvider: TracerProvider,
    private readonly asyncContext: AsyncContext,
    private readonly reflector: Reflector,
  ) {}

constructor(private readonly reflector: Reflector) {}

constructor(
    private reflector: Reflector,
    private readonly accessService: AccessService,
    private moduleRef: ModuleRef,
  ) {}

describe('RolesGuard', () => {
  let guard: RolesGuard;
  let reflector: Reflector;
  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        RolesGuard,
        {
          provide: Reflector,
          useValue: {
            constructor: jest.fn(),
            get: jest.fn(),
          },
        },
      ],
    }).compile();

    guard = module.get<RolesGuard>(RolesGuard);
    reflector = module.get<Reflector>(Reflector);
  });

  afterEach(async () => {
    jest.clearAllMocks();
  });

  it('should be defined', () => {
    expect(guard).toBeDefined();
  });

  it('should skip(return true) if the `HasRoles` decorator is not set', async () => {
    jest.spyOn(reflector, 'get').mockImplementation((a: any, b: any) => []);
    const context = createMock<ExecutionContext>();
    const result = await guard.canActivate(context);

    expect(result).toBeTruthy();
    expect(reflector.get).toBeCalled();
  });

  it('should return true if the `HasRoles` decorator is set', async () => {
    jest
      .spyOn(reflector, 'get')
      .mockImplementation((a: any, b: any) => [RoleType.USER]);
    const context = createMock<ExecutionContext>({
      getHandler: jest.fn(),
      switchToHttp: jest.fn().mockReturnValue({
        getRequest: jest.fn().mockReturnValue({
          user: { roles: [RoleType.USER] },
        } as AuthenticatedRequest),
      }),
    });

    const result = await guard.canActivate(context);
    expect(result).toBeTruthy();
    expect(reflector.get).toBeCalled();
  });

  it('should return false if the `HasRoles` decorator is set but role is not allowed', async () => {
    jest.spyOn(reflector, 'get').mockReturnValue([RoleType.ADMIN]);
    const request = {
      user: { roles: [RoleType.USER] },
    } as AuthenticatedRequest;
    const context = createMock<ExecutionContext>();
    const httpArgsHost = createMock<HttpArgumentsHost>({
      getRequest: () => request,
    });
    context.switchToHttp.mockImplementation(() => httpArgsHost);

    const result = await guard.canActivate(context);
    expect(result).toBeFalsy();
    expect(reflector.get).toBeCalled();
  });
});

constructor(private reflector: Reflector) {}

reflector: Reflector = new Reflector();

constructor(private reflector: Reflector) {}

constructor(private reflector: Reflector) {}

constructor(public reflector: Reflector) {}

constructor(
    private readonly reflector: Reflector
  ) {}

constructor(
    private readonly reflector: Reflector
  ) {}

constructor(
		private reflector: Reflector,
		private auditLogService: AuditLogService,
	) {}

constructor(private readonly reflector: Reflector) {}

constructor(private authService: AuthService, private reflector: Reflector) {
    super();
  }

constructor(
    @Inject(KeycloakService)
    private keycloak: KeycloakService,
    @Inject(Reflector.name)
    private readonly reflector: Reflector
  ) {}

constructor(private reflector: Reflector) {}

constructor(
    private reflector: Reflector,
  ) { }

constructor(private reflector: Reflector, private userService: UserService) {}

constructor(private readonly reflector: Reflector) {
    super();
  }

constructor(private reflector: Reflector) { }

constructor(
    @Inject(KeycloakService)
    private keycloak: KeycloakService,
    private readonly reflector: Reflector
  ) {}

constructor(
    @InjectRepository(Collection)
    private collectionRepository: Repository<Collection>,

    private reflector: Reflector,
  ) {}