NestJS interview questions and answers

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  async validate(payload: { sub: string; email: string }): Promise<{ id: string; email: string }> {
    return { id: payload.sub, email: payload.email }; // -> req.user
  }
}

ConfigModule.forRoot({
  // Default looks for ./.env relative to process.cwd()
  envFilePath: '.env', // explicit, same as default
});

import { Controller, Get, Query } from '@nestjs/common';

@Controller('products')
export class ProductsController {
  @Get()
  list(@Query('category') category: string, @Query('sort') sort: string): string {
    return `category=${category} sort=${sort}`;
  }
}

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class Article {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 200 })
  title: string;

  @Column({ type: 'text', nullable: true })
  body: string | null;
}

import { Module } from '@nestjs/common';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';

@Module({
  imports: [],
  controllers: [CatsController],
  providers: [CatsService],
  exports: [CatsService],
})
export class CatsModule {}

import { Controller } from '@nestjs/common';
import { EventPattern, Payload } from '@nestjs/microservices';

@Controller()
export class UserEventsController {
  @EventPattern('user.created')
  handleUserCreated(@Payload() data: { id: string }) {
    // process asynchronously; nothing returned to producer
  }
}

configure(consumer: MiddlewareConsumer): void {
  consumer
    .apply(LoggerMiddleware)
    .forRoutes('users'); // only /users and its sub-paths
}

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const req = context.switchToHttp().getRequest();
    return Boolean(req.headers.authorization);
  }
}

@Module({
  providers: [
    CatsService,                          // class provider
    { provide: 'API_KEY', useValue: 'abc' }, // value provider
  ],
})
export class CatsModule {}

const repo = { findById: jest.fn().mockResolvedValue({ id: '1' }) };
await service.load('1');
expect(repo.findById).toHaveBeenCalledWith('1');

import { SetMetadata } from '@nestjs/common';

export const IS_PUBLIC_KEY = 'isPublic';
export const Public = (): MethodDecorator & ClassDecorator =>
  SetMetadata(IS_PUBLIC_KEY, true);

// usage
@Public()
@Get('health')
health(): string {
  return 'ok';
}

import databaseConfig from './database.config'; // registerAs('database', ...)

@Module({
  imports: [ConfigModule.forFeature(databaseConfig)],
})
export class DatabaseModule {}

import { Controller, Get, Param } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly users: UsersService) {}

  @Get(':id')
  async findOne(@Param('id') id: string) {
    return await this.users.findOne(id); // resolved value is serialized
  }
}

await userRepo.find({ relations: ['posts'] });

// nested object form, also supports deep relations
await userRepo.find({
  relations: { posts: { comments: true } },
});

@Global()
@Module({
  providers: [ConfigService],
  exports: [ConfigService],
})
export class ConfigModule {}

@EventPattern('user.created')
handle(@Payload() data: { id: string }, @Ctx() context: KafkaContext) {
  const topic = context.getTopic();
  // data = message body, context = transport metadata
}

import { RequestMethod } from '@nestjs/common';

consumer
  .apply(LoggerMiddleware)
  .forRoutes({ path: 'cats', method: RequestMethod.POST }); // only POST /cats

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

@Injectable()
export class TokenGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    return typeof request.headers['x-token'] === 'string';
  }
}

@Module({
  providers: [
    LoggerService,
    { provide: 'AppLogger', useExisting: LoggerService }, // alias, same instance
  ],
})
export class AppModule {}

import * as request from 'supertest';

const res = await request(app.getHttpServer()).get('/users').expect(200);
expect(res.body).toEqual([]);

async revoke(jti: string, expSeconds: number): Promise<void> {
  await redis.set(`bl:${jti}`, '1', 'EX', expSeconds);
}
async assertNotRevoked(jti: string): Promise<void> {
  if (await redis.exists(`bl:${jti}`)) throw new UnauthorizedException('Token revoked');
}

// Precedence (highest first):
// 1) existing process.env (shell/CI)
// 2) .env.local   (first in array)
// 3) .env         (later in array)

import { MiddlewareConsumer, NestModule, RequestMethod, Module } from '@nestjs/common';
import { LoggerMiddleware } from './logger.middleware';

@Module({})
export class UsersModule implements NestModule {
  configure(consumer: MiddlewareConsumer): void {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes({ path: 'users', method: RequestMethod.GET });
  }
}

TypeOrmModule.forRoot({ name: 'reporting', type: 'postgres', /* ... */ });

@Module({ imports: [TypeOrmModule.forFeature([Stat], 'reporting')] })
export class ReportingModule {}

@Injectable()
class StatsService {
  constructor(
    @InjectRepository(Stat, 'reporting') private stats: Repository<Stat>,
  ) {}
}

@Injectable() // default DEFAULT scope → one instance app-wide
export class CounterService {
  private count = 0; // shared across all consumers — beware request state
  inc(): number { return ++this.count; }
}

// JetStream-style options enable persistence/acks
ClientsModule.register([{
  name: 'NATS',
  transport: Transport.NATS,
  options: { servers: ['nats://localhost:4222'], jetstream: true },
}]);

catch(exception: unknown, host: ArgumentsHost): void {
  if (host.getType() === 'http') {
    const res = host.switchToHttp().getResponse();
    // build HTTP response
  } else if (host.getType() === 'ws') {
    const client = host.switchToWs().getClient();
    // emit WS error
  }
}

const roles = this.reflector.getAllAndMerge<string[]>('roles', [
  context.getHandler(),
  context.getClass(),
]); // e.g. class ['user'] + method ['admin'] => ['admin','user']

import { Injectable, Scope } from '@nestjs/common';

@Injectable({ scope: Scope.REQUEST, durable: true })
export class TenantConnection {}
// Combined with a custom ContextIdStrategy keyed on tenant id,
// instances are reused per tenant rather than per request.

const service = await moduleRef.resolve(RequestScopedService);
expect(service).toBeDefined();