@Controller('users')
export class UsersController {
  constructor(
    private readonly usersService: UsersService,
    private readonly logger: Logger,
  ) {}
  
  @Get()
  findAll() {
    this.logger.log('Finding all users');
    return this.usersService.findAll();
  }
}

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

// За замовчуванням scope = Scope.DEFAULT
@Injectable()
export class UsersService {
  private callCount = 0; // Лічильник спільний для всіх запитів
  
  findAll() {
    this.callCount++;
    console.log(`UsersService.findAll() called ${this.callCount} times`);
    
    return [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' },
    ];
  }
}

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {
    console.log('UsersController instance created');
  }
  
  @Get()
  findAll() {
    return this.usersService.findAll();
  }
}

@Injectable()
export class DangerousService {
  // ❌ НЕБЕЗПЕЧНО: currentUser перезаписується між запитами
  private currentUser: User;
  
  setUser(user: User) {
    this.currentUser = user; // Race condition!
  }
  
  getUser(): User {
    return this.currentUser; // Може повернути чужого користувача!
  }
}

// ✅ БЕЗПЕЧНО: передаємо контекст як параметр
@Injectable()
export class SafeService {
  processOrder(user: User, order: Order) {
    // user існує лише в локальному scope методу
    return {
      userId: user.id,
      orderId: order.id,
      total: order.total,
    };
  }
}

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

// Провайдер з REQUEST scope
@Injectable({ scope: Scope.REQUEST })
export class RequestContextService {
  private requestId: string;
  private userId: string;
  
  setContext(requestId: string, userId: string) {
    this.requestId = requestId;
    this.userId = userId;
  }
  
  getContext() {
    return {
      requestId: this.requestId,
      userId: this.userId,
    };
  }
  
  log(message: string) {
    console.log(`[${this.requestId}] [User: ${this.userId}] ${message}`);
  }
}

// Контролер з REQUEST scope
@Controller({ path: 'orders', scope: Scope.REQUEST })
export class OrdersController {
  constructor(
    private readonly contextService: RequestContextService,
    private readonly ordersService: OrdersService,
  ) {
    console.log('New OrdersController instance created');
  }
  
  @Get()
  async findAll() {
    // Кожен запит має свій контекст
    this.contextService.log('Fetching all orders');
    return this.ordersService.findAll();
  }
}

import { Injectable, Scope, Inject } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';
import { Request } from 'express';

@Injectable({ scope: Scope.REQUEST })
export class TenantService {
  private tenantId: string;
  
  constructor(@Inject(REQUEST) private readonly request: Request) {
    // Витягуємо tenantId з заголовка або піддомену
    this.tenantId = this.extractTenantId(request);
  }
  
  private extractTenantId(req: Request): string {
    // Варіант 1: З заголовка
    const headerTenant = req.headers['x-tenant-id'] as string;
    if (headerTenant) return headerTenant;
    
    // Варіант 2: З піддомену (acme.app.com → acme)
    const host = req.hostname;
    const subdomain = host.split('.')[0];
    
    return subdomain;
  }
  
  getTenantId(): string {
    return this.tenantId;
  }
}

@Injectable({ scope: Scope.REQUEST })
export class UsersService {
  constructor(
    private readonly tenantService: TenantService,
    private readonly database: Database,
  ) {}
  
  async findAll() {
    const tenantId = this.tenantService.getTenantId();
    
    // Запит до БД фільтрується за tenantId
    return this.database.query(
      'SELECT * FROM users WHERE tenant_id = $1',
      [tenantId],
    );
  }
}

import { Injectable, Scope, Inject, Logger } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';
import { Request } from 'express';
import { v4 as uuidv4 } from 'uuid';

@Injectable({ scope: Scope.REQUEST })
export class RequestLogger extends Logger {
  private requestId: string;
  private userId: string;
  
  constructor(@Inject(REQUEST) private readonly request: Request) {
    super('HTTP');
    
    // Генеруємо або витягуємо request ID
    this.requestId = (request.headers['x-request-id'] as string) || uuidv4();
    
    // Витягуємо userId з автентифікації (якщо доступний)
    this.userId = (request as any).user?.id || 'anonymous';
  }
  
  log(message: string) {
    super.log(`[${this.requestId}] [User: ${this.userId}] ${message}`);
  }
  
  error(message: string, trace?: string) {
    super.error(`[${this.requestId}] [User: ${this.userId}] ${message}`, trace);
  }
}

@Controller('products')
export class ProductsController {
  constructor(
    private readonly logger: RequestLogger,
    private readonly productsService: ProductsService,
  ) {}
  
  @Get()
  async findAll() {
    this.logger.log('Fetching all products');
    const products = await this.productsService.findAll();
    this.logger.log(`Found ${products.length} products`);
    return products;
  }
}

import { Injectable, Scope, Inject } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';
import { Request } from 'express';

@Injectable({ scope: Scope.REQUEST })
export class AuditService {
  constructor(@Inject(REQUEST) private readonly request: Request) {}
  
  async logAction(action: string, entityId: string) {
    const auditEntry = {
      action,
      entityId,
      userId: (this.request as any).user?.id,
      ipAddress: this.request.ip,
      userAgent: this.request.headers['user-agent'],
      timestamp: new Date(),
    };
    
    // Зберігаємо аудит у БД
    await this.database.save('audit_log', auditEntry);
  }
}

@Injectable({ scope: Scope.TRANSIENT })
export class TransientService {
  private instanceId = Math.random().toString(36);
  
  getInstanceId() {
    return this.instanceId;
  }
}

@Controller('demo')
export class DemoController {
  constructor(
    private readonly service1: TransientService,
    private readonly service2: TransientService,
  ) {
    console.log('Service 1 ID:', service1.getInstanceId());
    console.log('Service 2 ID:', service2.getInstanceId());
  }
}

// database.service.ts
@Injectable() // scope: Scope.DEFAULT (за замовчуванням)
export class DatabaseService {
  constructor() {
    console.log('DatabaseService instance created');
  }
  
  query(sql: string) {
    return `Executing: ${sql}`;
  }
}

// users.service.ts
@Injectable() // scope: Scope.DEFAULT
export class UsersService {
  constructor(private readonly db: DatabaseService) {
    console.log('UsersService instance created');
  }
  
  findAll() {
    return this.db.query('SELECT * FROM users');
  }
}

// users.controller.ts
@Controller({ path: 'users', scope: Scope.REQUEST })
export class UsersController {
  constructor(private readonly usersService: UsersService) {
    console.log('UsersController instance created');
  }
  
  @Get()
  findAll() {
    return this.usersService.findAll();
  }
}

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

@Injectable({ scope: Scope.DEFAULT, durable: true })
export class ConfigService {
  // Цей провайдер завжди залишається Singleton,
  // навіть якщо споживається REQUEST-scoped класами
  
  private config = {
    apiUrl: process.env.API_URL,
    dbHost: process.env.DB_HOST,
  };
  
  get(key: string) {
    return this.config[key];
  }
}

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

// Варіант 1: Об'єкт з параметром scope
@Injectable({ scope: Scope.REQUEST })
export class RequestScopedService {
  // Новий екземпляр на кожен HTTP-запит
}

// Варіант 2: Додаткові параметри
@Injectable({
  scope: Scope.DEFAULT,
  durable: true, // Вимкнути каскадування
})
export class DurableService {
  // Завжди Singleton, навіть у REQUEST-дереві
}

// Варіант 3: TRANSIENT scope
@Injectable({ scope: Scope.TRANSIENT })
export class TransientService {
  // Новий екземпляр при кожній ін'єкції
}

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

// Варіант 1: Розширений синтаксис з scope
@Controller({ path: 'users', scope: Scope.REQUEST })
export class UsersController {
  // Новий екземпляр контролера на кожен запит
}

// Варіант 2: Комбінація з host (субдомен)
@Controller({
  path: 'admin/users',
  host: 'admin.example.com',
  scope: Scope.REQUEST,
})
export class AdminUsersController {
  // REQUEST scope + subdomain routing
}

// app.module.ts
import { Module, Scope } from '@nestjs/common';

@Module({
  providers: [
    // useClass з REQUEST scope
    {
      provide: 'LOGGER',
      useClass: RequestLogger,
      scope: Scope.REQUEST,
    },
    
    // useFactory з REQUEST scope
    {
      provide: 'DATABASE_CONNECTION',
      useFactory: (configService: ConfigService) => {
        return createDatabaseConnection(configService.get('DB_URL'));
      },
      inject: [ConfigService],
      scope: Scope.REQUEST,
    },
    
    // useValue завжди DEFAULT (немає сенсу створювати копії значення)
    {
      provide: 'API_KEY',
      useValue: process.env.API_KEY,
    },
  ],
})
export class AppModule {}

import { WebSocketGateway, SubscribeMessage, MessageBody } from '@nestjs/websockets';
import { Injectable, Scope } from '@nestjs/common';

// ❌ REQUEST scope не працює з WebSocket
@Injectable({ scope: Scope.REQUEST })
export class WebSocketContextService {
  private userId: string;
  
  setUserId(userId: string) {
    this.userId = userId;
  }
}

@WebSocketGateway()
export class ChatGateway {
  constructor(private readonly context: WebSocketContextService) {}
  
  @SubscribeMessage('sendMessage')
  handleMessage(@MessageBody() data: { message: string }) {
    // ⚠️ context.userId буде undefined або змішаний між клієнтами
    // оскільки WebSocket не має поняття "HTTP-запиту"
  }
}

import { WebSocketGateway, WebSocketServer, SubscribeMessage } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

@WebSocketGateway()
export class ChatGateway {
  @WebSocketServer()
  server: Server;
  
  handleConnection(client: Socket) {
    // Зберігаємо контекст у самому сокеті
    client.data.userId = this.extractUserId(client);
    console.log(`User ${client.data.userId} connected`);
  }
  
  @SubscribeMessage('sendMessage')
  handleMessage(client: Socket, message: string) {
    // Читаємо контекст з client.data
    const userId = client.data.userId;
    
    this.server.emit('newMessage', {
      userId,
      message,
      timestamp: new Date(),
    });
  }
  
  private extractUserId(client: Socket): string {
    // Витягуємо userId з токена авторизації
    const token = client.handshake.auth.token;
    return this.authService.getUserIdFromToken(token);
  }
}

// ✅ Правильно — DEFAULT для stateless логіки
@Injectable()
export class UsersService {
  constructor(private readonly database: Database) {}
  
  async findById(userId: string): Promise<User> {
    return this.database.query('SELECT * FROM users WHERE id = $1', [userId]);
  }
}

// ❌ Неправильно — REQUEST без причини
@Injectable({ scope: Scope.REQUEST })
export class UsersService {
  // Немає request-специфічного стану, але страждає продуктивність
  async findById(userId: string): Promise<User> {
    return this.database.query('SELECT * FROM users WHERE id = $1', [userId]);
  }
}

// ✅ Правильно — REQUEST для tenant isolation
@Injectable({ scope: Scope.REQUEST })
export class TenantService {
  constructor(@Inject(REQUEST) private readonly request: Request) {
    this.tenantId = request.headers['x-tenant-id'];
  }
}

// ❌ Неправильно — REQUEST для звичайної бізнес-логіки
@Injectable({ scope: Scope.REQUEST })
export class MathService {
  // Чиста функція, немає контексту — DEFAULT достатньо
  add(a: number, b: number): number {
    return a + b;
  }
}

// ❌ Неправильно — TRANSIENT без причини
@Injectable({ scope: Scope.TRANSIENT })
export class ConfigService {
  // Конфігурація immutable — DEFAULT ідеальний
  get(key: string) {
    return process.env[key];
  }
}

// ✅ Правильно — фабрика замість TRANSIENT
@Injectable()
export class LoggerFactory {
  create(context: string): Logger {
    return new Logger(context); // Новий екземпляр через метод
  }
}

// ✅ Правильно — REQUEST лише для middleware/context
@Injectable({ scope: Scope.REQUEST })
export class RequestContextService {
  private context: { tenantId: string; userId: string };
  
  setContext(tenantId: string, userId: string) {
    this.context = { tenantId, userId };
  }
  
  getContext() {
    return this.context;
  }
}

// DEFAULT сервіси приймають контекст як параметр
@Injectable()
export class UsersService {
  async findByTenant(tenantId: string): Promise<User[]> {
    return this.database.query(
      'SELECT * FROM users WHERE tenant_id = $1',
      [tenantId],
    );
  }
}

// Controller витягує контекст та передає далі
@Controller('users')
export class UsersController {
  constructor(
    private readonly usersService: UsersService,
    private readonly requestContext: RequestContextService,
  ) {}
  
  @Get()
  async findAll() {
    const { tenantId } = this.requestContext.getContext();
    return this.usersService.findByTenant(tenantId);
  }
}

// ✅ Правильно — пул з'єднань завжди Singleton
@Injectable({ scope: Scope.DEFAULT, durable: true })
export class DatabasePool {
  private pool: Pool;
  
  constructor() {
    this.pool = new Pool({
      host: process.env.DB_HOST,
      database: process.env.DB_NAME,
      max: 20, // Максимум 20 з'єднань
    });
  }
  
  query(sql: string, params: any[]) {
    return this.pool.query(sql, params);
  }
}

@Injectable({ scope: Scope.REQUEST })
export class DebugService {
  private instanceId = Math.random().toString(36).substring(7);
  
  constructor() {
    console.log(`[DebugService] Instance ${this.instanceId} created`);
  }
  
  getInstanceId() {
    return this.instanceId;
  }
}

// tenant.service.ts — REQUEST scope для ізоляції клієнтів
import { Injectable, Scope, Inject } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';
import { Request } from 'express';

@Injectable({ scope: Scope.REQUEST })
export class TenantService {
  private readonly tenantId: string;
  
  constructor(@Inject(REQUEST) private readonly request: Request) {
    // Витягуємо tenant з піддомену: acme.app.com → "acme"
    const subdomain = this.request.hostname.split('.')[0];
    this.tenantId = subdomain;
    
    console.log(`[TenantService] Initialized for tenant: ${this.tenantId}`);
  }
  
  getTenantId(): string {
    return this.tenantId;
  }
  
  async getTenantConfig() {
    // Завантажуємо конфігурацію конкретного клієнта
    return {
      tenantId: this.tenantId,
      features: ['analytics', 'reports'],
      limits: { users: 100, storage: '10GB' },
    };
  }
}

// users.service.ts — DEFAULT scope, приймає tenantId як параметр
@Injectable()
export class UsersService {
  constructor(private readonly database: Database) {}
  
  async findByTenant(tenantId: string): Promise<User[]> {
    return this.database.query(
      `SELECT * FROM users WHERE tenant_id = $1 ORDER BY created_at DESC`,
      [tenantId],
    );
  }
  
  async createUser(tenantId: string, userData: CreateUserDto): Promise<User> {
    return this.database.query(
      `INSERT INTO users (tenant_id, email, name) VALUES ($1, $2, $3) RETURNING *`,
      [tenantId, userData.email, userData.name],
    );
  }
}

// users.controller.ts
@Controller('users')
export class UsersController {
  constructor(
    private readonly usersService: UsersService,
    private readonly tenantService: TenantService, // REQUEST-scoped
  ) {}
  
  @Get()
  async findAll() {
    const tenantId = this.tenantService.getTenantId();
    return this.usersService.findByTenant(tenantId);
  }
  
  @Post()
  async create(@Body() createUserDto: CreateUserDto) {
    const tenantId = this.tenantService.getTenantId();
    return this.usersService.createUser(tenantId, createUserDto);
  }
}

// request-context.service.ts — REQUEST scope для tracing
import { Injectable, Scope, Inject } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';
import { Request } from 'express';
import { v4 as uuidv4 } from 'uuid';

@Injectable({ scope: Scope.REQUEST })
export class RequestContextService {
  public readonly traceId: string;
  public readonly spanId: string;
  public readonly userId: string;
  
  constructor(@Inject(REQUEST) private readonly request: Request) {
    // Витягуємо або генеруємо trace ID
    this.traceId = (request.headers['x-trace-id'] as string) || uuidv4();
    this.spanId = uuidv4();
    this.userId = (request as any).user?.id || 'anonymous';
    
    console.log(`[Trace: ${this.traceId}] Request started`);
  }
  
  createChildSpan(operation: string) {
    return {
      traceId: this.traceId,
      parentSpanId: this.spanId,
      spanId: uuidv4(),
      operation,
    };
  }
}

// external-api.service.ts — DEFAULT scope, використовує context
@Injectable()
export class ExternalApiService {
  constructor(
    private readonly httpService: HttpService,
    private readonly requestContext: RequestContextService,
  ) {}
  
  async callPartnerApi(endpoint: string, data: any) {
    const span = this.requestContext.createChildSpan('partner-api-call');
    
    console.log(`[Trace: ${span.traceId}] [Span: ${span.spanId}] Calling ${endpoint}`);
    
    try {
      const response = await firstValueFrom(
        this.httpService.post(endpoint, data, {
          headers: {
            'X-Trace-Id': span.traceId,
            'X-Parent-Span-Id': span.parentSpanId,
            'X-Span-Id': span.spanId,
          },
        }),
      );
      
      console.log(`[Trace: ${span.traceId}] [Span: ${span.spanId}] Response received`);
      return response.data;
      
    } catch (error) {
      console.error(`[Trace: ${span.traceId}] [Span: ${span.spanId}] Error:`, error.message);
      throw error;
    }
  }
}