Execution Context trong NestJS

Execution Context là một object chứa thông tin chi tiết về request hiện tại đang được xử lý. Nó được sử dụng trong Guards, Interceptors, Exception Filters, và Pipes để truy cập các thông tin như HTTP request, response, handler method, class, arguments, v.v.

Khái Niệm Execution Context

Execution Context cung cấp truy cập vào:

HTTP Request/Response objects (Express)
Handler class được gọi
Handler method đang thực thi
Arguments của method
Class metadata (custom decorators)
Execution type (HTTP, WebSocket, RPC)

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

@Injectable()
export class MyGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    // Truy cập information từ execution context
    const request = context.switchToHttp().getRequest();
    const response = context.switchToHttp().getResponse();
    const handler = context.getHandler();
    const classRef = context.getClass();

    console.log(`Executing: ${classRef.name}.${handler.name}`);
    console.log(`Method: ${request.method}`);
    console.log(`URL: ${request.url}`);

    return true;
  }
}

ExecutionContext API

switchToHttp()

@Injectable()
export class HttpContextGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const httpContext = context.switchToHttp();

    const request = httpContext.getRequest<Request>();
    const response = httpContext.getResponse<Response>();
    const next = httpContext.getNext<Function>();

    console.log(`Method: ${request.method}`);
    console.log(`URL: ${request.url}`);
    console.log(`Headers: ${JSON.stringify(request.headers)}`);

    return true;
  }
}

switchToWs()

@Injectable()
export class WsContextGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const wsContext = context.switchToWs();

    const client = wsContext.getClient();
    const data = wsContext.getData();

    console.log(`Client connected: ${client.id}`);
    console.log(`Data: ${JSON.stringify(data)}`);

    return true;
  }
}

switchToRpc()

@Injectable()
export class RpcContextGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const rpcContext = context.switchToRpc();

    const data = rpcContext.getData();
    const context_arg = rpcContext.getContext();

    console.log(`RPC Data: ${JSON.stringify(data)}`);
    console.log(`RPC Context: ${JSON.stringify(context_arg)}`);

    return true;
  }
}

getHandler() & getClass()

@Injectable()
export class MetadataGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    // Lấy handler method và class
    const handler = context.getHandler();
    const classRef = context.getClass();

    const handlerName = handler.name; // Method name
    const className = classRef.name; // Class name

    console.log(`Calling: ${className}.${handlerName}`);

    // Lấy custom metadata
    const roles = this.reflector.get<string[]>(
      'roles',
      handler,
    );

    const isPublic = this.reflector.get<boolean>(
      'public',
      handler,
    );

    console.log(`Required roles: ${roles}`);
    console.log(`Is public: ${isPublic}`);

    return true;
  }
}

getArgs() & getArgByIndex()

@Injectable()
export class ArgumentsGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    // Lấy tất cả arguments
    const args = context.getArgs();
    console.log(`Total arguments: ${args.length}`);

    // Lấy argument cụ thể
    const request = context.getArgByIndex(0);
    const response = context.getArgByIndex(1);
    const next = context.getArgByIndex(2);

    console.log(`Request: ${request.method} ${request.url}`);

    return true;
  }
}

getType()

@Injectable()
export class TypeAwareGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const type = context.getType();

    if (type === 'http') {
      const request = context.switchToHttp().getRequest();
      console.log(`HTTP Request: ${request.method} ${request.url}`);
    } else if (type === 'ws') {
      const client = context.switchToWs().getClient();
      console.log(`WebSocket Client: ${client.id}`);
    } else if (type === 'rpc') {
      const data = context.switchToRpc().getData();
      console.log(`RPC Data: ${JSON.stringify(data)}`);
    }

    return true;
  }
}

Ví Dụ Execution Context Thực Tế

1. Request Logging with Context

@Injectable()
export class RequestLoggingInterceptor implements NestInterceptor {
  private readonly logger = new Logger('HTTP');

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest<Request>();
    const { method, url, headers, ip } = request;
    const userAgent = headers['user-agent'];
    const startTime = Date.now();

    // Get handler info
    const handler = context.getHandler();
    const className = context.getClass().name;
    const handlerName = handler.name;

    this.logger.log(
      `→ [${className}:${handlerName}] ${method} ${url} from ${ip}`,
    );

    return next.handle().pipe(
      tap((data) => {
        const duration = Date.now() - startTime;
        const response = context.switchToHttp().getResponse<Response>();

        this.logger.log(
          `← [${className}:${handlerName}] ${response.statusCode} ${duration}ms`,
        );
      }),
      catchError((error) => {
        const duration = Date.now() - startTime;
        this.logger.error(
          `✗ [${className}:${handlerName}] ERROR ${duration}ms: ${error.message}`,
        );
        throw error;
      }),
    );
  }
}

2. Role-Based Authorization Guard

export const Roles = Reflector.createDecorator<string[]>();

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

  canActivate(context: ExecutionContext): boolean {
    // Lấy roles từ method decorator
    const requiredRoles = this.reflector.get(Roles, context.getHandler());

    if (!requiredRoles) {
      // Nếu không có roles required, cho phép truy cập
      return true;
    }

    // Lấy user từ request
    const request = context.switchToHttp().getRequest();
    const user = (request as any).user;

    if (!user) {
      throw new ForbiddenException('User not found');
    }

    // Check nếu user có required roles
    const hasRole = requiredRoles.some((role) => user.roles?.includes(role));

    if (!hasRole) {
      throw new ForbiddenException(
        `User must have one of these roles: ${requiredRoles.join(', ')}`,
      );
    }

    return true;
  }
}

// Sử dụng
@Controller('admin')
export class AdminController {
  @Get('dashboard')
  @Roles(['admin'])
  getDashboard() {
    return { data: 'admin dashboard' };
  }

  @Post('users')
  @Roles(['admin', 'moderator'])
  createUser() {
    return { message: 'user created' };
  }
}

3. Custom Decorator with Execution Context

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

// Lấy user từ request
export const CurrentUser = createParamDecorator(
  (data: string | undefined, context: ExecutionContext) => {
    const request = context.switchToHttp().getRequest();
    const user = (request as any).user;

    if (!user) {
      throw new UnauthorizedException('User not found');
    }

    return data ? user[data] : user;
  },
);

// Sử dụng
@Controller('profile')
export class ProfileController {
  @Get()
  getProfile(@CurrentUser() user: any) {
    return { user };
  }

  @Post('update')
  updateProfile(
    @CurrentUser('id') userId: string,
    @Body() updateDto: UpdateProfileDto,
  ) {
    return { userId, ...updateDto };
  }
}

4. Metadata Extraction Guard

export const Permissions = Reflector.createDecorator<string[]>();
export const Public = Reflector.createDecorator<void>();
export const Throttle = Reflector.createDecorator<{ limit: number; ttl: number }>();

@Injectable()
export class MetadataExtractionGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    // Lấy metadata từ handler
    const isPublic = this.reflector.getAllAndOverride(Public, [
      context.getHandler(),
      context.getClass(),
    ]);

    if (isPublic) {
      return true; // Public route, skip authorization
    }

    // Lấy permissions
    const requiredPermissions = this.reflector.get(
      Permissions,
      context.getHandler(),
    );

    // Lấy throttle config
    const throttleConfig = this.reflector.get(
      Throttle,
      context.getHandler(),
    );

    const request = context.switchToHttp().getRequest();
    const user = (request as any).user;

    console.log(`Permissions required: ${requiredPermissions}`);
    console.log(`Throttle config: ${JSON.stringify(throttleConfig)}`);

    return true;
  }
}

// Sử dụng
@Controller('api')
export class ApiController {
  @Get('public')
  @Public()
  getPublic() {
    return { data: 'public' };
  }

  @Post('users')
  @Permissions(['users:create'])
  @Throttle({ limit: 5, ttl: 60 })
  createUser() {
    return { message: 'user created' };
  }
}

5. Dynamic Handler Execution

@Injectable()
export class DynamicExecutionInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const handler = context.getHandler();
    const classRef = context.getClass();
    const request = context.switchToHttp().getRequest();

    // Lấy metadata về execution
    const handlerName = handler.name;
    const className = classRef.name;
    const httpMethod = request.method;

    console.log(`Executing: ${className}#${handlerName} [${httpMethod}]`);

    // Có thể dynamically modify handler behavior dựa trên metadata
    const customMeta = Reflect.getMetadata('custom', handler);

    if (customMeta?.requiresAuth) {
      const user = (request as any).user;
      if (!user) {
        throw new UnauthorizedException();
      }
    }

    return next.handle();
  }
}

6. Request Validation with Context

@Injectable()
export class RequestValidationGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const handler = context.getHandler();

    // Validate based on handler metadata
    const allowedMethods = this.reflector.get<string[]>(
      'allowedMethods',
      handler,
    );

    if (allowedMethods && !allowedMethods.includes(request.method)) {
      throw new BadRequestException(
        `Method ${request.method} not allowed`,
      );
    }

    // Validate headers
    const requiredHeaders = this.reflector.get<string[]>(
      'requiredHeaders',
      handler,
    );

    if (requiredHeaders) {
      for (const header of requiredHeaders) {
        if (!request.headers[header.toLowerCase()]) {
          throw new BadRequestException(
            `Missing required header: ${header}`,
          );
        }
      }
    }

    return true;
  }
}

// Decorators
export const AllowedMethods = (methods: string[]) =>
  SetMetadata('allowedMethods', methods);

export const RequiredHeaders = (headers: string[]) =>
  SetMetadata('requiredHeaders', headers);

// Sử dụng
@Controller('api')
export class ApiController {
  @Post('data')
  @AllowedMethods(['POST', 'PUT'])
  @RequiredHeaders(['Content-Type', 'Authorization'])
  processData(@Body() data: any) {
    return { success: true };
  }
}

7. Performance Monitoring with Context

@Injectable()
export class PerformanceInterceptor implements NestInterceptor {
  private readonly logger = new Logger('Performance');

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const startTime = performance.now();
    const startMemory = process.memoryUsage();

    const request = context.switchToHttp().getRequest();
    const handler = context.getHandler();
    const classRef = context.getClass();

    return next.handle().pipe(
      tap(() => {
        const duration = performance.now() - startTime;
        const endMemory = process.memoryUsage();

        const memoryDelta = {
          heapUsed:
            Math.round((endMemory.heapUsed - startMemory.heapUsed) / 1024) +
            'KB',
          heapTotal:
            Math.round((endMemory.heapTotal - startMemory.heapTotal) / 1024) +
            'KB',
        };

        const metrics = {
          handler: `${classRef.name}#${handler.name}`,
          method: request.method,
          path: request.path,
          duration: `${duration.toFixed(2)}ms`,
          memory: memoryDelta,
        };

        if (duration > 1000) {
          this.logger.warn(`Slow handler: ${JSON.stringify(metrics)}`);
        } else {
          this.logger.debug(`Handler executed: ${JSON.stringify(metrics)}`);
        }
      }),
      catchError((error) => {
        const duration = performance.now() - startTime;
        this.logger.error(
          `Error in ${classRef.name}#${handler.name}: ${error.message} (${duration.toFixed(2)}ms)`,
        );
        throw error;
      }),
    );
  }
}

8. Conditional Response Transformation

@Injectable()
export class ConditionalTransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const handler = context.getHandler();
    const shouldTransform = Reflect.getMetadata('transform', handler);

    if (!shouldTransform) {
      return next.handle();
    }

    return next.handle().pipe(
      map((data) => {
        // Transform response based on metadata
        const transformType = Reflect.getMetadata('transformType', handler);

        switch (transformType) {
          case 'pagination':
            return {
              data,
              page: 1,
              limit: 10,
              total: data.length,
            };
          case 'envelope':
            return {
              success: true,
              timestamp: new Date(),
              data,
            };
          default:
            return data;
        }
      }),
    );
  }
}

// Decorators
export const Transform = (type: string) => {
  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
    Reflect.defineMetadata('transform', true, descriptor.value);
    Reflect.defineMetadata('transformType', type, descriptor.value);
    return descriptor;
  };
};

// Sử dụng
@Controller('api')
export class ApiController {
  @Get('users')
  @Transform('pagination')
  getUsers() {
    return ['Alice', 'Bob', 'Charlie'];
  }

  @Get('data')
  @Transform('envelope')
  getData() {
    return { key: 'value' };
  }
}

9. Multi-Type Context Handling

@Injectable()
export class MultiContextGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const contextType = context.getType();

    if (contextType === 'http') {
      return this.handleHttp(context);
    } else if (contextType === 'ws') {
      return this.handleWs(context);
    } else if (contextType === 'rpc') {
      return this.handleRpc(context);
    }

    return false;
  }

  private handleHttp(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const user = (request as any).user;

    console.log(`HTTP: User ${user?.id} accessing ${request.path}`);
    return !!user;
  }

  private handleWs(context: ExecutionContext): boolean {
    const client = context.switchToWs().getClient();
    const data = context.switchToWs().getData();

    console.log(`WebSocket: Client ${client.id} sent data: ${JSON.stringify(data)}`);
    return true;
  }

  private handleRpc(context: ExecutionContext): boolean {
    const data = context.switchToRpc().getData();

    console.log(`RPC: Received data: ${JSON.stringify(data)}`);
    return true;
  }
}

10. Audit Logging with Context

@Injectable()
export class AuditLoggingInterceptor implements NestInterceptor {
  constructor(private auditService: AuditService) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest();
    const handler = context.getHandler();
    const classRef = context.getClass();

    const auditData = {
      action: `${classRef.name}#${handler.name}`,
      method: request.method,
      path: request.path,
      userId: (request as any).user?.id,
      timestamp: new Date(),
      ip: request.ip,
      userAgent: request.headers['user-agent'],
    };

    return next.handle().pipe(
      tap(() => {
        // Log successful action
        this.auditService.log({
          ...auditData,
          status: 'success',
        });
      }),
      catchError((error) => {
        // Log failed action
        this.auditService.log({
          ...auditData,
          status: 'error',
          error: error.message,
        });
        throw error;
      }),
    );
  }
}

@Injectable()
export class AuditService {
  log(auditData: any) {
    console.log(`[AUDIT] ${JSON.stringify(auditData)}`);
    // Save to database, file, or external service
  }
}

Execution Context in Different Contexts

HTTP Context

const httpContext = context.switchToHttp();
const request = httpContext.getRequest<Request>(); // Express Request
const response = httpContext.getResponse<Response>(); // Express Response
const next = httpContext.getNext<Function>(); // Express next()

WebSocket Context

const wsContext = context.switchToWs();
const client = wsContext.getClient(); // WebSocket client
const data = wsContext.getData(); // Data from message

RPC Context

const rpcContext = context.switchToRpc();
const data = rpcContext.getData(); // RPC data
const context_arg = rpcContext.getContext(); // RPC context

Best Practices

1. Check Execution Type Before Switching

// ❌ Sai - Assume HTTP context
const request = context.switchToHttp().getRequest();

// ✅ Đúng - Check type first
if (context.getType() === 'http') {
  const request = context.switchToHttp().getRequest();
}

2. Use Type Guards

// ✅ Đúng - Type-safe context switching
const isHttpContext = (context: ExecutionContext): boolean => {
  return context.getType() === 'http';
};

if (isHttpContext(context)) {
  const request = context.switchToHttp().getRequest<Request>();
  // Type-safe operations
}

3. Cache Context Information

// ✅ Đúng - Cache expensive operations
@Injectable()
export class OptimizedGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    // Cache expensive lookups
    const handler = context.getHandler();
    const metadata = Reflect.getMetadata('key', handler);
    
    // Reuse cached values
    return !!metadata;
  }
}

4. Use Reflector for Metadata

// ✅ Đúng - Use Reflector API
const roles = this.reflector.get<string[]>('roles', context.getHandler());

// ❌ Sai - Direct metadata access
const roles = Reflect.getMetadata('roles', context.getHandler());

5. Error Handling with Context

// ✅ Đúng - Provide context in errors
if (!user) {
  const request = context.switchToHttp().getRequest();
  throw new UnauthorizedException(
    `Unauthorized access to ${request.path}`,
  );
}

Complete Example

// decorators/require-roles.decorator.ts
export const RequireRoles = Reflector.createDecorator<string[]>();
export const RequirePermissions = Reflector.createDecorator<string[]>();

// guards/authorization.guard.ts
@Injectable()
export class AuthorizationGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const handler = context.getHandler();
    const classRef = context.getClass();
    const request = context.switchToHttp().getRequest();

    // Get required roles and permissions
    const requiredRoles = this.reflector.get(
      RequireRoles,
      handler,
    ) || [];

    const requiredPermissions = this.reflector.get(
      RequirePermissions,
      handler,
    ) || [];

    if (requiredRoles.length === 0 && requiredPermissions.length === 0) {
      return true; // No authorization required
    }

    const user = (request as any).user;

    if (!user) {
      throw new UnauthorizedException('User not authenticated');
    }

    // Check roles
    if (requiredRoles.length > 0) {
      const hasRole = requiredRoles.some((role) =>
        user.roles?.includes(role),
      );

      if (!hasRole) {
        throw new ForbiddenException(
          `Required roles: ${requiredRoles.join(', ')}`,
        );
      }
    }

    // Check permissions
    if (requiredPermissions.length > 0) {
      const hasPermission = requiredPermissions.every((permission) =>
        user.permissions?.includes(permission),
      );

      if (!hasPermission) {
        throw new ForbiddenException(
          `Required permissions: ${requiredPermissions.join(', ')}`,
        );
      }
    }

    return true;
  }
}

// controllers/users.controller.ts
@Controller('users')
@UseGuards(AuthorizationGuard)
export class UsersController {
  @Get()
  @RequireRoles(['admin', 'moderator'])
  findAll() {
    return [];
  }

  @Post()
  @RequireRoles(['admin'])
  @RequirePermissions(['users:create'])
  create(@Body() createUserDto: CreateUserDto) {
    return { message: 'User created' };
  }

  @Delete(':id')
  @RequireRoles(['admin'])
  @RequirePermissions(['users:delete'])
  remove(@Param('id') id: string) {
    return { message: 'User deleted' };
  }
}

// interceptors/audit.interceptor.ts
@Injectable()
export class AuditInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest();
    const handler = context.getHandler();
    const classRef = context.getClass();

    const auditData = {
      action: `${classRef.name}#${handler.name}`,
      method: request.method,
      path: request.path,
      userId: (request as any).user?.id,
      timestamp: new Date().toISOString(),
    };

    console.log(`[AUDIT] ${JSON.stringify(auditData)}`);

    return next.handle();
  }
}

Kết Luận

Execution Context là công cụ mạnh mẽ để:

Truy cập thông tin về request hiện tại
Extract metadata từ handlers
Implement authorization logic
Log và audit operations
Handle multiple execution types

Sử dụng Execution Context đúng cách giúp bạn:

Xây dựng flexible guards và interceptors
Implement fine-grained access control
Tạo powerful audit logging
Handle complex authorization scenarios
Support multiple execution contexts (HTTP, WebSocket, RPC)

Execution Context là nền tảng của nhiều advanced NestJS patterns và features!

Tổng quan

Nền tảng

Execution Context

Execution Context trong NestJS

Khái Niệm Execution Context

ExecutionContext API

switchToHttp()

switchToWs()

switchToRpc()

getHandler() & getClass()

getArgs() & getArgByIndex()

getType()

Ví Dụ Execution Context Thực Tế

1. Request Logging with Context

2. Role-Based Authorization Guard

3. Custom Decorator with Execution Context

4. Metadata Extraction Guard

5. Dynamic Handler Execution

6. Request Validation with Context

7. Performance Monitoring with Context

8. Conditional Response Transformation

9. Multi-Type Context Handling

10. Audit Logging with Context

Execution Context in Different Contexts

HTTP Context

WebSocket Context

RPC Context

Best Practices

1. Check Execution Type Before Switching

2. Use Type Guards

3. Cache Context Information

4. Use Reflector for Metadata

5. Error Handling with Context

Complete Example

Kết Luận

​Execution Context trong NestJS

​Khái Niệm Execution Context

​ExecutionContext API

​switchToHttp()

​switchToWs()

​switchToRpc()

​getHandler() & getClass()

​getArgs() & getArgByIndex()

​getType()

​Ví Dụ Execution Context Thực Tế

​1. Request Logging with Context

​2. Role-Based Authorization Guard

​3. Custom Decorator with Execution Context

​4. Metadata Extraction Guard

​5. Dynamic Handler Execution

​6. Request Validation with Context

​7. Performance Monitoring with Context

​8. Conditional Response Transformation

​9. Multi-Type Context Handling

​10. Audit Logging with Context

​Execution Context in Different Contexts

​HTTP Context

​WebSocket Context

​RPC Context

​Best Practices

​1. Check Execution Type Before Switching

​2. Use Type Guards

​3. Cache Context Information

​4. Use Reflector for Metadata

​5. Error Handling with Context

​Complete Example

​Kết Luận

Execution Context trong NestJS

Khái Niệm Execution Context

ExecutionContext API

switchToHttp()

switchToWs()

switchToRpc()

getHandler() & getClass()

getArgs() & getArgByIndex()

getType()

Ví Dụ Execution Context Thực Tế

1. Request Logging with Context

2. Role-Based Authorization Guard

3. Custom Decorator with Execution Context

4. Metadata Extraction Guard

5. Dynamic Handler Execution

6. Request Validation with Context

7. Performance Monitoring with Context

8. Conditional Response Transformation

9. Multi-Type Context Handling

10. Audit Logging with Context

Execution Context in Different Contexts

HTTP Context

WebSocket Context

RPC Context

Best Practices

1. Check Execution Type Before Switching

2. Use Type Guards

3. Cache Context Information

4. Use Reflector for Metadata

5. Error Handling with Context

Complete Example

Kết Luận