3. Add a path alias if you want cleaner imports:

{
  "compilerOptions": {
    "paths": {
      "@nestjs/common": ["./src/vendor/nestjs-common/index.ts"]
    }
  }
}

4. In your application entry file (main.ts), import reflect-metadata before anything else:

import 'reflect-metadata';

5. No environment variables are required by this package itself. Runtime configuration (ports, database URLs) is your application's responsibility.

Public API

Injectable

function Injectable(options?: { scope?: Scope }): ClassDecorator;

Marks a class as a NestJS provider that can be injected via the DI container. Use it on any service, repository, or helper class that needs to participate in dependency injection.

Controller

function Controller(prefix?: string | string[]): ClassDecorator;
function Controller(options: ControllerOptions): ClassDecorator;

Declares a class as an HTTP controller and optionally sets a route prefix. Apply it to any class that handles incoming HTTP requests; NestJS will scan it for route handler decorators such as @Get and @Post.

Module

function Module(metadata: ModuleMetadata): ClassDecorator;

Defines a NestJS module. ModuleMetadata accepts imports, controllers, providers, and exports arrays. Every NestJS application is composed of at least one module decorated with @Module.

HttpException

class HttpException extends Error {
  constructor(response: string | Record<string, unknown>, status: number, options?: HttpExceptionOptions);
  getStatus(): number;
  getResponse(): string | object;
}

Base class for all HTTP exceptions. Extend it to create custom error types, or use the pre-built subclasses (NotFoundException, BadRequestException, etc.) for standard HTTP status codes.

SetMetadata

function SetMetadata<K = string, V = unknown>(metadataKey: K, metadataValue: V): CustomDecorator<K>;

Attaches arbitrary metadata to a class or method. Typically paired with a custom Reflector call inside a guard or interceptor to implement role-based access control or feature flags.

UseGuards

function UseGuards(...guards: (CanActivate | Function)[]): MethodDecorator & ClassDecorator;

Binds one or more guards to a controller or route handler. Guards run before the route handler and can short-circuit the request pipeline by returning false or throwing an exception.

Working examples

Scenario - Basic REST controller with a service

A typical CRUD setup: a provider injected into a controller that handles a GET route.

import 'reflect-metadata';
import {
  Controller,
  Get,
  Injectable,
  Module,
  NotFoundException,
} from './src/vendor/nestjs-common/index';

@Injectable()
class CatsService {
  private cats = [{ id: 1, name: 'Tom' }];

  findOne(id: number) {
    const cat = this.cats.find(c => c.id === id);
    if (!cat) throw new NotFoundException(`Cat #${id} not found`);
    return cat;
  }
}

@Controller('cats')
class CatsController {
  constructor(private readonly catsService: CatsService) {}

  @Get(':id')
  getOne() {
    return this.catsService.findOne(1);
  }
}

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

Scenario - Custom guard using SetMetadata

Attach role metadata to a route and read it inside a guard.

import 'reflect-metadata';
import {
  SetMetadata,
  UseGuards,
  CanActivate,
  ExecutionContext,
  Injectable,
  Controller,
  Get,
} from './src/vendor/nestjs-common/index';

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

@Injectable()
class RolesGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    // In a real app, retrieve Reflector from DI and read metadata
    const request = context.switchToHttp().getRequest();
    return request.user?.role === 'admin';
  }
}

@Controller('admin')
class AdminController {
  @Get()
  @Roles('admin')
  @UseGuards(RolesGuard)
  dashboard() {
    return { status: 'ok' };
  }
}

Scenario - Custom HTTP exception

Extend HttpException or use a built-in subclass for structured error responses.

import 'reflect-metadata';
import {
  HttpException,
  HttpStatus,
  BadRequestException,
  UnprocessableEntityException,
} from './src/vendor/nestjs-common/index';

// Using a built-in subclass
function validateAge(age: number) {
  if (age < 0) {
    throw new BadRequestException('Age must be a positive number');
  }
}

// Using a custom structured response
function requireFeatureFlag(flag: string) {
  if (!flag) {
    throw new HttpException(
      { statusCode: 403, message: 'Feature not enabled', error: 'Forbidden' },
      HttpStatus.FORBIDDEN,
    );
  }
}

// Unprocessable entity with validation errors
function throwValidation() {
  throw new UnprocessableEntityException({
    message: 'Validation failed',
    fields: { email: 'must be a valid email' },
  });
}

File walkthrough

• index.ts - Root barrel; re-exports everything from decorators, enums, exceptions, file-stream, and interfaces. Import from here.
• decorators/core/ - DI and metadata decorators: @Injectable, @Inject, @Controller, @Catch, @UseGuards, @UseInterceptors, @UsePipes, @SetMetadata, @Optional, @Version, applyDecorators.
• decorators/http/ - HTTP route decorators: @Get, @Post, @Put, etc. (request-mapping), route param decorators (@Param, @Body, @Query), @Header, @Redirect, @Render, @Sse, @HttpCode.
• decorators/modules/ - Module-level decorators: @Module and @Global.
• enums/ - HttpStatus, RequestMethod, RouteParamtypes, ShutdownSignal, VersionType enumerations.
• exceptions/ - One file per HTTP error class plus HttpException base and IntrinsicException.
• file-stream/ - Interfaces and helpers for StreamableFile responses.
• interfaces/ - TypeScript interfaces (PipeTransform, CanActivate, NestInterceptor, ExceptionFilter, lifecycle hooks, provider shapes, etc.).
• module-utils/ - Helpers for building ConfigurableModuleBuilder patterns.
• pipes/ - ValidationPipe, ParseIntPipe, ParseBoolPipe, and other built-in pipes.
• serializer/ - ClassSerializerInterceptor and ClassSerializerContextOptions.
• services/ - Logger and ConsoleLogger implementations.
• utils/ - Internal helpers (not part of the public API).
• constants.ts - Shared framework constants (metadata keys, tokens).

Common pitfalls and fixes

• Missing reflect-metadata import: Decorators silently fail at runtime. Fix: add import 'reflect-metadata' as the very first line of your entry file.
• emitDecoratorMetadata not enabled: Constructor parameter types are not emitted, breaking DI. Fix: set "emitDecoratorMetadata": true in tsconfig.json.
• ESM/CJS interop with load-esm: Some transitive deps use ESM. Fix: set "module": "node16" or "nodenext" only if your whole project is ESM; otherwise stick with "commonjs".
• class-validator / class-transformer version mismatch: ValidationPipe requires compatible major versions. Fix: pin class-validator@^0.14 and class-transformer@^0.5 together.
• path-to-regexp v8 breaking change: NestJS 11 requires path-to-regexp@^8. If another dep installs v6 or v7, hoist the v8 version in package.json overrides.
• Decorator order matters: @UseGuards, @UseInterceptors, and @UsePipes execute bottom-up when stacked. Fix: place more specific decorators closer to the method signature.

Vibe-coding prompt template

I have added the NestJS Common source code to `src/vendor/nestjs-common/`
and there is a USAGE.md file at the root of that directory.

Upstream package: @nestjs/core@11.1.10 / @nestjs/common
Source root: src/vendor/nestjs-common/
USAGE.md: src/vendor/nestjs-common/USAGE.md

Please integrate this into my existing project step by step:

1. Read USAGE.md fully before writing any code.
2. Add `import 'reflect-metadata'` to my entry file if not already present.
3. Enable `experimentalDecorators` and `emitDecoratorMetadata` in tsconfig.json.
4. Add a tsconfig path alias mapping `@nestjs/common` to `src/vendor/nestjs-common/index.ts`.
5. Create a sample module, controller, and injectable service using only the
   exports visible in src/vendor/nestjs-common/index.ts.
6. Show me how to wire it into my existing Express app or NestFactory bootstrap.
7. Point out any dependency version conflicts in my package.json and suggest fixes.

License and credit

This source is part of the NestJS framework, copyright Kamil Mysliwiec, licensed under the MIT License. See source/PACKAGE.md or the upstream repository for full license text. Upstream npm package: @nestjs/common.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

Hướng dẫn cài đặt đầy đủ và prompt tích hợp sẽ mở khóa sau khi mua.