NestJS Administrator & Developer Guide

1. Architecture Overview

NestJS is a TypeScript-first framework for building server-side Node.js applications. It provides a modular, decorator-driven architecture inspired by Angular, centered around dependency injection, a request processing pipeline, and platform-agnostic HTTP layer abstractions. The framework is published as a monorepo of packages under the @nestjs scope, each addressing a specific concern — from HTTP handling to microservices, WebSockets, and testing.

The core design philosophy separates the framework into three layers: the platform layer (HTTP adapters for Express or Fastify), the core layer (DI container, lifecycle management, routing, middleware pipeline), and the common layer (decorators, interfaces, pipes, exceptions, and utilities shared across all parts of the framework).

Architecture Diagram

                    ┌─────────────────────────────────────────┐
                    │              NestFactory                 │
                    │  create() / createMicroservice()         │
                    └─────────────┬───────────────────────────┘
                                  │
                    ┌─────────────▼───────────────────────────┐
                    │         NestApplication                  │
                    │  ┌──────────────────────────────────┐   │
                    │  │      ApplicationConfig            │   │
                    │  │  (global prefix, versioning,      │   │
                    │  │   pipes, guards, interceptors,    │   │
                    │  │   filters, WebSocket adapter)     │   │
                    │  └──────────────────────────────────┘   │
                    │  ┌──────────────────────────────────┐   │
                    │  │       NestContainer               │   │
                    │  │  ┌────────┐  ┌────────┐          │   │
                    │  │  │Module A│  │Module B│  ...      │   │
                    │  │  │ provs  │  │ provs  │          │   │
                    │  │  │ ctrls  │  │ ctrls  │          │   │
                    │  │  └────────┘  └────────┘          │   │
                    │  └──────────────────────────────────┘   │
                    │  ┌──────────────────────────────────┐   │
                    │  │    Request Pipeline               │   │
                    │  │  Middleware → Guards → Intercept  │   │
                    │  │  → Pipes → Handler → Intercept   │   │
                    │  │  → Exception Filters              │   │
                    │  └──────────────────────────────────┘   │
                    └─────────────┬───────────────────────────┘
                                  │
                    ┌─────────────▼───────────────────────────┐
                    │      Platform Adapter (HTTP)             │
                    │  ExpressAdapter  │  FastifyAdapter        │
                    └──────────────────────────────────────────┘

Component Inventory

Technology Stack

Data Flow: HTTP Request

1. HTTP request arrives at the platform adapter (Express/Fastify)
2. Global middleware executes in registration order
3. Module-scoped middleware executes for matching routes
4. Guards evaluate (canActivate) — reject returns 403 Forbidden
5. Pre-handler interceptors execute (intercept before next.handle())
6. Pipes transform/validate parameters
7. Route handler executes
8. Post-handler interceptors process the response Observable
9. Exception filters catch any thrown errors, format the response
10. Response is sent to the client

2. System Requirements

TypeScript Configuration Requirements

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "ES2021",
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "strictNullChecks": true,
    "declaration": true,
    "sourceMap": true,
    "outDir": "./dist"
  }
}

Important

emitDecoratorMetadata and experimentalDecorators are mandatory. Without them, dependency injection based on constructor parameter types will not work.

ESM Support

NestJS supports ECMAScript Modules (ESM) from Node.js 22+. For ESM projects, set "type": "module" in package.json and use the load-esm package (bundled dependency) for dynamic imports of ESM-only packages. Sample applications 34-using-esm-packages and 35-use-esm-package-after-node22 demonstrate the pattern.

3. Configuration Reference

NestFactory.create() Options

Application Instance Methods

Environment Variables

Note

NEST_DEBUG is extremely verbose and intended for debugging circular dependency or missing provider issues. Do not enable in production.

Global Prefix Options

app.setGlobalPrefix('api', {
  exclude: [
    { path: 'health', method: RequestMethod.GET },
    { path: '/', method: RequestMethod.GET },
  ],
});

Versioning Options

Module-Level Registration via APP_* Tokens

Instead of app.useGlobal*(), register enhancers within the DI system using special tokens:

import { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER } from '@nestjs/core';

@Module({
  providers: [
    { provide: APP_GUARD, useClass: AuthGuard },
    { provide: APP_PIPE, useClass: ValidationPipe },
    { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
    { provide: APP_FILTER, useClass: AllExceptionsFilter },
  ],
})
export class AppModule {}

Tip

Using APP_* tokens allows enhancers to participate in dependency injection (they can inject other providers). app.useGlobal*() registers instances outside the DI container.

4. Deployment & Scaling

Production Build

npm run build        # Compile TypeScript → dist/
node dist/main.js    # Run production build

For monorepo workspaces:

npx tsc -b -v packages   # Build all packages

Fastify Adapter (Production)

Fastify provides significantly higher throughput than Express. Switch by replacing the platform package:

import { NestFactory } from '@nestjs/core';
import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';

const app = await NestFactory.create<NestFastifyApplication>(
  AppModule,
  new FastifyAdapter({ logger: true }),
);
await app.listen(3000, '0.0.0.0');

Warning

Fastify binds to localhost by default. In containerized environments, you must bind to 0.0.0.0 or the container's network interface.

Docker Deployment

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
EXPOSE 3000
CMD ["node", "dist/main.js"]

Webpack Bundling

NestJS supports Webpack for bundling applications into a single file:

nest build --webpack

Sample 08-webpack demonstrates this pattern with HotModuleReplacementPlugin for development.

Graceful Shutdown

const app = await NestFactory.create(AppModule);
app.enableShutdownHooks();

// Or with specific signals and options:
app.enableShutdownHooks([ShutdownSignal.SIGTERM, ShutdownSignal.SIGINT], {
  useProcessExit: true,  // Required for async loggers (e.g., Pino with transports)
});

Shutdown signal lifecycle:

1. Signal received → onModuleDestroy() (reverse module order)
2. beforeApplicationShutdown(signal) (reverse module order)
3. Server connections closed
4. onApplicationShutdown(signal) (reverse module order)
5. Process exits

Hybrid Applications (HTTP + Microservices)

const app = await NestFactory.create(AppModule);

// Attach a TCP microservice
app.connectMicroservice<MicroserviceOptions>({
  transport: Transport.TCP,
  options: { host: '0.0.0.0', port: 3001 },
});

// Attach a Redis microservice
app.connectMicroservice<MicroserviceOptions>({
  transport: Transport.REDIS,
  options: { host: 'localhost', port: 6379 },
});

await app.startAllMicroservices();
await app.listen(3000);

5. Operations

Logging

NestJS ships with a built-in Logger and ConsoleLogger service.

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

@Injectable()
export class CatsService {
  private readonly logger = new Logger(CatsService.name);

  findAll() {
    this.logger.log('Fetching all cats');
    this.logger.warn('This is a warning');
    this.logger.error('Something failed', stackTrace);
    this.logger.debug('Debug info');
    this.logger.verbose('Verbose info');
  }
}

Log levels (in order): verbose, debug, log, warn, error, fatal

Configure at bootstrap:

const app = await NestFactory.create(AppModule, {
  logger: ['error', 'warn', 'log'],
});

Tip

Replace the built-in logger with a production logger (Winston, Pino, etc.) by implementing LoggerService and calling app.useLogger(myLogger).

Note

The ConsoleLogger class can be extended for custom formatting while retaining NestJS's log level filtering logic. Unlike Logger (which is a static wrapper), ConsoleLogger is instantiable and supports dependency injection.

Health Checks

Use @nestjs/terminus (separate package) for health check endpoints:

npm i @nestjs/terminus

@Controller('health')
export class HealthController {
  constructor(
    private health: HealthCheckService,
    private db: TypeOrmHealthIndicator,
  ) {}

  @Get()
  check() {
    return this.health.check([
      () => this.db.pingCheck('database'),
    ]);
  }
}

Monitoring and Metrics

The DiscoveryService and GraphInspector from @nestjs/core provide introspection capabilities:

import { DiscoveryService } from '@nestjs/core';

@Injectable()
export class MetricsService {
  constructor(private readonly discovery: DiscoveryService) {}

  getProviderCount(): number {
    return this.discovery.getProviders().length;
  }

  getControllerCount(): number {
    return this.discovery.getControllers().length;
  }
}

Note

A community feature request for a native metrics module exists (nestjs/nest#967) but is not yet implemented. Use third-party packages like @willsoto/nestjs-prometheus or custom interceptors for request metrics.

REPL Mode

Start an interactive REPL for debugging and exploration:

// repl.ts
import { repl } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const replServer = await repl(AppModule);
  replServer.setupHistory('.nestjs_repl_history', (err) => {
    if (err) console.error(err);
  });
}
bootstrap();

npx ts-node repl.ts

Built-in REPL functions:

6. Performance

Express vs. Fastify

The repository includes a benchmark suite (tools/benchmarks/) that compares Express and Fastify adapters:

Tip

For high-throughput APIs, use @nestjs/platform-fastify. The Fastify adapter supports fast-json-stringify for schema-based response serialization, which can further improve throughput for JSON-heavy APIs.

Injection Scopes and Performance

Warning

REQUEST scope propagates up the dependency chain. If a singleton depends on a request-scoped provider, the singleton must also become request-scoped. Design the dependency graph carefully to avoid unintended scope bubbling.

Lazy Module Loading

Load modules on demand to reduce startup time:

@Injectable()
export class AppService {
  constructor(private readonly loader: LazyModuleLoader) {}

  async loadReporting() {
    const { ReportingModule } = await import('./reporting/reporting.module');
    const moduleRef = await this.loader.load(() => ReportingModule);
    const service = moduleRef.get(ReportingService);
    return service.generateReport();
  }
}

7. Security

CORS Configuration

app.enableCors({
  origin: ['https://example.com', 'https://admin.example.com'],
  methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
  credentials: true,
  allowedHeaders: 'Content-Type,Authorization',
  exposedHeaders: 'X-Total-Count',
  maxAge: 3600,
});

Helmet Integration

npm i helmet

import helmet from 'helmet';

const app = await NestFactory.create(AppModule);
app.use(helmet());

Rate Limiting

npm i @nestjs/throttler

@Module({
  imports: [
    ThrottlerModule.forRoot({ ttl: 60, limit: 10 }),
  ],
})
export class AppModule {}

Authentication Patterns

NestJS integrates with Passport.js for authentication. The sample 19-auth-jwt demonstrates JWT authentication with:

1. JwtStrategy extending PassportStrategy(Strategy) — validates JWT tokens
2. AuthService — handles login logic and token generation
3. JwtAuthGuard extending AuthGuard('jwt') — protects routes
4. Public decorator — marks routes as public (skips authentication)

// Public decorator pattern from sample 19
export const IS_PUBLIC_KEY = 'isPublic';
export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

Exception Handling Security

The built-in exception layer prevents stack traces from leaking to clients in production. HttpException responses include only the status code and message. Enable detailed errors only in development:

// Avoid in production
GraphQLModule.forRoot({
  includeStacktraceInErrorResponses: false,  // Default: false
});

Caution

Never expose internal error details, stack traces, or database error messages to clients. Always catch and transform internal exceptions into appropriate HTTP exceptions with safe messages.

File Upload Validation

Use ParseFilePipe with built-in validators:

@Post('upload')
@UseInterceptors(FileInterceptor('file'))
uploadFile(
  @UploadedFile(
    new ParseFilePipe({
      validators: [
        new MaxFileSizeValidator({ maxSize: 10 * 1024 * 1024 }),  // 10 MB
        new FileTypeValidator({ fileType: 'image/jpeg' }),
      ],
    }),
  )
  file: Express.Multer.File,
) {
  return { filename: file.originalname };
}

8. Developer Internals

Repository Structure

nestjs/nest/
├── packages/                    # Framework source (published to npm)
│   ├── common/                  # Shared decorators, interfaces, pipes, exceptions
│   │   ├── decorators/          # @Controller, @Injectable, @Module, @Inject, etc.
│   │   │   ├── core/            # Core decorators (DI, lifecycle, metadata)
│   │   │   ├── http/            # HTTP method + param decorators
│   │   │   └── modules/         # @Module, @Global
│   │   ├── enums/               # HttpStatus, RequestMethod, Scope, VersioningType
│   │   ├── exceptions/          # All HTTP exception classes
│   │   ├── file-stream/         # StreamableFile
│   │   ├── interfaces/          # TypeScript interfaces for the entire framework
│   │   ├── module-utils/        # ConfigurableModuleBuilder
│   │   ├── pipes/               # Built-in pipes (Validation, Parse*, File)
│   │   ├── serializer/          # ClassSerializerInterceptor
│   │   ├── services/            # Logger, ConsoleLogger
│   │   └── utils/               # Shared utilities
│   ├── core/                    # Framework engine
│   │   ├── adapters/            # AbstractHttpAdapter
│   │   ├── discovery/           # DiscoveryService, DiscoveryModule
│   │   ├── errors/              # Framework-level error classes
│   │   ├── exceptions/          # BaseExceptionFilter, ExceptionsHandler
│   │   ├── guards/              # GuardsConsumer, GuardsContextCreator
│   │   ├── helpers/             # ContextIdFactory, ExecutionContext utilities
│   │   ├── hooks/               # Lifecycle hook callers
│   │   ├── injector/            # DI container, Injector, Module, InstanceWrapper
│   │   ├── inspector/           # GraphInspector, SerializedGraph
│   │   ├── interceptors/        # InterceptorsConsumer, InterceptorsContextCreator
│   │   ├── middleware/           # MiddlewareModule, MiddlewareContainer
│   │   ├── pipes/               # PipesConsumer, PipesContextCreator
│   │   ├── repl/                # REPL mode implementation
│   │   ├── router/              # RoutesResolver, RouterExplorer, RouterModule
│   │   └── services/            # Reflector
│   ├── microservices/           # Microservice transports
│   │   ├── client/              # ClientProxy implementations per transport
│   │   ├── ctx-host/            # Transport-specific context classes
│   │   ├── decorators/          # @MessagePattern, @EventPattern, @Client, etc.
│   │   ├── deserializers/       # Message deserializers
│   │   ├── enums/               # Transport enum
│   │   ├── events/              # Event/message pattern handling
│   │   ├── exceptions/          # RpcException, microservice exception filters
│   │   ├── helpers/             # Kafka/NATS/MQTT helpers
│   │   ├── module/              # ClientsModule
│   │   ├── record-builders/     # NatsRecord, RmqRecord, MqttRecord, KafkaRecord
│   │   ├── serializers/         # Message serializers
│   │   ├── server/              # Server implementations per transport
│   │   └── utils/               # Shared microservice utilities
│   ├── platform-express/        # Express adapter
│   │   ├── adapters/            # ExpressAdapter
│   │   └── multer/              # File upload interceptors
│   ├── platform-fastify/        # Fastify adapter
│   │   ├── adapters/            # FastifyAdapter
│   │   └── decorators/          # @InjectRawBody, Fastify-specific decorators
│   ├── platform-socket.io/      # Socket.IO WebSocket adapter
│   ├── platform-ws/             # ws WebSocket adapter
│   ├── testing/                 # Test utilities (Test.createTestingModule)
│   └── websockets/              # WebSocket gateway system
│       ├── adapters/            # AbstractWsAdapter
│       ├── decorators/          # @WebSocketGateway, @SubscribeMessage, etc.
│       ├── errors/              # WS error classes
│       ├── exceptions/          # WsException, WsExceptionFilter
│       └── utils/               # Gateway metadata accessor
├── integration/                 # Integration test suites
│   ├── cors/                    # CORS integration tests
│   ├── hello-world/             # Basic HTTP integration
│   ├── hooks/                   # Lifecycle hooks tests
│   ├── injector/                # DI system tests (circular deps, scopes)
│   ├── inspector/               # Graph inspector tests
│   ├── lazy-modules/            # Lazy loading tests
│   ├── microservices/           # All transport integration tests
│   ├── mongoose/                # Mongoose integration
│   ├── nest-application/        # Application-level tests (SSE, body parser, etc.)
│   ├── repl/                    # REPL integration tests
│   ├── scopes/                  # Injection scope tests
│   ├── send-files/              # StreamableFile tests
│   ├── typeorm/                 # TypeORM integration
│   ├── versioning/              # API versioning tests
│   └── websockets/              # WebSocket integration tests
├── sample/                      # 36 example applications
├── tools/                       # Build and benchmark tools
│   ├── benchmarks/              # Express vs Fastify performance comparison
│   └── gulp/                    # Build pipeline tasks
├── lerna.json                   # Monorepo config (version: 11.1.19)
└── package.json                 # Root dependencies and scripts

Architecture Deep Dive

Dependency Injection System

The DI system is the foundation of NestJS. It operates through these core classes:

NestContainer — The top-level container holding a Map<string, Module> of all registered modules. Each module is identified by a token generated from its class and dynamic metadata.

Module (internal) — Represents a single @Module() class. Contains three collections:

• _providers — Map of provider wrappers (InstanceWrapper)
• _controllers — Map of controller wrappers
• _imports — Set of imported module references

InstanceWrapper — Wraps a provider/controller instance with metadata: scope, injection token, resolved value, and per-context instance maps for REQUEST/TRANSIENT scopes.

Injector — The resolution engine. For each provider, it:

1. Reads constructor parameter types via reflect-metadata
2. Resolves each parameter's injection token
3. Looks up the matching InstanceWrapper in the module tree
4. Recursively instantiates dependencies
5. Caches singleton instances; creates new instances for request/transient scopes

Injection scopes:

Durable providers (durable: true in @Injectable()) can persist across requests when used with a custom ContextIdStrategy.

Module Resolution Order

1. NestFactory.create() calls the DependenciesScanner
2. Scanner recursively traverses imports from the root module
3. Each module is compiled (metadata extracted, token generated)
4. The InstanceLoader instantiates all providers in dependency order
5. onModuleInit hooks fire in topological order (leaf modules first)
6. onApplicationBootstrap hooks fire in the same order

Lifecycle Hooks

All hooks support async (Promise) return values. Modules are processed in topological distance order on init, and reverse order on shutdown.

Router System

The RoutesResolver scans all controllers and their methods:

1. Reads PATH_METADATA from @Controller() for the base path
2. Reads HTTP method metadata from @Get(), @Post(), etc.
3. Reads parameter metadata from @Body(), @Param(), etc.
4. Creates route handlers that execute the pipeline (guards → interceptors → pipes → handler)
5. Registers routes with the platform adapter

Route parameter extraction uses RouteParamtypes enum values (REQUEST=0, RESPONSE=1, NEXT=2, BODY=3, QUERY=4, PARAM=5, HEADERS=6, SESSION=7, FILE=8, FILES=9, HOST=10, IP=11, RAW_BODY=12).

Platform Adapters

Both adapters extend AbstractHttpAdapter and implement a common interface:

ExpressAdapter:

• Wraps Express 5.x
• Supports multer for file uploads (FileInterceptor, FilesInterceptor, FileFieldsInterceptor, AnyFilesInterceptor)
• Body parsing enabled by default (JSON + URL-encoded)
• Versioning supports URI, HEADER, MEDIA_TYPE, and CUSTOM types

FastifyAdapter:

• Wraps Fastify 5.x
• Uses @fastify/multipart for file uploads
• Uses @fastify/middie for Express-style middleware compatibility
• Uses @fastify/cors for CORS
• Uses @fastify/static for static file serving
• Uses @fastify/view for template rendering
• Supports @fastify/formbody for form data parsing
• Provides @InjectRawBody() decorator for raw body access

Microservices Architecture

Transport Implementations

All servers extend the abstract Server class. All clients extend ClientProxy.

Message Patterns

• @MessagePattern(pattern) — Request/response (client sends, expects a reply)
• @EventPattern(pattern) — Event-based (fire-and-forget, no reply)
• @GrpcMethod(service, method) — gRPC unary/server-streaming
• @GrpcStreamMethod(service, method) — gRPC client-streaming/bidirectional

Context Classes

Each transport provides a specialized context:

All extend BaseRpcContext.

Record Builders

For transport-specific message metadata:

ClientsModule Registration

@Module({
  imports: [
    ClientsModule.register([
      { name: 'MATH_SERVICE', transport: Transport.TCP, options: { port: 3001 } },
    ]),
    // Or async:
    ClientsModule.registerAsync([
      {
        name: 'MATH_SERVICE',
        useFactory: (config: ConfigService) => ({
          transport: Transport.TCP,
          options: { port: config.get('MATH_PORT') },
        }),
        inject: [ConfigService],
      },
    ]),
  ],
})
export class AppModule {}

Serialization Layer

Custom serializers/deserializers transform messages between wire format and application format:

WebSocket System

The @WebSocketGateway() decorator registers a class as a WebSocket gateway. The WebSocketsController discovers all gateways, creates server instances via the configured adapter, and binds message handlers.

Decorators:

Gateway hooks:

Testing

@nestjs/testing provides Test.createTestingModule() for creating isolated test modules:

const moduleRef = await Test.createTestingModule({
  imports: [CatsModule],
  providers: [
    { provide: CatsService, useValue: mockCatsService },
  ],
})
  .overrideProvider(CatsService)
  .useValue(mockCatsService)
  .overrideGuard(AuthGuard)
  .useValue({ canActivate: () => true })
  .compile();

Override methods:

Each returns a builder with .useClass(), .useValue(), and .useFactory().

Code Patterns and Conventions

Decorator pattern: NestJS uses TypeScript decorators extensively with reflect-metadata for storing configuration metadata on classes and methods. All framework decorators write metadata using Reflect.defineMetadata().

Observable-based pipeline: Interceptors use RxJS Observable chains. The CallHandler.handle() returns an Observable of the route handler's response, allowing operators like map, tap, catchError, and timeout to be chained.

Commit conventions: The repo uses Angular-style commits (feat, fix, chore, etc.) with scopes matching package names (common, core, microservices, express, fastify, socket.io, ws, testing, websockets).

Build system: TypeScript project references (tsc -b) compile all packages. Gulp tasks handle file copying, sample builds, and module relocation. Lerna manages versioning and publishing.

Testing: Unit tests use Mocha + Chai + Sinon. Integration tests live in integration/ with per-feature directories. Docker Compose (integration/docker-compose.yml) provides Redis, NATS, MQTT, MySQL, MongoDB, RabbitMQ, ZooKeeper, and Kafka for transport integration tests.

Key Interfaces

ConfigurableModuleBuilder

Generates forRoot(), forRootAsync(), MODULE_OPTIONS_TOKEN, and ConfigurableModuleAsyncOptions for dynamic modules:

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

export interface HttpModuleOptions {
  baseUrl: string;
  timeout?: number;
}

export const {
  ConfigurableModuleClass,
  MODULE_OPTIONS_TOKEN,
  OPTIONS_TYPE,
  ASYNC_OPTIONS_TYPE,
} = new ConfigurableModuleBuilder<HttpModuleOptions>()
  .setClassMethodName('forRoot')
  .setExtras({ isGlobal: false }, (definition, extras) => ({
    ...definition,
    global: extras.isGlobal,
  }))
  .build();

Reflector Service

The Reflector class (from @nestjs/core) reads metadata set by @SetMetadata():

// Define
export const Roles = (...roles: string[]) => SetMetadata('roles', roles);

// Use
@Roles('admin')
@Get()
findAll() {}

// Read in guard
@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

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

Reflector methods:

9. Integration Points

Database Integrations

NestJS provides official wrappers for database ORMs as separate packages:

Each provides forRoot() / forRootAsync() and forFeature() patterns for module-level configuration.

GraphQL

Federation support: Samples 31-graphql-federation-code-first and 32-graphql-federation-schema-first demonstrate Apollo Federation with gateway + subgraph patterns.

Caching

import { CacheModule } from '@nestjs/cache-manager';

@Module({
  imports: [CacheModule.register({ ttl: 5, max: 100 })],
})
export class AppModule {}

Use @UseInterceptors(CacheInterceptor) for automatic GET response caching.

Task Scheduling

npm i @nestjs/schedule

import { Cron, Interval, Timeout } from '@nestjs/schedule';

@Injectable()
export class TasksService {
  @Cron('0 */5 * * * *')
  handleCron() { /* every 5 minutes */ }

  @Interval(10000)
  handleInterval() { /* every 10 seconds */ }

  @Timeout(5000)
  handleTimeout() { /* once after 5 seconds */ }
}

Event Emitter

npm i @nestjs/event-emitter

import { EventEmitter2 } from '@nestjs/event-emitter';

@Injectable()
export class OrdersService {
  constructor(private eventEmitter: EventEmitter2) {}

  create(order: Order) {
    this.eventEmitter.emit('order.created', new OrderCreatedEvent(order));
  }
}

@Injectable()
export class OrderCreatedListener {
  @OnEvent('order.created')
  handleOrderCreatedEvent(event: OrderCreatedEvent) {
    // Handle event
  }
}

Queues

npm i @nestjs/bull bull

@Module({
  imports: [
    BullModule.forRoot({
      redis: { host: 'localhost', port: 6379 },
    }),
    BullModule.registerQueue({ name: 'audio' }),
  ],
})
export class AppModule {}

Docker Compose for Integration Testing

The repository's integration/docker-compose.yml provisions all external services needed for transport tests:

docker-compose -f integration/docker-compose.yml up -d
npm run test:integration
docker-compose -f integration/docker-compose.yml down

Note

KafkaJS, the Kafka client used by NestJS, appears to be no longer actively maintained (nestjs/nest#13223). Monitor for potential migration to an alternative client library.

Build Scripts

Contributing

The repository uses:

• Commit format: Angular-style (feat(core): add feature, fix(microservices): fix bug)
• Linting: ESLint with Prettier integration
• Pre-commit: Husky + lint-staged (auto-formats .ts and .json files)
• CI: CircleCI for build/test/lint
• Code coverage: nyc + Coveralls
• Monorepo management: Lerna (version 9.x)

Known Issues