const apiConfig = {
  baseUrl: 'https://api.example.com',
  apiKey: 'secret_key_12345',
  timeout: 5000,
  retryAttempts: 3
};

// ❌ НЕ ПРАЦЮЄ: об'єкт не може бути токеном
@Module({
  providers: [
    {
      provide: apiConfig,  // Помилка компіляції!
      useValue: apiConfig
    }
  ]
})
export class AppModule {}

// config/api.config.ts
export const API_CONFIG = {
  baseUrl: 'https://api.example.com',
  apiKey: process.env.API_KEY || 'default_key',
  timeout: 5000,
  retryAttempts: 3,
  enableLogging: true
};

// app.module.ts
import { Module } from '@nestjs/common';
import { API_CONFIG } from './config/api.config';

@Module({
  providers: [
    {
      provide: 'API_CONFIG',      // Рядковий токен
      useValue: API_CONFIG         // Значення, яке буде ін'єктовано
    }
  ]
})
export class AppModule {}

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

@Injectable()
export class ApiService {
  constructor(
    @Inject('API_CONFIG') private readonly config: typeof API_CONFIG
  ) {
    console.log(`API Base URL: ${this.config.baseUrl}`);
  }

  async fetchUsers() {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);

    try {
      const response = await fetch(`${this.config.baseUrl}/users`, {
        headers: {
          'Authorization': `Bearer ${this.config.apiKey}`
        },
        signal: controller.signal
      });

      clearTimeout(timeoutId);
      return response.json();
    } catch (error) {
      if (this.config.enableLogging) {
        console.error('API request failed:', error);
      }
      throw error;
    }
  }
}

// TypeScript автоматично визначає тип залежності
constructor(private readonly usersService: UsersService) {}

// Після компіляції JavaScript містить метадані:
// __metadata("design:paramtypes", [UsersService])

// Явне вказування токена через декоратор
constructor(@Inject('API_CONFIG') private readonly config: any) {}

// constants/injection-tokens.ts

/**
 * Централізоване сховище токенів для системи ін'єкції залежностей.
 * 
 * Використовуйте ці константи замість магічних рядків для забезпечення
 * типобезпеки та полегшення рефакторингу.
 */
export const INJECTION_TOKENS = {
  // Конфігурація
  API_CONFIG: 'API_CONFIG',
  DATABASE_CONFIG: 'DATABASE_CONFIG',
  REDIS_CONFIG: 'REDIS_CONFIG',

  // Підключення до зовнішніх сервісів
  DATABASE_CONNECTION: 'DATABASE_CONNECTION',
  REDIS_CLIENT: 'REDIS_CLIENT',
  HTTP_CLIENT: 'HTTP_CLIENT',

  // Утиліти та хелпери
  LOGGER: 'LOGGER',
  CACHE_MANAGER: 'CACHE_MANAGER',
  FILE_STORAGE: 'FILE_STORAGE',

  // Бізнес-логіка
  PAYMENT_GATEWAY: 'PAYMENT_GATEWAY',
  EMAIL_SERVICE: 'EMAIL_SERVICE',
  SMS_SERVICE: 'SMS_SERVICE'
} as const;

/**
 * Тип для автодоповнення токенів у IDE.
 * Використовуйте у дженериках: @Inject<TokenKey>()
 */
export type TokenKey = keyof typeof INJECTION_TOKENS;

// app.module.ts
import { Module } from '@nestjs/common';
import { INJECTION_TOKENS } from './constants/injection-tokens';
import { API_CONFIG } from './config/api.config';

@Module({
  providers: [
    {
      provide: INJECTION_TOKENS.API_CONFIG,
      useValue: API_CONFIG
    },
    {
      provide: INJECTION_TOKENS.HTTP_CLIENT,
      useFactory: () => {
        return axios.create({
          baseURL: API_CONFIG.baseUrl,
          timeout: API_CONFIG.timeout
        });
      }
    }
  ]
})
export class AppModule {}

// services/api.service.ts
import { Injectable, Inject } from '@nestjs/common';
import { AxiosInstance } from 'axios';
import { INJECTION_TOKENS } from '../constants/injection-tokens';

@Injectable()
export class ApiService {
  constructor(
    @Inject(INJECTION_TOKENS.API_CONFIG) 
    private readonly config: typeof API_CONFIG,
    
    @Inject(INJECTION_TOKENS.HTTP_CLIENT) 
    private readonly httpClient: AxiosInstance
  ) {}

  async getData(endpoint: string) {
    const response = await this.httpClient.get(endpoint);
    return response.data;
  }
}

// ❌ Помилка компіляції: Property 'API_CONFG' does not exist
@Inject(INJECTION_TOKENS.API_CONFG)

// ✅ Правильно: автодоповнення працює
@Inject(INJECTION_TOKENS.API_CONFIG)

// Module A (бібліотека аутентифікації)
@Module({
  providers: [
    {
      provide: 'CONFIG',
      useValue: { jwtSecret: 'secret123', tokenExpiry: 3600 }
    }
  ]
})
export class AuthModule {}

// Module B (бібліотека кешування)
@Module({
  providers: [
    {
      provide: 'CONFIG',  // ❌ Конфлікт! Той самий токен
      useValue: { ttl: 600, maxSize: 1000 }
    }
  ]
})
export class CacheModule {}

const symbol1 = Symbol('CONFIG');
const symbol2 = Symbol('CONFIG');

console.log(symbol1 === symbol2); // false — різні символи!
console.log(symbol1.description);  // 'CONFIG' — опис для налагодження

// constants/tokens.ts (Module A)
export const AUTH_CONFIG_TOKEN = Symbol('CONFIG');

// constants/tokens.ts (Module B)
export const CACHE_CONFIG_TOKEN = Symbol('CONFIG');

// Ці токени різні, хоча мають однаковий опис!
console.log(AUTH_CONFIG_TOKEN === CACHE_CONFIG_TOKEN); // false

// constants/injection-tokens.ts
export const INJECTION_TOKENS = {
  // Конфігурація
  API_CONFIG: Symbol('API_CONFIG'),
  DATABASE_CONFIG: Symbol('DATABASE_CONFIG'),
  REDIS_CONFIG: Symbol('REDIS_CONFIG'),

  // Підключення
  DATABASE_CONNECTION: Symbol('DATABASE_CONNECTION'),
  REDIS_CLIENT: Symbol('REDIS_CLIENT'),
  HTTP_CLIENT: Symbol('HTTP_CLIENT'),

  // Сервіси
  LOGGER: Symbol('LOGGER'),
  CACHE_MANAGER: Symbol('CACHE_MANAGER')
};

// Тип для типобезпеки
export type InjectionToken = typeof INJECTION_TOKENS[keyof typeof INJECTION_TOKENS];

// database.module.ts
import { Module } from '@nestjs/common';
import { DataSource } from 'typeorm';
import { INJECTION_TOKENS } from './constants/injection-tokens';

@Module({
  providers: [
    {
      provide: INJECTION_TOKENS.DATABASE_CONNECTION,
      useFactory: async (): Promise<DataSource> => {
        const dataSource = new DataSource({
          type: 'postgres',
          host: process.env.DB_HOST || 'localhost',
          port: parseInt(process.env.DB_PORT || '5432'),
          username: process.env.DB_USER || 'postgres',
          password: process.env.DB_PASSWORD,
          database: process.env.DB_NAME || 'myapp',
          entities: [__dirname + '/**/*.entity{.ts,.js}'],
          synchronize: false
        });

        await dataSource.initialize();
        console.log('✓ Database connection established');
        return dataSource;
      }
    }
  ],
  exports: [INJECTION_TOKENS.DATABASE_CONNECTION]
})
export class DatabaseModule {}

// services/users.repository.ts
import { Injectable, Inject } from '@nestjs/common';
import { DataSource, Repository } from 'typeorm';
import { INJECTION_TOKENS } from '../constants/injection-tokens';
import { User } from '../entities/user.entity';

@Injectable()
export class UsersRepository {
  private readonly repository: Repository<User>;

  constructor(
    @Inject(INJECTION_TOKENS.DATABASE_CONNECTION)
    private readonly dataSource: DataSource
  ) {
    this.repository = dataSource.getRepository(User);
  }

  async findAll(): Promise<User[]> {
    return this.repository.find();
  }

  async findById(id: number): Promise<User | null> {
    return this.repository.findOne({ where: { id } });
  }

  async create(userData: Partial<User>): Promise<User> {
    const user = this.repository.create(userData);
    return this.repository.save(user);
  }
}

// interfaces/logger.interface.ts
export interface ILogger {
  log(message: string): void;
  error(message: string, trace?: string): void;
  warn(message: string): void;
  debug(message: string): void;
}

// services/console-logger.service.ts
import { Injectable } from '@nestjs/common';
import { ILogger } from '../interfaces/logger.interface';

@Injectable()
export class ConsoleLogger implements ILogger {
  log(message: string): void {
    console.log(`[LOG] ${new Date().toISOString()} - ${message}`);
  }

  error(message: string, trace?: string): void {
    console.error(`[ERROR] ${new Date().toISOString()} - ${message}`);
    if (trace) console.error(trace);
  }

  warn(message: string): void {
    console.warn(`[WARN] ${new Date().toISOString()} - ${message}`);
  }

  debug(message: string): void {
    console.debug(`[DEBUG] ${new Date().toISOString()} - ${message}`);
  }
}

// ❌ НЕ ПРАЦЮЄ: інтерфейс не може бути токеном
@Module({
  providers: [
    {
      provide: ILogger,          // Помилка компіляції!
      useClass: ConsoleLogger
    }
  ]
})
export class AppModule {}

// abstractions/logger.abstract.ts
export abstract class Logger {
  abstract log(message: string): void;
  abstract error(message: string, trace?: string): void;
  abstract warn(message: string): void;
  abstract debug(message: string): void;
}

// services/console-logger.service.ts
import { Injectable } from '@nestjs/common';
import { Logger } from '../abstractions/logger.abstract';

@Injectable()
export class ConsoleLogger extends Logger {
  log(message: string): void {
    console.log(`[LOG] ${message}`);
  }

  error(message: string, trace?: string): void {
    console.error(`[ERROR] ${message}`, trace);
  }

  warn(message: string): void {
    console.warn(`[WARN] ${message}`);
  }

  debug(message: string): void {
    console.debug(`[DEBUG] ${message}`);
  }
}

// ✅ ПРАЦЮЄ: абстрактний клас існує у JavaScript
@Module({
  providers: [
    {
      provide: Logger,            // Абстрактний клас як токен
      useClass: ConsoleLogger     // Конкретна реалізація
    }
  ]
})
export class AppModule {}

// services/users.service.ts
import { Injectable } from '@nestjs/common';
import { Logger } from '../abstractions/logger.abstract';

@Injectable()
export class UsersService {
  constructor(private readonly logger: Logger) {
    this.logger.log('UsersService initialized');
  }

  async createUser(userData: any) {
    this.logger.log(`Creating user: ${userData.email}`);
    // Логіка створення користувача
  }
}

// interfaces/logger.interface.ts
export interface ILogger {
  log(message: string): void;
  error(message: string, trace?: string): void;
}

// Токен для ін'єкції
export const LOGGER_TOKEN = Symbol('ILogger');

import { ILogger, LOGGER_TOKEN } from './interfaces/logger.interface';
import { ConsoleLogger } from './services/console-logger.service';

@Module({
  providers: [
    {
      provide: LOGGER_TOKEN,      // Symbol як токен
      useClass: ConsoleLogger
    }
  ]
})
export class AppModule {}

import { Injectable, Inject } from '@nestjs/common';
import { ILogger, LOGGER_TOKEN } from '../interfaces/logger.interface';

@Injectable()
export class UsersService {
  constructor(
    @Inject(LOGGER_TOKEN) private readonly logger: ILogger
  ) {
    this.logger.log('UsersService initialized');
  }
}

// config/interfaces/config.interface.ts

export interface DatabaseConfig {
  host: string;
  port: number;
  username: string;
  password: string;
  database: string;
  synchronize: boolean;
  logging: boolean;
}

export interface RedisConfig {
  host: string;
  port: number;
  password?: string;
  db: number;
  keyPrefix: string;
}

export interface ApiConfig {
  baseUrl: string;
  apiKey: string;
  timeout: number;
  retryAttempts: number;
}

export interface AppConfig {
  port: number;
  environment: 'development' | 'staging' | 'production';
  logLevel: 'error' | 'warn' | 'info' | 'debug';
  corsOrigins: string[];
}

// config/config.tokens.ts

export const CONFIG_TOKENS = {
  DATABASE: Symbol('DatabaseConfig'),
  REDIS: Symbol('RedisConfig'),
  API: Symbol('ApiConfig'),
  APP: Symbol('AppConfig')
} as const;

// Допоміжний тип для типобезпеки
export type ConfigToken = typeof CONFIG_TOKENS[keyof typeof CONFIG_TOKENS];

// config/config.factory.ts
import { DatabaseConfig, RedisConfig, ApiConfig, AppConfig } from './interfaces/config.interface';

export function loadDatabaseConfig(): DatabaseConfig {
  return {
    host: process.env.DB_HOST || 'localhost',
    port: parseInt(process.env.DB_PORT || '5432'),
    username: process.env.DB_USER || 'postgres',
    password: process.env.DB_PASSWORD || '',
    database: process.env.DB_NAME || 'myapp',
    synchronize: process.env.NODE_ENV === 'development',
    logging: process.env.DB_LOGGING === 'true'
  };
}

export function loadRedisConfig(): RedisConfig {
  return {
    host: process.env.REDIS_HOST || 'localhost',
    port: parseInt(process.env.REDIS_PORT || '6379'),
    password: process.env.REDIS_PASSWORD,
    db: parseInt(process.env.REDIS_DB || '0'),
    keyPrefix: process.env.REDIS_PREFIX || 'myapp:'
  };
}

export function loadApiConfig(): ApiConfig {
  return {
    baseUrl: process.env.API_BASE_URL || 'https://api.example.com',
    apiKey: process.env.API_KEY || '',
    timeout: parseInt(process.env.API_TIMEOUT || '5000'),
    retryAttempts: parseInt(process.env.API_RETRY_ATTEMPTS || '3')
  };
}

export function loadAppConfig(): AppConfig {
  return {
    port: parseInt(process.env.PORT || '3000'),
    environment: (process.env.NODE_ENV as any) || 'development',
    logLevel: (process.env.LOG_LEVEL as any) || 'info',
    corsOrigins: process.env.CORS_ORIGINS?.split(',') || ['http://localhost:3000']
  };
}

// config/config.module.ts
import { Module, Global } from '@nestjs/common';
import { CONFIG_TOKENS } from './config.tokens';
import {
  loadDatabaseConfig,
  loadRedisConfig,
  loadApiConfig,
  loadAppConfig
} from './config.factory';

@Global()  // Робить конфігурацію доступною у всіх модулях
@Module({
  providers: [
    {
      provide: CONFIG_TOKENS.DATABASE,
      useValue: loadDatabaseConfig()
    },
    {
      provide: CONFIG_TOKENS.REDIS,
      useValue: loadRedisConfig()
    },
    {
      provide: CONFIG_TOKENS.API,
      useValue: loadApiConfig()
    },
    {
      provide: CONFIG_TOKENS.APP,
      useValue: loadAppConfig()
    }
  ],
  exports: [
    CONFIG_TOKENS.DATABASE,
    CONFIG_TOKENS.REDIS,
    CONFIG_TOKENS.API,
    CONFIG_TOKENS.APP
  ]
})
export class ConfigModule {}

// database/database.module.ts
import { Module } from '@nestjs/common';
import { DataSource } from 'typeorm';
import { CONFIG_TOKENS } from '../config/config.tokens';
import { DatabaseConfig } from '../config/interfaces/config.interface';

@Module({
  providers: [
    {
      provide: 'DATABASE_CONNECTION',
      useFactory: async (config: DatabaseConfig): Promise<DataSource> => {
        const dataSource = new DataSource({
          type: 'postgres',
          host: config.host,
          port: config.port,
          username: config.username,
          password: config.password,
          database: config.database,
          entities: [__dirname + '/../**/*.entity{.ts,.js}'],
          synchronize: config.synchronize,
          logging: config.logging
        });

        try {
          await dataSource.initialize();
          console.log(`✓ Database connected: ${config.host}:${config.port}/${config.database}`);
          return dataSource;
        } catch (error) {
          console.error('❌ Database connection failed:', error.message);
          throw error;
        }
      },
      inject: [CONFIG_TOKENS.DATABASE]
    }
  ],
  exports: ['DATABASE_CONNECTION']
})
export class DatabaseModule {}

// cache/redis.module.ts
import { Module } from '@nestjs/common';
import { createClient, RedisClientType } from 'redis';
import { CONFIG_TOKENS } from '../config/config.tokens';
import { RedisConfig } from '../config/interfaces/config.interface';

@Module({
  providers: [
    {
      provide: 'REDIS_CLIENT',
      useFactory: async (config: RedisConfig): Promise<RedisClientType> => {
        const client = createClient({
          socket: {
            host: config.host,
            port: config.port
          },
          password: config.password,
          database: config.db
        });

        client.on('error', (err) => console.error('Redis Error:', err));
        client.on('connect', () => console.log(`✓ Redis connected: ${config.host}:${config.port}`));

        await client.connect();
        return client;
      },
      inject: [CONFIG_TOKENS.REDIS]
    }
  ],
  exports: ['REDIS_CLIENT']
})
export class RedisModule {}

// services/api-client.service.ts
import { Injectable, Inject } from '@nestjs/common';
import axios, { AxiosInstance } from 'axios';
import { CONFIG_TOKENS } from '../config/config.tokens';
import { ApiConfig } from '../config/interfaces/config.interface';

@Injectable()
export class ApiClientService {
  private readonly httpClient: AxiosInstance;

  constructor(
    @Inject(CONFIG_TOKENS.API) private readonly config: ApiConfig
  ) {
    this.httpClient = axios.create({
      baseURL: this.config.baseUrl,
      timeout: this.config.timeout,
      headers: {
        'Authorization': `Bearer ${this.config.apiKey}`,
        'Content-Type': 'application/json'
      }
    });

    // Додавання retry-логіки
    this.setupRetryInterceptor();
  }

  private setupRetryInterceptor(): void {
    this.httpClient.interceptors.response.use(
      (response) => response,
      async (error) => {
        const { config } = error;
        
        if (!config._retryCount) {
          config._retryCount = 0;
        }

        if (config._retryCount < this.config.retryAttempts) {
          config._retryCount++;
          console.log(`Retry attempt ${config._retryCount}/${this.config.retryAttempts}`);
          
          // Затримка перед повтором (exponential backoff)
          await new Promise(resolve => 
            setTimeout(resolve, Math.pow(2, config._retryCount) * 1000)
          );
          
          return this.httpClient(config);
        }

        return Promise.reject(error);
      }
    );
  }

  async get<T>(endpoint: string): Promise<T> {
    const response = await this.httpClient.get<T>(endpoint);
    return response.data;
  }

  async post<T>(endpoint: string, data: any): Promise<T> {
    const response = await this.httpClient.post<T>(endpoint, data);
    return response.data;
  }
}

// app.module.ts
import { Module } from '@nestjs/common';
import { ConfigModule } from './config/config.module';
import { DatabaseModule } from './database/database.module';
import { RedisModule } from './cache/redis.module';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    ConfigModule,     // Глобальний модуль конфігурації
    DatabaseModule,
    RedisModule,
    UsersModule
  ]
})
export class AppModule {}

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { CONFIG_TOKENS } from './config/config.tokens';
import { AppConfig } from './config/interfaces/config.interface';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Отримання конфігурації з DI-контейнера
  const appConfig = app.get<AppConfig>(CONFIG_TOKENS.APP);

  // Налаштування CORS
  app.enableCors({
    origin: appConfig.corsOrigins,
    credentials: true
  });

  await app.listen(appConfig.port);
  
  console.log(`🚀 Application running on port ${appConfig.port}`);
  console.log(`📦 Environment: ${appConfig.environment}`);
  console.log(`📝 Log level: ${appConfig.logLevel}`);
}

bootstrap();

@Inject(token: string | symbol | Type<any>)

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

@Injectable()
export class UsersService {
  constructor(
    @Inject('DATABASE_CONNECTION') 
    private readonly db: any,
    
    @Inject('LOGGER') 
    private readonly logger: any
  ) {
    this.logger.log('UsersService initialized');
  }

  async findAll() {
    return this.db.query('SELECT * FROM users');
  }
}

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

@Injectable()
export class UsersService {
  @Inject('DATABASE_CONNECTION')
  private readonly db: any;

  @Inject('LOGGER')
  private readonly logger: any;

  async findAll() {
    this.logger.log('Fetching all users');
    return this.db.query('SELECT * FROM users');
  }
}

// ❌ Погано: рядок може конфліктувати з іншими бібліотеками
export const AUTH_CONFIG = 'AUTH_CONFIG';

// ✅ Добре: Symbol унікальний і не може конфліктувати
export const AUTH_CONFIG = Symbol('AUTH_CONFIG');

// constants/tokens.ts
export const TOKENS = {
  // Інфраструктура
  DATABASE: Symbol('DATABASE_CONNECTION'),
  REDIS: Symbol('REDIS_CLIENT'),
  ELASTICSEARCH: Symbol('ELASTICSEARCH_CLIENT'),

  // Конфігурація
  APP_CONFIG: Symbol('APP_CONFIG'),
  DB_CONFIG: Symbol('DB_CONFIG'),
  AUTH_CONFIG: Symbol('AUTH_CONFIG'),

  // Сервіси
  LOGGER: Symbol('LOGGER'),
  MAILER: Symbol('MAILER'),
  STORAGE: Symbol('STORAGE')
} as const;

// ❌ Погано: неясне призначення
export const TOKEN_1 = Symbol('T1');
export const DATA = Symbol('DATA');

// ✅ Добре: зрозуміле призначення
export const DATABASE_CONNECTION = Symbol('DATABASE_CONNECTION');
export const USER_REPOSITORY = Symbol('USER_REPOSITORY');

import { Injectable, Inject } from '@nestjs/common';
import { DataSource } from 'typeorm';
import { TOKENS } from '../constants/tokens';

@Injectable()
export class UsersRepository {
  constructor(
    // ✅ Добре: явна типізація
    @Inject(TOKENS.DATABASE) 
    private readonly dataSource: DataSource
  ) {}
}

/**
 * Токен для ін'єкції головного з'єднання до бази даних PostgreSQL.
 * 
 * Провайдер створює та ініціалізує TypeORM DataSource під час запуску застосунку.
 * 
 * @example
 * ```typescript
 * constructor(
 *   @Inject(TOKENS.DATABASE) private readonly db: DataSource
 * ) {}
 * ```
 */
export const DATABASE_CONNECTION = Symbol('DATABASE_CONNECTION');

// ❌ Погано: магічний рядок, схильний до помилок
constructor(@Inject('API_CONFIG') private readonly config: any) {}

// ✅ Добре: константа з автодоповненням
import { TOKENS } from '../constants/tokens';
constructor(@Inject(TOKENS.API_CONFIG) private readonly config: ApiConfig) {}

// database/database.module.ts
import { Module } from '@nestjs/common';

export const DATABASE_CONNECTION = Symbol('DATABASE_CONNECTION');

@Module({
  providers: [
    {
      provide: DATABASE_CONNECTION,
      useFactory: async () => {
        // Ініціалізація підключення
      }
    }
  ],
  exports: [DATABASE_CONNECTION]  // Експорт токена
})
export class DatabaseModule {}

// Інший модуль може імпортувати токен
import { DATABASE_CONNECTION } from '../database/database.module';

// ❌ Погано: інтерфейс зникає після компіляції
export interface IEmailService {
  sendEmail(to: string, subject: string, body: string): Promise<void>;
}

// Потрібен окремий токен
export const EMAIL_SERVICE = Symbol('IEmailService');

// ✅ Добре: абстрактний клас може бути токеном
export abstract class EmailService {
  abstract sendEmail(to: string, subject: string, body: string): Promise<void>;
}

// Реєстрація без додаткового токена
@Module({
  providers: [
    {
      provide: EmailService,
      useClass: SmtpEmailService
    }
  ]
})

// config/config.factory.ts
import { plainToInstance } from 'class-transformer';
import { validateSync } from 'class-validator';

export class DatabaseConfig {
  @IsString()
  @IsNotEmpty()
  host: string;

  @IsNumber()
  @Min(1)
  @Max(65535)
  port: number;

  @IsString()
  @IsNotEmpty()
  username: string;
}

export function loadDatabaseConfig(): DatabaseConfig {
  const config = {
    host: process.env.DB_HOST || 'localhost',
    port: parseInt(process.env.DB_PORT || '5432'),
    username: process.env.DB_USER || 'postgres'
  };

  // Перетворення та валідація
  const validated = plainToInstance(DatabaseConfig, config);
  const errors = validateSync(validated);

  if (errors.length > 0) {
    throw new Error(`Database configuration validation failed: ${errors}`);
  }

  return validated;
}

// logging/logger.abstract.ts
export enum LogLevel {
  ERROR = 'error',
  WARN = 'warn',
  INFO = 'info',
  DEBUG = 'debug'
}

export interface LogEntry {
  timestamp: Date;
  level: LogLevel;
  message: string;
  context?: string;
  trace?: string;
  metadata?: Record<string, any>;
}

export abstract class Logger {
  abstract log(entry: LogEntry): void;
  abstract error(message: string, trace?: string, context?: string): void;
  abstract warn(message: string, context?: string): void;
  abstract info(message: string, context?: string): void;
  abstract debug(message: string, context?: string): void;
}

// logging/transports/console-logger.ts
import { Injectable } from '@nestjs/common';
import { Logger, LogEntry, LogLevel } from '../logger.abstract';

@Injectable()
export class ConsoleLogger extends Logger {
  private readonly colors = {
    [LogLevel.ERROR]: '\x1b[31m',  // Червоний
    [LogLevel.WARN]: '\x1b[33m',   // Жовтий
    [LogLevel.INFO]: '\x1b[36m',   // Блакитний
    [LogLevel.DEBUG]: '\x1b[90m'   // Сірий
  };
  private readonly reset = '\x1b[0m';

  log(entry: LogEntry): void {
    const color = this.colors[entry.level] || '';
    const timestamp = entry.timestamp.toISOString();
    const context = entry.context ? `[${entry.context}]` : '';
    
    console.log(
      `${color}[${timestamp}] [${entry.level.toUpperCase()}]${this.reset} ${context} ${entry.message}`
    );

    if (entry.trace) {
      console.log(`${color}${entry.trace}${this.reset}`);
    }
  }

  error(message: string, trace?: string, context?: string): void {
    this.log({
      timestamp: new Date(),
      level: LogLevel.ERROR,
      message,
      trace,
      context
    });
  }

  warn(message: string, context?: string): void {
    this.log({
      timestamp: new Date(),
      level: LogLevel.WARN,
      message,
      context
    });
  }

  info(message: string, context?: string): void {
    this.log({
      timestamp: new Date(),
      level: LogLevel.INFO,
      message,
      context
    });
  }

  debug(message: string, context?: string): void {
    this.log({
      timestamp: new Date(),
      level: LogLevel.DEBUG,
      message,
      context
    });
  }
}

// logging/transports/file-logger.ts
import { Injectable } from '@nestjs/common';
import { Logger, LogEntry, LogLevel } from '../logger.abstract';
import * as fs from 'fs/promises';
import * as path from 'path';

@Injectable()
export class FileLogger extends Logger {
  private readonly logDir = path.join(process.cwd(), 'logs');
  private readonly logFile = path.join(this.logDir, 'app.log');

  async ensureLogDirectory(): Promise<void> {
    try {
      await fs.mkdir(this.logDir, { recursive: true });
    } catch (error) {
      console.error('Failed to create log directory:', error);
    }
  }

  log(entry: LogEntry): void {
    const logLine = JSON.stringify({
      timestamp: entry.timestamp.toISOString(),
      level: entry.level,
      message: entry.message,
      context: entry.context,
      trace: entry.trace,
      metadata: entry.metadata
    }) + '\n';

    // Асинхронний запис у файл (не блокує виконання)
    fs.appendFile(this.logFile, logLine).catch(err => {
      console.error('Failed to write to log file:', err);
    });
  }

  error(message: string, trace?: string, context?: string): void {
    this.log({
      timestamp: new Date(),
      level: LogLevel.ERROR,
      message,
      trace,
      context
    });
  }

  warn(message: string, context?: string): void {
    this.log({ timestamp: new Date(), level: LogLevel.WARN, message, context });
  }

  info(message: string, context?: string): void {
    this.log({ timestamp: new Date(), level: LogLevel.INFO, message, context });
  }

  debug(message: string, context?: string): void {
    this.log({ timestamp: new Date(), level: LogLevel.DEBUG, message, context });
  }
}

// logging/composite-logger.ts
import { Injectable, Inject } from '@nestjs/common';
import { Logger, LogEntry } from './logger.abstract';

export const LOGGER_TRANSPORTS = Symbol('LOGGER_TRANSPORTS');

@Injectable()
export class CompositeLogger extends Logger {
  constructor(
    @Inject(LOGGER_TRANSPORTS) 
    private readonly transports: Logger[]
  ) {
    super();
  }

  log(entry: LogEntry): void {
    // Відправка логу до всіх транспортів
    this.transports.forEach(transport => transport.log(entry));
  }

  error(message: string, trace?: string, context?: string): void {
    this.transports.forEach(transport => transport.error(message, trace, context));
  }

  warn(message: string, context?: string): void {
    this.transports.forEach(transport => transport.warn(message, context));
  }

  info(message: string, context?: string): void {
    this.transports.forEach(transport => transport.info(message, context));
  }

  debug(message: string, context?: string): void {
    this.transports.forEach(transport => transport.debug(message, context));
  }
}

// logging/logging.module.ts
import { Module } from '@nestjs/common';
import { Logger } from './logger.abstract';
import { ConsoleLogger } from './transports/console-logger';
import { FileLogger } from './transports/file-logger';
import { CompositeLogger, LOGGER_TRANSPORTS } from './composite-logger';

@Module({
  providers: [
    ConsoleLogger,
    FileLogger,
    {
      provide: LOGGER_TRANSPORTS,
      useFactory: (
        consoleLogger: ConsoleLogger,
        fileLogger: FileLogger
      ): Logger[] => {
        const transports: Logger[] = [consoleLogger];

        // У продакшні додаємо файловий логер
        if (process.env.NODE_ENV === 'production') {
          transports.push(fileLogger);
        }

        return transports;
      },
      inject: [ConsoleLogger, FileLogger]
    },
    {
      provide: Logger,
      useClass: CompositeLogger
    }
  ],
  exports: [Logger]
})
export class LoggingModule {}

// users/users.service.ts
import { Injectable } from '@nestjs/common';
import { Logger } from '../logging/logger.abstract';

@Injectable()
export class UsersService {
  constructor(private readonly logger: Logger) {
    this.logger.info('UsersService initialized', 'UsersService');
  }

  async findAll() {
    this.logger.debug('Fetching all users from database', 'UsersService');
    
    try {
      // Логіка отримання користувачів
      const users = []; // ... запит до БД
      
      this.logger.info(`Found ${users.length} users`, 'UsersService');
      return users;
    } catch (error) {
      this.logger.error(
        'Failed to fetch users',
        error.stack,
        'UsersService'
      );
      throw error;
    }
  }
}