@vritti/api-sdk 0.0.8 → 0.1.0

package/dist/index.cjs

@@ -36,13 +36,19 @@ __export(index_exports, {
   BadRequestException: () => BadRequestException,
   BaseFieldException: () => BaseFieldException,
   ConflictException: () => ConflictException,
+  CorrelationIdMiddleware: () => CorrelationIdMiddleware,
   CsrfGuard: () => CsrfGuard,
+  DEFAULT_CORRELATION_HEADER: () => DEFAULT_CORRELATION_HEADER,
   DatabaseModule: () => DatabaseModule,
   ForbiddenException: () => ForbiddenException2,
   GoneException: () => GoneException,
   HttpExceptionFilter: () => HttpExceptionFilter,
+  HttpLoggerInterceptor: () => HttpLoggerInterceptor,
   HttpModule: () => HttpModule,
   InternalServerErrorException: () => InternalServerErrorException3,
+  LOGGER_MODULE_OPTIONS: () => LOGGER_MODULE_OPTIONS,
+  LoggerModule: () => LoggerModule,
+  LoggerService: () => LoggerService2,
   MethodNotAllowedException: () => MethodNotAllowedException,
   NotAcceptableException: () => NotAcceptableException,
   NotFoundException: () => NotFoundException,
@@ -64,7 +70,13 @@ __export(index_exports, {
   UnsupportedMediaTypeException: () => UnsupportedMediaTypeException,
   ValidationException: () => ValidationException,
   VrittiAuthGuard: () => VrittiAuthGuard,
-  getHttpStatusTitle: () => getHttpStatusTitle
+  addCorrelationIdToResponse: () => addCorrelationIdToResponse,
+  correlationStorage: () => correlationStorage,
+  generateCorrelationId: () => generateCorrelationId,
+  getCorrelationContext: () => getCorrelationContext,
+  getHttpStatusTitle: () => getHttpStatusTitle,
+  runWithCorrelationContext: () => runWithCorrelationContext,
+  updateCorrelationContext: () => updateCorrelationContext
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -210,6 +222,9 @@ var jwt = __toESM(require("jsonwebtoken"), 1);
 
 // src/database/services/primary-database.service.ts
 var import_common3 = require("@nestjs/common");
+var import_pg = require("pg");
+var import_node_postgres = require("drizzle-orm/node-postgres");
+var import_drizzle_orm = require("drizzle-orm");
 
 // src/database/constants.ts
 var DATABASE_MODULE_OPTIONS = Symbol("DATABASE_MODULE_OPTIONS");
@@ -238,8 +253,10 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
   }
   options;
   logger = new import_common3.Logger(_PrimaryDatabaseService.name);
-  /** Primary database client for querying tenant registry */
-  primaryDbClient;
+  /** PostgreSQL connection pool */
+  pool = null;
+  /** Drizzle database instance */
+  db = null;
   /** In-memory cache: Map<tenantIdentifier, TenantConfig> */
   tenantConfigCache = /* @__PURE__ */ new Map();
   /** Cache TTL in milliseconds */
@@ -250,28 +267,24 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
   }
   async onModuleInit() {
     if (this.options.primaryDb) {
-      await this.initializePrimaryDbClient();
+      await this.initializeDrizzleClient();
     }
   }
   /**
-  * Initialize connection to primary database
+  * Initialize connection to primary database using Drizzle
   */
-  async initializePrimaryDbClient() {
+  async initializeDrizzleClient() {
     try {
-      const PrimaryDbClient = this.options.prismaClientConstructor;
       const databaseUrl = this.buildPrimaryDbUrl();
-      this.primaryDbClient = new PrimaryDbClient({
-        datasources: {
-          db: {
-            url: databaseUrl
-          }
-        },
-        log: [
-          "error",
-          "warn"
-        ]
+      this.pool = new import_pg.Pool({
+        connectionString: databaseUrl,
+        max: this.options.maxConnections || 10
       });
-      await this.primaryDbClient.$connect();
+      this.db = (0, import_node_postgres.drizzle)({
+        client: this.pool,
+        schema: this.options.drizzleSchema
+      });
+      await this.pool.query("SELECT 1");
       this.logger.log("Connected to primary database (tenant registry)");
     } catch (error) {
       this.logger.error("Failed to connect to primary database", error);
@@ -286,7 +299,7 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
       throw new Error("Primary database configuration not provided");
     }
     const { host, port = 5432, username, password, database, schema = "public", sslMode = "require" } = this.options.primaryDb;
-    let url = `postgresql://${username}:${password}@${host}:${port}/${database}`;
+    let url = `postgresql://${username}:${encodeURIComponent(password)}@${host}:${port}/${database}`;
     const params = new URLSearchParams();
     if (schema) {
       params.set("schema", schema);
@@ -306,9 +319,9 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
     return url.replace(/:([^@]+)@/, ":****@");
   }
   /**
-  * Get tenant configuration by identifier (ID or slug)
+  * Get tenant configuration by identifier (ID or subdomain)
   *
-  * @param tenantIdentifier Tenant ID or slug
+  * @param tenantIdentifier Tenant ID or subdomain
   * @returns Tenant configuration or null if not found
   */
   async getTenantInfo(tenantIdentifier) {
@@ -318,45 +331,39 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
       return cached;
     }
     try {
-      if (!this.primaryDbClient) {
+      if (!this.db) {
         throw new Error("Primary database client not initialized");
       }
       this.logger.debug(`Querying primary database for tenant: ${tenantIdentifier}`);
-      const tenant = await this.primaryDbClient.tenant.findFirst({
-        where: {
-          OR: [
-            {
-              id: tenantIdentifier
-            },
-            {
-              subdomain: tenantIdentifier
-            }
-          ],
-          status: "ACTIVE"
-        },
-        include: {
-          databaseConfig: true
-        }
-      });
-      if (!tenant) {
+      const schema = this.options.drizzleSchema;
+      const { tenants, tenantDatabaseConfigs } = schema;
+      const result = await this.db.select().from(tenants).leftJoin(tenantDatabaseConfigs, (0, import_drizzle_orm.eq)(tenants.id, tenantDatabaseConfigs.tenantId)).where((0, import_drizzle_orm.or)((0, import_drizzle_orm.eq)(tenants.id, tenantIdentifier), (0, import_drizzle_orm.eq)(tenants.subdomain, tenantIdentifier))).limit(1);
+      if (!result.length) {
         this.logger.warn(`Tenant not found: ${tenantIdentifier}`);
         return null;
       }
+      const row = result[0];
+      const tenant = row.tenants;
+      const config = row.tenant_database_configs;
+      if (tenant.status !== "ACTIVE") {
+        this.logger.warn(`Tenant not active: ${tenantIdentifier}`);
+        return null;
+      }
       const info = {
         id: tenant.id,
         subdomain: tenant.subdomain,
         type: tenant.dbType,
         status: tenant.status,
         // For SHARED tenants: schema name
-        schemaName: tenant.databaseConfig?.dbSchema || void 0,
+        schemaName: config?.dbSchema || void 0,
         // For DEDICATED tenants: database configuration from TenantDatabaseConfig table
-        databaseName: tenant.databaseConfig?.dbName || void 0,
-        databaseHost: tenant.databaseConfig?.dbHost || void 0,
-        databasePort: tenant.databaseConfig?.dbPort || void 0,
-        databaseUsername: tenant.databaseConfig?.dbUsername ? this.decrypt(tenant.databaseConfig.dbUsername) : void 0,
-        databasePassword: tenant.databaseConfig?.dbPassword ? this.decrypt(tenant.databaseConfig.dbPassword) : void 0,
-        databaseSslMode: tenant.databaseConfig?.dbSslMode || void 0,
-        connectionPoolSize: tenant.databaseConfig?.connectionPoolSize || void 0
+        databaseName: config?.dbName || void 0,
+        databaseHost: config?.dbHost || void 0,
+        databasePort: config?.dbPort || void 0,
+        databaseUsername: config?.dbUsername ? this.decrypt(config.dbUsername) : void 0,
+        databasePassword: config?.dbPassword ? this.decrypt(config.dbPassword) : void 0,
+        databaseSslMode: config?.dbSslMode || void 0,
+        connectionPoolSize: config?.connectionPoolSize || void 0
       };
       this.cacheInfo(info);
       return info;
@@ -382,7 +389,7 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
   *
   * Useful when tenant settings are updated and cache needs to be invalidated
   *
-  * @param tenantIdentifier Tenant ID or slug
+  * @param tenantIdentifier Tenant ID or subdomain
   */
   clearTenantCache(tenantIdentifier) {
     const config = this.tenantConfigCache.get(tenantIdentifier);
@@ -401,17 +408,23 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
     this.logger.log(`Cleared ${size} cached tenant configs`);
   }
   /**
-  * Get the Prisma client for the primary database.
-  * This is a synchronous property that returns the initialized Prisma client.
+  * Get the Drizzle database instance for the primary database.
+  * This is a synchronous property that returns the initialized Drizzle client.
   *
-  * @returns Primary database client instance
+  * @returns Primary database Drizzle instance
   * @throws Error if primary database client is not initialized
   */
-  get prismaClient() {
-    if (!this.primaryDbClient) {
+  get drizzleClient() {
+    if (!this.db) {
       throw new Error("Primary database client not initialized");
     }
-    return this.primaryDbClient;
+    return this.db;
+  }
+  /**
+  * Get the Drizzle schema
+  */
+  get schema() {
+    return this.options.drizzleSchema;
   }
   /**
   * Decrypt database credentials
@@ -425,8 +438,8 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
     return encrypted;
   }
   async onModuleDestroy() {
-    if (this.primaryDbClient) {
-      await this.primaryDbClient.$disconnect();
+    if (this.pool) {
+      await this.pool.end();
       this.logger.log("Disconnected from primary database");
     }
   }
@@ -971,6 +984,8 @@ TenantContextInterceptor = _ts_decorate8([
 
 // src/database/services/tenant-database.service.ts
 var import_common9 = require("@nestjs/common");
+var import_pg2 = require("pg");
+var import_node_postgres2 = require("drizzle-orm/node-postgres");
 function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -995,7 +1010,7 @@ var TenantDatabaseService = class _TenantDatabaseService {
   options;
   tenantContext;
   logger = new import_common9.Logger(_TenantDatabaseService.name);
-  /** Connection pool: Map<cacheKey, DbClient> */
+  /** Connection pool: Map<cacheKey, TenantConnection> */
   clients = /* @__PURE__ */ new Map();
   /** Track last usage time for idle connection cleanup */
   clientLastUsed = /* @__PURE__ */ new Map();
@@ -1007,17 +1022,23 @@ var TenantDatabaseService = class _TenantDatabaseService {
     this.startConnectionCleaner();
   }
   /**
-  * Get the Prisma client for the current tenant's database.
+  * Get the Drizzle client for the current tenant's database.
   * This returns the tenant-scoped database client.
   *
-  * @returns Tenant-scoped database client instance
+  * @returns Tenant-scoped Drizzle database instance
   * @throws UnauthorizedException if tenant context not set
   * @throws InternalServerErrorException if connection fails
   */
-  get prismaClient() {
+  get drizzleClient() {
     return this.getDbClient();
   }
   /**
+  * Get the Drizzle schema
+  */
+  get schema() {
+    return this.options.drizzleSchema;
+  }
+  /**
   * Get tenant-scoped database client for the current request/message
   *
   * This method:
@@ -1025,66 +1046,61 @@ var TenantDatabaseService = class _TenantDatabaseService {
   * 2. Builds a connection URL based on tenant type
   * 3. Returns cached client if exists, otherwise creates new one
   *
-  * @returns Promise<Database client instance>
+  * @returns Drizzle database instance
   * @throws UnauthorizedException if tenant context not set
   * @throws InternalServerErrorException if connection fails
-  *
-  * @example
-  * const dbClient = await tenantDatabase.getDbClient<PrismaClient>();
-  * const users = await dbClient.user.findMany();
   */
-  async getDbClient() {
+  getDbClient() {
     const tenant = this.tenantContext.getTenant();
     const cacheKey = this.buildCacheKey(tenant);
-    if (this.clients.has(cacheKey)) {
+    const existing = this.clients.get(cacheKey);
+    if (existing) {
       this.clientLastUsed.set(cacheKey, Date.now());
       this.logger.debug(`Reusing cached connection: ${cacheKey}`);
-      return this.clients.get(cacheKey);
+      return existing.db;
     }
     this.logger.log(`Creating new database connection: ${cacheKey}`);
-    const client = await this.createDbClient(tenant);
-    this.clients.set(cacheKey, client);
+    const connection = this.createDbClientSync(tenant);
+    this.clients.set(cacheKey, connection);
     this.clientLastUsed.set(cacheKey, Date.now());
-    return client;
+    return connection.db;
   }
   /**
-  * Create a new database client for the given tenant
+  * Create a new database client for the given tenant (synchronous)
   */
-  async createDbClient(tenant) {
+  createDbClientSync(tenant) {
     try {
       const databaseUrl = this.buildTenantDbUrl(tenant);
-      const PrismaClient = await this.options.prismaClientConstructor;
-      const client = new PrismaClient({
-        datasources: {
-          db: {
-            url: databaseUrl
-          }
-        },
-        log: [
-          "error",
-          "warn"
-        ]
+      const pool = new import_pg2.Pool({
+        connectionString: databaseUrl,
+        max: tenant.connectionPoolSize || this.options.maxConnections || 10
+      });
+      const db = (0, import_node_postgres2.drizzle)({
+        client: pool,
+        schema: this.options.drizzleSchema
       });
-      await client.$connect();
       this.logger.log(`Connected to database for tenant: ${tenant.subdomain}`);
-      return client;
+      return {
+        pool,
+        db
+      };
     } catch (error) {
       this.logger.error(`Failed to create database connection for tenant: ${tenant.subdomain}`, error);
       throw new import_common9.InternalServerErrorException("Failed to connect to tenant database");
     }
   }
   /**
-  * Build connection URL for enterprise tenant (dedicated database)
+  * Build connection URL for tenant (dedicated database)
   */
   buildTenantDbUrl(tenant) {
     const { databaseHost, databasePort, databaseName, databaseUsername, databasePassword, databaseSslMode } = tenant;
     if (!databaseHost || !databaseName || !databaseUsername) {
-      throw new Error(`Enterprise tenant ${tenant.subdomain} missing database configuration`);
+      throw new Error(`Tenant ${tenant.subdomain} missing database configuration`);
     }
     const port = databasePort || 5432;
     const sslMode = databaseSslMode || "require";
-    const connectionUrl = `postgresql://${databaseUsername}:${databasePassword}@${databaseHost}:${port}/${databaseName}?sslmode=${sslMode}`;
-    this.logger.debug(`Enterprise connection URL: ${this.maskPassword(connectionUrl)}`);
+    const connectionUrl = `postgresql://${databaseUsername}:${encodeURIComponent(databasePassword || "")}@${databaseHost}:${port}/${databaseName}?sslmode=${sslMode}`;
+    this.logger.debug(`Tenant connection URL: ${this.maskPassword(connectionUrl)}`);
     return connectionUrl;
   }
   /**
@@ -1106,19 +1122,20 @@ var TenantDatabaseService = class _TenantDatabaseService {
   /**
   * Clean up idle connections that haven't been used recently
   */
-  cleanupIdleConnections() {
+  async cleanupIdleConnections() {
     const now = Date.now();
     const maxIdle = this.options.connectionCacheTTL || 3e5;
     let cleaned = 0;
     for (const [key, lastUsed] of this.clientLastUsed.entries()) {
       if (now - lastUsed > maxIdle) {
-        const client = this.clients.get(key);
-        if (client) {
-          client.$disconnect().then(() => {
+        const connection = this.clients.get(key);
+        if (connection) {
+          try {
+            await connection.pool.end();
             this.logger.debug(`Cleaned up idle connection: ${key}`);
-          }).catch((error) => {
+          } catch (error) {
             this.logger.error(`Error disconnecting idle client: ${key}`, error);
-          });
+          }
           this.clients.delete(key);
           this.clientLastUsed.delete(key);
           cleaned++;
@@ -1149,9 +1166,9 @@ var TenantDatabaseService = class _TenantDatabaseService {
       clearInterval(this.cleanupInterval);
     }
     this.logger.log(`Disconnecting ${this.clients.size} database connections`);
-    const disconnectPromises = Array.from(this.clients.entries()).map(async ([key, client]) => {
+    const disconnectPromises = Array.from(this.clients.entries()).map(async ([key, connection]) => {
       try {
-        await client.$disconnect();
+        await connection.pool.end();
         this.logger.debug(`Disconnected: ${key}`);
       } catch (error) {
         this.logger.error(`Error disconnecting client: ${key}`, error);
@@ -1287,56 +1304,64 @@ DatabaseModule = _ts_decorate10([
 
 // src/database/repositories/primary-base.repository.ts
 var import_common11 = require("@nestjs/common");
+var import_drizzle_orm2 = require("drizzle-orm");
 var PrimaryBaseRepository = class {
   static {
     __name(this, "PrimaryBaseRepository");
   }
   database;
+  table;
   logger;
-  modelGetter;
   /**
-  * Lazy getter for Prisma client.
+  * The table name extracted from the Drizzle table at runtime.
+  * Used to access the query API for this repository's table.
+  */
+  tableName;
+  /**
+  * Lazy getter for Drizzle client.
   * Accesses the client from the database service only when needed,
   * avoiding initialization timing issues with NestJS lifecycle.
   */
-  get prisma() {
-    return this.database.prismaClient;
+  get db() {
+    return this.database.drizzleClient;
   }
   /**
-  * Lazy getter for the Prisma model delegate.
-  * Returns the specific model (e.g., prisma.user, prisma.tenant) for this repository.
+  * Model query API for THIS repository's table (Prisma-like syntax)
+  * Scoped to only the table this repository manages.
+  * Returns a type-safe wrapper around Drizzle's RelationalQueryBuilder.
+  *
+  * @example
+  * ```typescript
+  * // Use relational queries with type safety
+  * const user = await this.model.findFirst({
+  *   where: eq(users.id, id),
+  *   with: { posts: true, profile: true }
+  * });
+  * ```
   */
   get model() {
-    return this.modelGetter(this.prisma);
+    return this.database.drizzleClient.query[this.tableName];
   }
   /**
   * Create a new repository instance
   *
   * @param database - The primary database service
-  * @param getModel - Function that returns the Prisma model delegate from the client
+  * @param table - The Drizzle table schema object
   *
   * @example
   * ```typescript
-  * // Standard usage with full parameter name
-  * constructor(database: PrimaryDatabaseService) {
-  *   super(database, (prisma) => prisma.user);
-  * }
-  *
-  * // Short syntax
-  * constructor(database: PrimaryDatabaseService) {
-  *   super(database, (p) => p.user);
-  * }
+  * import { users } from '@/db/schema';
   *
-  * // Complex model names
   * constructor(database: PrimaryDatabaseService) {
-  *   super(database, (p) => p.emailVerification);
+  *   super(database, users);
   * }
   * ```
   */
-  constructor(database, getModel) {
+  constructor(database, table) {
     this.database = database;
+    this.table = table;
+    this.tableName = (0, import_drizzle_orm2.getTableName)(table);
     this.logger = new import_common11.Logger(this.constructor.name);
-    this.modelGetter = getModel;
     this.logger.debug(`Initialized ${this.constructor.name}`);
   }
   /**
@@ -1349,21 +1374,20 @@ var PrimaryBaseRepository = class {
   * ```typescript
   * const user = await userRepository.create({
   *   email: 'user@example.com',
-  *   name: 'John Doe'
+  *   firstName: 'John'
   * });
   * ```
   */
   async create(data) {
     this.logger.log("Creating record");
-    return await this.model.create({
-      data
-    });
+    const results = await this.db.insert(this.table).values(data).returning();
+    return results[0];
   }
   /**
   * Find a single record by ID
   *
   * @param id - The record ID
-  * @returns Promise resolving to the record or null if not found
+  * @returns Promise resolving to the record or undefined if not found
   *
   * @example
   * ```typescript
@@ -1372,59 +1396,54 @@ var PrimaryBaseRepository = class {
   */
   async findById(id) {
     this.logger.debug(`Finding record by ID: ${id}`);
-    return await this.model.findUnique({
-      where: {
-        id
-      }
+    const idColumn = this.table.id;
+    return this.model.findFirst({
+      where: (0, import_drizzle_orm2.eq)(idColumn, id)
     });
   }
   /**
   * Find a single record with custom where clause
   *
-  * @param where - The where clause or findUnique args
-  * @returns Promise resolving to the record or null if not found
+  * @param where - SQL condition
+  * @returns Promise resolving to the record or undefined if not found
   *
   * @example
   * ```typescript
-  * // Simple where clause
-  * const user = await userRepository.findOne({ email: 'user@example.com' });
-  *
-  * // With include
-  * const user = await userRepository.findOne({
-  *   where: { email: 'user@example.com' },
-  *   include: { posts: true }
-  * });
+  * import { eq } from 'drizzle-orm';
+  * const user = await userRepository.findOne(eq(users.email, 'user@example.com'));
   * ```
   */
   async findOne(where) {
     this.logger.debug("Finding record with custom query");
-    return await this.model.findUnique(typeof where === "object" && "where" in where ? where : {
+    return this.model.findFirst({
       where
     });
   }
   /**
   * Find multiple records
   *
-  * @param args - Prisma findMany arguments (where, orderBy, take, skip, etc.)
+  * @param options - Query options (where, orderBy, limit, offset)
   * @returns Promise resolving to an array of records
   *
   * @example
   * ```typescript
+  * import { eq, desc } from 'drizzle-orm';
+  *
   * // Find all users
   * const users = await userRepository.findMany();
   *
   * // Find with filtering and pagination
   * const users = await userRepository.findMany({
-  *   where: { status: 'ACTIVE' },
-  *   orderBy: { createdAt: 'desc' },
-  *   take: 10,
-  *   skip: 0
+  *   where: eq(users.accountStatus, 'ACTIVE'),
+  *   orderBy: desc(users.createdAt),
+  *   limit: 10,
+  *   offset: 0
   * });
   * ```
   */
-  async findMany(args) {
+  async findMany(options) {
     this.logger.debug("Finding multiple records");
-    return await this.model.findMany(args);
+    return this.model.findMany(options);
   }
   /**
   * Update a record by ID
@@ -1436,41 +1455,40 @@ var PrimaryBaseRepository = class {
   * @example
   * ```typescript
   * const user = await userRepository.update('user-id-123', {
-  *   name: 'Jane Doe'
+  *   firstName: 'Jane'
   * });
   * ```
   */
   async update(id, data) {
     this.logger.log(`Updating record with ID: ${id}`);
-    return await this.model.update({
-      where: {
-        id
-      },
-      data
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.update(this.table).set(data).where((0, import_drizzle_orm2.eq)(idColumn, id)).returning();
+    return results[0];
   }
   /**
   * Update multiple records
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @param data - The data to update
   * @returns Promise resolving to the count of updated records
   *
   * @example
   * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
   * const result = await userRepository.updateMany(
-  *   { status: 'PENDING' },
-  *   { status: 'ACTIVE' }
+  *   eq(users.accountStatus, 'PENDING'),
+  *   { accountStatus: 'ACTIVE' }
   * );
   * console.log(`Updated ${result.count} users`);
   * ```
   */
   async updateMany(where, data) {
     this.logger.log("Updating multiple records");
-    return await this.model.updateMany({
-      where,
-      data
-    });
+    const result = await this.db.update(this.table).set(data).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
   }
   /**
   * Delete a record by ID
@@ -1485,127 +1503,143 @@ var PrimaryBaseRepository = class {
   */
   async delete(id) {
     this.logger.log(`Deleting record with ID: ${id}`);
-    return await this.model.delete({
-      where: {
-        id
-      }
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.delete(this.table).where((0, import_drizzle_orm2.eq)(idColumn, id)).returning();
+    return results[0];
   }
   /**
   * Delete multiple records
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @returns Promise resolving to the count of deleted records
   *
   * @example
   * ```typescript
-  * const result = await userRepository.deleteMany({
-  *   status: 'INACTIVE',
-  *   createdAt: { lt: new Date('2020-01-01') }
-  * });
+  * import { lt } from 'drizzle-orm';
+  *
+  * const result = await userRepository.deleteMany(
+  *   lt(users.createdAt, new Date('2020-01-01'))
+  * );
   * console.log(`Deleted ${result.count} users`);
   * ```
   */
   async deleteMany(where) {
     this.logger.log("Deleting multiple records");
-    return await this.model.deleteMany({
-      where
-    });
+    const result = await this.db.delete(this.table).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
   }
   /**
   * Count records
   *
-  * @param where - Optional where clause to filter records
+  * @param where - Optional SQL condition to filter records
   * @returns Promise resolving to the count of records
   *
   * @example
   * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
   * // Count all users
   * const total = await userRepository.count();
   *
   * // Count active users
-  * const activeCount = await userRepository.count({ status: 'ACTIVE' });
+  * const activeCount = await userRepository.count(
+  *   eq(users.accountStatus, 'ACTIVE')
+  * );
   * ```
   */
   async count(where) {
     this.logger.debug("Counting records");
-    return await this.model.count({
-      where
-    });
+    let query = this.db.select({
+      count: import_drizzle_orm2.sql`count(*)::int`
+    }).from(this.table).$dynamic();
+    if (where) {
+      query = query.where(where);
+    }
+    const results = await query;
+    return results[0].count;
   }
   /**
   * Check if a record exists
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @returns Promise resolving to true if at least one record exists, false otherwise
   *
   * @example
   * ```typescript
-  * const emailExists = await userRepository.exists({
-  *   email: 'user@example.com'
-  * });
+  * import { eq } from 'drizzle-orm';
+  *
+  * const emailExists = await userRepository.exists(
+  *   eq(users.email, 'user@example.com')
+  * );
   * ```
   */
   async exists(where) {
-    const count = await this.model.count({
-      where
-    });
+    const count = await this.count(where);
     return count > 0;
   }
 };
 
 // src/database/repositories/tenant-base.repository.ts
 var import_common12 = require("@nestjs/common");
+var import_drizzle_orm3 = require("drizzle-orm");
 var TenantBaseRepository = class {
   static {
     __name(this, "TenantBaseRepository");
   }
   database;
+  table;
   logger;
-  modelGetter;
   /**
-  * Lazy getter for Prisma client.
+  * The table name extracted from the Drizzle table at runtime.
+  * Used to access the query API for this repository's table.
+  */
+  tableName;
+  /**
+  * Lazy getter for Drizzle client.
   * Accesses the client from the database service only when needed,
   * avoiding initialization timing issues with NestJS lifecycle.
   */
-  get prisma() {
-    return this.database.prismaClient;
+  get db() {
+    return this.database.drizzleClient;
   }
   /**
-  * Lazy getter for the Prisma model delegate.
-  * Returns the specific model (e.g., prisma.product, prisma.order) for this repository.
+  * Model query API for THIS repository's table (Prisma-like syntax)
+  * Scoped to only the table this repository manages
+  *
+  * @example
+  * ```typescript
+  * // Use relational queries with type safety
+  * const product = await this.model.findFirst({
+  *   where: eq(products.id, id),
+  *   with: { category: true, variants: true }
+  * });
+  * ```
   */
   get model() {
-    return this.modelGetter(this.prisma);
+    return this.database.drizzleClient.query[this.tableName];
   }
   /**
   * Create a new repository instance
   *
   * @param database - The tenant database service
-  * @param getModel - Function that returns the Prisma model delegate from the client
+  * @param table - The Drizzle table schema object
   *
   * @example
   * ```typescript
-  * // Standard usage with full parameter name
-  * constructor(database: TenantDatabaseService) {
-  *   super(database, (prisma) => prisma.product);
-  * }
-  *
-  * // Short syntax
-  * constructor(database: TenantDatabaseService) {
-  *   super(database, (p) => p.product);
-  * }
+  * import { products } from '@/db/schema';
   *
-  * // Complex model names
   * constructor(database: TenantDatabaseService) {
-  *   super(database, (p) => p.inventoryItem);
+  *   super(database, products);
   * }
   * ```
   */
-  constructor(database, getModel) {
+  constructor(database, table) {
     this.database = database;
+    this.table = table;
+    this.tableName = (0, import_drizzle_orm3.getTableName)(table);
     this.logger = new import_common12.Logger(this.constructor.name);
-    this.modelGetter = getModel;
     this.logger.debug(`Initialized ${this.constructor.name}`);
   }
   /**
@@ -1625,9 +1659,8 @@ var TenantBaseRepository = class {
   */
   async create(data) {
     this.logger.log("Creating record");
-    return await this.model.create({
-      data
-    });
+    const results = await this.db.insert(this.table).values(data).returning();
+    return results[0];
   }
   /**
   * Find a single record by ID
@@ -1642,59 +1675,65 @@ var TenantBaseRepository = class {
   */
   async findById(id) {
     this.logger.debug(`Finding record by ID: ${id}`);
-    return await this.model.findUnique({
-      where: {
-        id
-      }
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.select().from(this.table).where((0, import_drizzle_orm3.eq)(idColumn, id)).limit(1);
+    return results[0] ?? null;
   }
   /**
   * Find a single record with custom where clause
   *
-  * @param where - The where clause or findUnique args
+  * @param where - SQL condition
   * @returns Promise resolving to the record or null if not found
   *
   * @example
   * ```typescript
-  * // Simple where clause
-  * const product = await productRepository.findOne({ sku: 'WDG-001' });
-  *
-  * // With include
-  * const product = await productRepository.findOne({
-  *   where: { sku: 'WDG-001' },
-  *   include: { category: true }
-  * });
+  * import { eq } from 'drizzle-orm';
+  * const product = await productRepository.findOne(eq(products.sku, 'WDG-001'));
   * ```
   */
   async findOne(where) {
     this.logger.debug("Finding record with custom query");
-    return await this.model.findUnique(typeof where === "object" && "where" in where ? where : {
-      where
-    });
+    const results = await this.db.select().from(this.table).where(where).limit(1);
+    return results[0] ?? null;
   }
   /**
   * Find multiple records
   *
-  * @param args - Prisma findMany arguments (where, orderBy, take, skip, etc.)
+  * @param options - Query options (where, orderBy, limit, offset)
   * @returns Promise resolving to an array of records
   *
   * @example
   * ```typescript
+  * import { eq, desc } from 'drizzle-orm';
+  *
   * // Find all products
   * const products = await productRepository.findMany();
   *
   * // Find with filtering and pagination
   * const products = await productRepository.findMany({
-  *   where: { status: 'ACTIVE' },
-  *   orderBy: { createdAt: 'desc' },
-  *   take: 10,
-  *   skip: 0
+  *   where: eq(products.status, 'ACTIVE'),
+  *   orderBy: desc(products.createdAt),
+  *   limit: 10,
+  *   offset: 0
   * });
   * ```
   */
-  async findMany(args) {
+  async findMany(options) {
     this.logger.debug("Finding multiple records");
-    return await this.model.findMany(args);
+    let query = this.db.select().from(this.table).$dynamic();
+    if (options?.where) {
+      query = query.where(options.where);
+    }
+    if (options?.orderBy) {
+      query = query.orderBy(options.orderBy);
+    }
+    if (options?.limit) {
+      query = query.limit(options.limit);
+    }
+    if (options?.offset) {
+      query = query.offset(options.offset);
+    }
+    return await query;
   }
   /**
   * Update a record by ID
@@ -1712,24 +1751,23 @@ var TenantBaseRepository = class {
   */
   async update(id, data) {
     this.logger.log(`Updating record with ID: ${id}`);
-    return await this.model.update({
-      where: {
-        id
-      },
-      data
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.update(this.table).set(data).where((0, import_drizzle_orm3.eq)(idColumn, id)).returning();
+    return results[0];
   }
   /**
   * Update multiple records
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @param data - The data to update
   * @returns Promise resolving to the count of updated records
   *
   * @example
   * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
   * const result = await productRepository.updateMany(
-  *   { status: 'PENDING' },
+  *   eq(products.status, 'PENDING'),
   *   { status: 'ACTIVE' }
   * );
   * console.log(`Updated ${result.count} products`);
@@ -1737,10 +1775,10 @@ var TenantBaseRepository = class {
   */
   async updateMany(where, data) {
     this.logger.log("Updating multiple records");
-    return await this.model.updateMany({
-      where,
-      data
-    });
+    const result = await this.db.update(this.table).set(data).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
   }
   /**
   * Delete a record by ID
@@ -1755,71 +1793,80 @@ var TenantBaseRepository = class {
   */
   async delete(id) {
     this.logger.log(`Deleting record with ID: ${id}`);
-    return await this.model.delete({
-      where: {
-        id
-      }
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.delete(this.table).where((0, import_drizzle_orm3.eq)(idColumn, id)).returning();
+    return results[0];
   }
   /**
   * Delete multiple records
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @returns Promise resolving to the count of deleted records
   *
   * @example
   * ```typescript
-  * const result = await productRepository.deleteMany({
-  *   status: 'INACTIVE',
-  *   createdAt: { lt: new Date('2020-01-01') }
-  * });
+  * import { lt } from 'drizzle-orm';
+  *
+  * const result = await productRepository.deleteMany(
+  *   lt(products.createdAt, new Date('2020-01-01'))
+  * );
   * console.log(`Deleted ${result.count} products`);
   * ```
   */
   async deleteMany(where) {
     this.logger.log("Deleting multiple records");
-    return await this.model.deleteMany({
-      where
-    });
+    const result = await this.db.delete(this.table).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
   }
   /**
   * Count records
   *
-  * @param where - Optional where clause to filter records
+  * @param where - Optional SQL condition to filter records
   * @returns Promise resolving to the count of records
   *
   * @example
   * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
   * // Count all products
   * const total = await productRepository.count();
   *
   * // Count active products
-  * const activeCount = await productRepository.count({ status: 'ACTIVE' });
+  * const activeCount = await productRepository.count(
+  *   eq(products.status, 'ACTIVE')
+  * );
   * ```
   */
   async count(where) {
     this.logger.debug("Counting records");
-    return await this.model.count({
-      where
-    });
+    let query = this.db.select({
+      count: import_drizzle_orm3.sql`count(*)::int`
+    }).from(this.table).$dynamic();
+    if (where) {
+      query = query.where(where);
+    }
+    const results = await query;
+    return results[0].count;
   }
   /**
   * Check if a record exists
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @returns Promise resolving to true if at least one record exists, false otherwise
   *
   * @example
   * ```typescript
-  * const skuExists = await productRepository.exists({
-  *   sku: 'WDG-001'
-  * });
+  * import { eq } from 'drizzle-orm';
+  *
+  * const skuExists = await productRepository.exists(
+  *   eq(products.sku, 'WDG-001')
+  * );
   * ```
   */
   async exists(where) {
-    const count = await this.model.count({
-      where
-    });
+    const count = await this.count(where);
     return count > 0;
   }
 };
@@ -1976,15 +2023,16 @@ var HttpExceptionFilter = class _HttpExceptionFilter {
       const exceptionResponse = exception.getResponse();
       if (typeof exceptionResponse === "object" && exceptionResponse !== null) {
         const responseObj = exceptionResponse;
-        if (responseObj.errors && Array.isArray(responseObj.errors)) {
+        if ("errors" in responseObj && Array.isArray(responseObj.errors)) {
           errors = responseObj.errors;
-          detail = responseObj.detail || exception.message;
-        } else if (responseObj.message && Array.isArray(responseObj.message)) {
+          detail = ("detail" in responseObj ? responseObj.detail : void 0) || exception.message;
+        } else if ("message" in responseObj && Array.isArray(responseObj.message)) {
           errors = responseObj.message.map((msg) => {
-            if (typeof msg === "object" && msg.property && msg.constraints) {
+            if (typeof msg === "object" && "property" in msg && "constraints" in msg) {
+              const constraintValues = Object.values(msg.constraints);
               return {
                 field: msg.property,
-                message: Object.values(msg.constraints)[0]
+                message: constraintValues[0] ?? "Validation failed"
               };
             }
             return {
@@ -1992,13 +2040,14 @@ var HttpExceptionFilter = class _HttpExceptionFilter {
             };
           });
           detail = "Validation failed";
-        } else if (responseObj.message) {
+        } else if ("message" in responseObj) {
+          const message = responseObj.message;
           errors = [
             {
-              message: Array.isArray(responseObj.message) ? responseObj.message.join(", ") : responseObj.message
+              message: Array.isArray(message) ? message.join(", ") : message
             }
           ];
-          detail = responseObj.error || exception.message;
+          detail = ("error" in responseObj ? responseObj.error : void 0) || exception.message;
         }
       } else if (typeof exceptionResponse === "string") {
         errors = [
@@ -2009,7 +2058,9 @@ var HttpExceptionFilter = class _HttpExceptionFilter {
         detail = exceptionResponse;
       }
     } else {
-      this.logger.error("Unexpected error:", exception);
+      const errorMessage = exception instanceof Error ? exception.message : "Unknown error";
+      const stack = exception instanceof Error ? exception.stack : void 0;
+      this.logger.error(`Unexpected error: ${errorMessage}`, stack);
       errors = [
         {
           message: "An unexpected error occurred"
@@ -2412,6 +2463,885 @@ var BadGatewayException = class extends BaseFieldException {
     }
   }
 };
+
+// src/logger/logger.module.ts
+var import_common41 = require("@nestjs/common");
+
+// src/logger/services/logger.service.ts
+var import_common38 = require("@nestjs/common");
+var import_winston = require("winston");
+var import_winston_daily_rotate_file = __toESM(require("winston-daily-rotate-file"), 1);
+
+// src/logger/utils/index.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+var correlationStorage = new import_node_async_hooks.AsyncLocalStorage();
+function getCorrelationContext() {
+  return correlationStorage.getStore();
+}
+__name(getCorrelationContext, "getCorrelationContext");
+function runWithCorrelationContext(context, callback) {
+  return correlationStorage.run(context, callback);
+}
+__name(runWithCorrelationContext, "runWithCorrelationContext");
+function updateCorrelationContext(updates) {
+  const context = correlationStorage.getStore();
+  if (context) {
+    Object.assign(context, updates);
+  }
+}
+__name(updateCorrelationContext, "updateCorrelationContext");
+var DEFAULT_CORRELATION_HEADER = "x-correlation-id";
+function generateCorrelationId() {
+  return (0, import_node_crypto.randomUUID)();
+}
+__name(generateCorrelationId, "generateCorrelationId");
+function addCorrelationIdToResponse(reply, correlationId, headerName = DEFAULT_CORRELATION_HEADER) {
+  if (typeof reply.header === "function") {
+    reply.header(headerName, correlationId);
+  } else if (reply.raw && typeof reply.raw.setHeader === "function") {
+    reply.raw.setHeader(headerName, correlationId);
+  }
+}
+__name(addCorrelationIdToResponse, "addCorrelationIdToResponse");
+
+// src/logger/services/logger.service.ts
+function _ts_decorate14(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var LoggerService2 = class _LoggerService {
+  static {
+    __name(this, "LoggerService");
+  }
+  defaultLogger;
+  activeLogger;
+  options;
+  context;
+  constructor(options = {}, defaultLogger) {
+    this.defaultLogger = defaultLogger;
+    this.options = options;
+    const provider = options.provider ?? "winston";
+    if (provider === "default") {
+      if (!this.defaultLogger) {
+        throw new Error("LoggerService: Default Logger not provided");
+      }
+      this.activeLogger = this.defaultLogger;
+    } else {
+      this.activeLogger = this.createWinstonLogger(options);
+    }
+  }
+  /**
+  * Creates a Winston logger instance with inline configuration.
+  * Consolidates winston-config.factory.ts logic.
+  */
+  createWinstonLogger(opts) {
+    const level = opts.level ?? "debug";
+    const logFormat = opts.format ?? "text";
+    const baseFormatters = [
+      import_winston.format.timestamp({
+        format: "YYYY-MM-DDTHH:mm:ss.SSSZ"
+      }),
+      import_winston.format.errors({
+        stack: true
+      })
+    ];
+    const consoleTransport = logFormat === "json" ? new import_winston.transports.Console({
+      level,
+      format: import_winston.format.combine(...baseFormatters, import_winston.format.json())
+    }) : new import_winston.transports.Console({
+      level,
+      format: import_winston.format.combine(...baseFormatters, import_winston.format.printf((info) => {
+        const { timestamp, level: level2, message, context, correlationId, trace } = info;
+        const parts = [
+          timestamp,
+          level2.toUpperCase().padEnd(7),
+          correlationId ? `[${correlationId.toString().slice(-6)}]` : "",
+          context ? `[${context}]` : "",
+          message
+        ].filter(Boolean);
+        let output = parts.join(" ");
+        if (trace) {
+          output += "\n" + trace;
+        }
+        return output;
+      }), import_winston.format.colorize({
+        all: true
+      }))
+    });
+    const winstonTransports = [
+      consoleTransport
+    ];
+    if (opts.enableFileLogger) {
+      const filePath = opts.filePath ?? "./logs";
+      const maxFiles = opts.maxFiles ?? "14d";
+      winstonTransports.push(new import_winston_daily_rotate_file.default({
+        level,
+        filename: `${filePath}/%DATE%-combined.log`,
+        datePattern: "YYYY-MM-DD",
+        maxSize: "20m",
+        maxFiles,
+        format: import_winston.format.combine(import_winston.format.timestamp(), import_winston.format.json())
+      }), new import_winston_daily_rotate_file.default({
+        level: "error",
+        filename: `${filePath}/%DATE%-error.log`,
+        datePattern: "YYYY-MM-DD",
+        maxSize: "20m",
+        maxFiles,
+        format: import_winston.format.combine(import_winston.format.timestamp(), import_winston.format.json())
+      }));
+    }
+    const config = {
+      level,
+      transports: winstonTransports,
+      exitOnError: false
+    };
+    if (opts.defaultMeta || opts.appName) {
+      config.defaultMeta = {
+        ...opts.defaultMeta,
+        appName: opts.appName,
+        environment: opts.environment
+      };
+    }
+    return (0, import_winston.createLogger)(config);
+  }
+  // NestJS LoggerService interface methods
+  log(message, context) {
+    this._log("log", message, context);
+  }
+  error(message, trace, context) {
+    this._log("error", message, context, trace);
+  }
+  warn(message, context) {
+    this._log("warn", message, context);
+  }
+  debug(message, context) {
+    this._log("debug", message, context);
+  }
+  verbose(message, context) {
+    this._log("verbose", message, context);
+  }
+  setContext(context) {
+    this.context = context;
+  }
+  /**
+  * Unified internal logging method that handles both Winston and NestJS Logger.
+  */
+  _log(level, message, context, trace) {
+    const ctx = context ?? this.context;
+    if ("format" in this.activeLogger && "transports" in this.activeLogger) {
+      const winstonLogger = this.activeLogger;
+      const winstonLevel = level === "log" ? "info" : level;
+      const formattedMessage = this.formatMessage(message);
+      const metadata = this.enrichMetadata({}, ctx, trace);
+      winstonLogger.log({
+        level: winstonLevel,
+        message: formattedMessage,
+        ...metadata
+      });
+    } else {
+      const nestLogger = this.activeLogger;
+      if (level === "error" && trace) {
+        ctx ? nestLogger.error(message, trace, ctx) : nestLogger.error(message, trace);
+      } else if (level === "log") {
+        ctx ? nestLogger.log(message, ctx) : nestLogger.log(message);
+      } else if (level === "warn") {
+        ctx ? nestLogger.warn(message, ctx) : nestLogger.warn(message);
+      } else if (level === "debug" && nestLogger.debug) {
+        ctx ? nestLogger.debug(message, ctx) : nestLogger.debug(message);
+      } else if (level === "verbose" && nestLogger.verbose) {
+        ctx ? nestLogger.verbose(message, ctx) : nestLogger.verbose(message);
+      }
+    }
+  }
+  /**
+  * Logs with custom metadata (Winston only).
+  */
+  logWithMetadata(level, message, metadata, context) {
+    const ctx = context ?? this.context;
+    if ("format" in this.activeLogger && "transports" in this.activeLogger) {
+      const winstonLogger = this.activeLogger;
+      const winstonLevel = level === "log" ? "info" : level;
+      winstonLogger.log({
+        level: winstonLevel,
+        message: this.formatMessage(message),
+        ...metadata
+      });
+    } else {
+      const messageWithMeta = metadata ? `${message} ${JSON.stringify(metadata)}` : message;
+      this[level](messageWithMeta, ctx);
+    }
+  }
+  formatMessage(message) {
+    if (message instanceof Error) return message.message;
+    if (typeof message === "object" && message !== null) {
+      try {
+        return JSON.stringify(message);
+      } catch {
+        return String(message);
+      }
+    }
+    return String(message);
+  }
+  /**
+  * Enriches metadata with correlation context from AsyncLocalStorage.
+  * Inline from winston-logger.service.ts
+  */
+  enrichMetadata(metadata = {}, context, trace) {
+    const enriched = {
+      ...metadata
+    };
+    if (context) enriched.context = context;
+    const correlationContext = getCorrelationContext();
+    if (correlationContext) {
+      if (correlationContext.correlationId) enriched.correlationId = correlationContext.correlationId;
+      for (const [key, value] of Object.entries(correlationContext)) {
+        if (key !== "correlationId") {
+          enriched[key] = value;
+        }
+      }
+    }
+    if (trace) enriched.trace = trace;
+    return enriched;
+  }
+  child(context) {
+    const childLogger = new _LoggerService(this.options, this.defaultLogger);
+    childLogger.setContext(context);
+    return childLogger;
+  }
+};
+LoggerService2 = _ts_decorate14([
+  (0, import_common38.Injectable)(),
+  _ts_param4(0, (0, import_common38.Optional)()),
+  _ts_param4(1, (0, import_common38.Optional)()),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof LoggerModuleOptions === "undefined" ? Object : LoggerModuleOptions,
+    typeof import_common38.Logger === "undefined" ? Object : import_common38.Logger
+  ])
+], LoggerService2);
+
+// src/logger/middleware/correlation-id.middleware.ts
+var import_common39 = require("@nestjs/common");
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+var CorrelationIdMiddleware = class {
+  static {
+    __name(this, "CorrelationIdMiddleware");
+  }
+  includeInResponse;
+  responseHeader;
+  constructor(options = {}) {
+    this.includeInResponse = options.includeInResponse ?? true;
+    this.responseHeader = options.responseHeader ?? DEFAULT_CORRELATION_HEADER;
+  }
+  /**
+  * Middleware handler for processing requests.
+  */
+  use(req, reply, next) {
+    const correlationId = generateCorrelationId();
+    if (this.includeInResponse) {
+      addCorrelationIdToResponse(reply, correlationId, this.responseHeader);
+    }
+    runWithCorrelationContext({
+      correlationId
+    }, () => {
+      next();
+    });
+  }
+  /**
+  * Fastify hook handler for onRequest.
+  * This is an async function that returns a Promise, ensuring the AsyncLocalStorage
+  * context persists throughout the entire request lifecycle.
+  */
+  async onRequest(req, reply) {
+    const correlationId = generateCorrelationId();
+    if (this.includeInResponse) {
+      addCorrelationIdToResponse(reply, correlationId, this.responseHeader);
+    }
+    const store = correlationStorage.getStore();
+    if (!store) {
+      correlationStorage.enterWith({
+        correlationId
+      });
+    }
+  }
+};
+CorrelationIdMiddleware = _ts_decorate15([
+  (0, import_common39.Injectable)(),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof CorrelationIdMiddlewareOptions === "undefined" ? Object : CorrelationIdMiddlewareOptions
+  ])
+], CorrelationIdMiddleware);
+
+// src/logger/interceptors/http-logger.interceptor.ts
+var import_common40 = require("@nestjs/common");
+var import_operators2 = require("rxjs/operators");
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var HttpLoggerInterceptor = class {
+  static {
+    __name(this, "HttpLoggerInterceptor");
+  }
+  logger;
+  enableRequestLog;
+  enableResponseLog;
+  slowRequestThreshold;
+  constructor(logger, options) {
+    this.logger = logger;
+    this.enableRequestLog = options?.enableRequestLog ?? true;
+    this.enableResponseLog = options?.enableResponseLog ?? true;
+    this.slowRequestThreshold = options?.slowRequestThreshold ?? 3e3;
+  }
+  intercept(context, next) {
+    if (context.getType() !== "http") {
+      return next.handle();
+    }
+    const httpContext = context.switchToHttp();
+    const request = httpContext.getRequest();
+    const response = httpContext.getResponse();
+    const startTime = Date.now();
+    if (this.enableRequestLog) {
+      this.logRequest(request);
+    }
+    return next.handle().pipe((0, import_operators2.tap)(() => {
+      if (this.enableResponseLog) {
+        const duration = Date.now() - startTime;
+        this.logResponse(request, response, duration);
+      }
+    }), (0, import_operators2.catchError)((error) => {
+      const duration = Date.now() - startTime;
+      this.logError(request, response, duration, error);
+      throw error;
+    }));
+  }
+  logRequest(request) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const metadata = {
+        type: "http_request",
+        method: request.method,
+        url: request.url,
+        correlationId: correlationContext?.correlationId,
+        ip: request.ip,
+        userAgent: request.headers["user-agent"]
+      };
+      this.logger.logWithMetadata("log", `Incoming ${request.method} ${request.url}`, metadata);
+    } catch (error) {
+      this.logger.error("Failed to log HTTP request", error.stack);
+    }
+  }
+  logResponse(request, response, duration) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const statusCode = response.statusCode;
+      const logLevel = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "log";
+      const metadata = {
+        type: "http_response",
+        method: request.method,
+        url: request.url,
+        statusCode,
+        duration,
+        correlationId: correlationContext?.correlationId
+      };
+      if (duration > this.slowRequestThreshold) {
+        metadata.slowRequest = true;
+      }
+      const message = metadata.slowRequest ? `SLOW ${request.method} ${request.url} ${statusCode} - ${duration}ms` : `${request.method} ${request.url} ${statusCode} - ${duration}ms`;
+      this.logger.logWithMetadata(logLevel, message, metadata);
+    } catch (error) {
+      this.logger.error("Failed to log HTTP response", error.stack);
+    }
+  }
+  logError(request, response, duration, error) {
+    try {
+      const correlationContext = getCorrelationContext();
+      const statusCode = response.statusCode || 500;
+      const metadata = {
+        type: "http_error",
+        method: request.method,
+        url: request.url,
+        statusCode,
+        duration,
+        correlationId: correlationContext?.correlationId,
+        errorName: error?.name || "Error",
+        errorMessage: error?.message || "Unknown error"
+      };
+      if (error?.stack) {
+        metadata.trace = error.stack;
+      }
+      if (error?.response) {
+        metadata.errorDetails = error.response;
+      }
+      const message = `ERROR ${request.method} ${request.url} ${statusCode} - ${error?.message || "Unknown error"}`;
+      this.logger.logWithMetadata("error", message, metadata);
+    } catch (loggingError) {
+      this.logger.error("Failed to log HTTP error", loggingError.stack);
+    }
+  }
+};
+HttpLoggerInterceptor = _ts_decorate16([
+  (0, import_common40.Injectable)(),
+  _ts_param5(1, (0, import_common40.Optional)()),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService,
+    typeof HttpLoggerOptions === "undefined" ? Object : HttpLoggerOptions
+  ])
+], HttpLoggerInterceptor);
+
+// src/logger/logger.module.ts
+function _ts_decorate17(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate17, "_ts_decorate");
+var LOGGER_MODULE_OPTIONS = Symbol("LOGGER_MODULE_OPTIONS");
+var DEFAULT_LOGGER_OPTIONS = {
+  provider: "winston",
+  enableCorrelationId: true,
+  enableHttpLogger: true,
+  filePath: "./logs",
+  maxFiles: "14d"
+};
+var ENVIRONMENT_PRESETS = {
+  /**
+  * Development preset - maximum verbosity for local development
+  */
+  development: {
+    provider: "winston",
+    level: "debug",
+    format: "text",
+    enableFileLogger: false,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: true,
+      enableResponseLog: true,
+      slowRequestThreshold: 1e3
+    }
+  },
+  /**
+  * Staging preset - moderate verbosity with file logging
+  */
+  staging: {
+    provider: "winston",
+    level: "log",
+    format: "json",
+    enableFileLogger: true,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: true,
+      enableResponseLog: true,
+      slowRequestThreshold: 3e3
+    }
+  },
+  /**
+  * Production preset - minimal verbosity with all safety features enabled
+  */
+  production: {
+    provider: "winston",
+    level: "warn",
+    format: "json",
+    enableFileLogger: true,
+    enableCorrelationId: true,
+    enableHttpLogger: true,
+    httpLogger: {
+      enableRequestLog: false,
+      enableResponseLog: true,
+      slowRequestThreshold: 5e3
+    }
+  },
+  /**
+  * Test preset - errors only, minimal features for faster test execution
+  */
+  test: {
+    provider: "winston",
+    level: "error",
+    format: "json",
+    enableFileLogger: false,
+    enableCorrelationId: false,
+    enableHttpLogger: false
+  }
+};
+function mergeWithDefaults(options = {}) {
+  const preset = options.environment ? ENVIRONMENT_PRESETS[options.environment] ?? ENVIRONMENT_PRESETS.development : ENVIRONMENT_PRESETS.development;
+  const filteredOptions = Object.fromEntries(Object.entries(options).filter(([_, value]) => value !== void 0));
+  if (filteredOptions.httpLogger && preset?.httpLogger) {
+    filteredOptions.httpLogger = {
+      ...preset.httpLogger,
+      ...Object.fromEntries(Object.entries(filteredOptions.httpLogger).filter(([_, value]) => value !== void 0))
+    };
+  }
+  const merged = {
+    ...DEFAULT_LOGGER_OPTIONS,
+    ...preset,
+    ...filteredOptions
+  };
+  return merged;
+}
+__name(mergeWithDefaults, "mergeWithDefaults");
+function createDefaultLoggerProvider(options) {
+  return {
+    provide: import_common41.Logger,
+    useFactory: /* @__PURE__ */ __name(() => {
+      const logger = new import_common41.Logger();
+      if (options.level && typeof logger.setLogLevels === "function") {
+        const levels = getLevelsUpTo(options.level);
+        logger.setLogLevels(levels);
+      }
+      return logger;
+    }, "useFactory")
+  };
+}
+__name(createDefaultLoggerProvider, "createDefaultLoggerProvider");
+function createLoggerProviders(options = {}) {
+  const mergedOptions = mergeWithDefaults(options);
+  const providers = [
+    // Options provider
+    {
+      provide: LOGGER_MODULE_OPTIONS,
+      useValue: mergedOptions
+    }
+  ];
+  if (mergedOptions.provider === "default") {
+    providers.push(createDefaultLoggerProvider(mergedOptions));
+  }
+  providers.push({
+    provide: LoggerService2,
+    useFactory: /* @__PURE__ */ __name((opts, defaultLogger) => {
+      return new LoggerService2(opts, defaultLogger);
+    }, "useFactory"),
+    inject: [
+      LOGGER_MODULE_OPTIONS,
+      {
+        token: import_common41.Logger,
+        optional: true
+      }
+    ]
+  });
+  providers.push({
+    provide: CorrelationIdMiddleware,
+    useFactory: /* @__PURE__ */ __name(() => {
+      return new CorrelationIdMiddleware({
+        includeInResponse: true,
+        responseHeader: "x-correlation-id"
+      });
+    }, "useFactory")
+  });
+  providers.push({
+    provide: HttpLoggerInterceptor,
+    useFactory: /* @__PURE__ */ __name((logger, opts) => {
+      const httpLoggerOptions = opts.httpLogger ?? {
+        enableRequestLog: opts.enableHttpLogger,
+        enableResponseLog: opts.enableHttpLogger
+      };
+      return new HttpLoggerInterceptor(logger, httpLoggerOptions);
+    }, "useFactory"),
+    inject: [
+      LoggerService2,
+      LOGGER_MODULE_OPTIONS
+    ]
+  });
+  return providers;
+}
+__name(createLoggerProviders, "createLoggerProviders");
+function getLevelsUpTo(level) {
+  const allLevels = [
+    "error",
+    "warn",
+    "log",
+    "debug",
+    "verbose"
+  ];
+  const isValidLevel = /* @__PURE__ */ __name((l) => allLevels.includes(l), "isValidLevel");
+  if (!isValidLevel(level)) {
+    return [
+      "error",
+      "warn",
+      "log"
+    ];
+  }
+  const levelIndex = allLevels.indexOf(level);
+  return allLevels.slice(0, levelIndex + 1);
+}
+__name(getLevelsUpTo, "getLevelsUpTo");
+var LoggerModule = class _LoggerModule {
+  static {
+    __name(this, "LoggerModule");
+  }
+  /**
+  * Configures the logger module with static options.
+  *
+  * Users must explicitly pass `environment` to select a preset.
+  * All preset values can be overridden by passing explicit options.
+  *
+  * @param options - Logger configuration options
+  * @returns Dynamic module configuration
+  *
+  * @example
+  * ```typescript
+  * // Production preset with app name
+  * LoggerModule.forRoot({
+  *   environment: 'production',
+  *   appName: 'my-service'
+  * })
+  *
+  * // Development preset with custom level
+  * LoggerModule.forRoot({
+  *   environment: 'development',
+  *   level: 'verbose',
+  *   enableFileLogger: true
+  * })
+  *
+  * // Use default NestJS logger
+  * LoggerModule.forRoot({
+  *   provider: 'default',
+  *   environment: 'development'
+  * })
+  * ```
+  */
+  static forRoot(options = {}) {
+    const providers = createLoggerProviders(options);
+    return {
+      module: _LoggerModule,
+      providers,
+      exports: [
+        LoggerService2,
+        CorrelationIdMiddleware,
+        HttpLoggerInterceptor,
+        LOGGER_MODULE_OPTIONS
+      ]
+    };
+  }
+  /**
+  * Configures the logger module with async options.
+  *
+  * Supports dynamic configuration using:
+  * - `useFactory`: Factory function with dependency injection
+  * - `useClass`: Class implementing `LoggerOptionsFactory`
+  * - `useExisting`: Existing provider implementing `LoggerOptionsFactory`
+  *
+  * Options from the factory/class are merged with environment preset defaults.
+  *
+  * @param options - Async configuration options
+  * @returns Dynamic module configuration
+  *
+  * @example
+  * ```typescript
+  * // Factory with ConfigService
+  * LoggerModule.forRootAsync({
+  *   imports: [ConfigModule],
+  *   useFactory: (config: ConfigService) => ({
+  *     environment: config.get('NODE_ENV', 'development'),
+  *     provider: config.get('LOG_PROVIDER', 'winston'),
+  *     level: config.get('LOG_LEVEL'),
+  *     appName: config.get('APP_NAME'),
+  *   }),
+  *   inject: [ConfigService]
+  * })
+  *
+  * // Factory class
+  * @Injectable()
+  * class LoggerConfigService implements LoggerOptionsFactory {
+  *   createLoggerOptions(): LoggerModuleOptions {
+  *     return {
+  *       environment: 'production',
+  *       appName: 'my-service'
+  *     };
+  *   }
+  * }
+  *
+  * LoggerModule.forRootAsync({
+  *   useClass: LoggerConfigService
+  * })
+  * ```
+  */
+  static forRootAsync(options) {
+    const asyncProviders = this.createAsyncProviders(options);
+    return {
+      module: _LoggerModule,
+      imports: options.imports || [],
+      providers: [
+        ...asyncProviders,
+        // Default logger provider
+        {
+          provide: import_common41.Logger,
+          useFactory: /* @__PURE__ */ __name((opts) => {
+            if (opts.provider === "default") {
+              const logger = new import_common41.Logger();
+              if (opts.level && typeof logger.setLogLevels === "function") {
+                const levels = getLevelsUpTo(opts.level);
+                logger.setLogLevels(levels);
+              }
+              return logger;
+            }
+            return null;
+          }, "useFactory"),
+          inject: [
+            LOGGER_MODULE_OPTIONS
+          ]
+        },
+        // Unified logger service
+        {
+          provide: LoggerService2,
+          useFactory: /* @__PURE__ */ __name((opts, defaultLogger) => {
+            return new LoggerService2(opts, defaultLogger);
+          }, "useFactory"),
+          inject: [
+            LOGGER_MODULE_OPTIONS,
+            {
+              token: import_common41.Logger,
+              optional: true
+            }
+          ]
+        },
+        // Correlation ID middleware
+        {
+          provide: CorrelationIdMiddleware,
+          useFactory: /* @__PURE__ */ __name(() => {
+            return new CorrelationIdMiddleware({
+              includeInResponse: true,
+              responseHeader: "x-correlation-id"
+            });
+          }, "useFactory")
+        },
+        // HTTP logger interceptor
+        {
+          provide: HttpLoggerInterceptor,
+          useFactory: /* @__PURE__ */ __name((logger, opts) => {
+            const httpLoggerOptions = opts.httpLogger ?? {
+              enableRequestLog: opts.enableHttpLogger,
+              enableResponseLog: opts.enableHttpLogger
+            };
+            return new HttpLoggerInterceptor(logger, httpLoggerOptions);
+          }, "useFactory"),
+          inject: [
+            LoggerService2,
+            LOGGER_MODULE_OPTIONS
+          ]
+        }
+      ],
+      exports: [
+        LoggerService2,
+        CorrelationIdMiddleware,
+        HttpLoggerInterceptor,
+        LOGGER_MODULE_OPTIONS
+      ]
+    };
+  }
+  /**
+  * Configures middleware for the module.
+  * Middleware is registered globally in main.ts using Fastify hooks.
+  */
+  configure(consumer) {
+  }
+  /**
+  * Creates async providers for dynamic module configuration.
+  */
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        this.createAsyncOptionsProvider(options)
+      ];
+    }
+    const providers = [
+      this.createAsyncOptionsProvider(options)
+    ];
+    if (options.useClass) {
+      providers.push({
+        provide: options.useClass,
+        useClass: options.useClass
+      });
+    }
+    return providers;
+  }
+  /**
+  * Creates the async options provider.
+  */
+  static createAsyncOptionsProvider(options) {
+    if (options.useFactory) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (...args) => {
+          const userOptions = await options.useFactory(...args);
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: options.inject || []
+      };
+    }
+    if (options.useClass) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (optionsFactory) => {
+          const userOptions = await optionsFactory.createLoggerOptions();
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: [
+          options.useClass
+        ]
+      };
+    }
+    if (options.useExisting) {
+      return {
+        provide: LOGGER_MODULE_OPTIONS,
+        useFactory: /* @__PURE__ */ __name(async (optionsFactory) => {
+          const userOptions = await optionsFactory.createLoggerOptions();
+          return mergeWithDefaults(userOptions);
+        }, "useFactory"),
+        inject: [
+          options.useExisting
+        ]
+      };
+    }
+    throw new Error("LoggerModule.forRootAsync() requires one of: useFactory, useClass, or useExisting");
+  }
+};
+LoggerModule = _ts_decorate17([
+  (0, import_common41.Global)(),
+  (0, import_common41.Module)({})
+], LoggerModule);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthConfigModule,
@@ -2419,13 +3349,19 @@ var BadGatewayException = class extends BaseFieldException {
   BadRequestException,
   BaseFieldException,
   ConflictException,
+  CorrelationIdMiddleware,
   CsrfGuard,
+  DEFAULT_CORRELATION_HEADER,
   DatabaseModule,
   ForbiddenException,
   GoneException,
   HttpExceptionFilter,
+  HttpLoggerInterceptor,
   HttpModule,
   InternalServerErrorException,
+  LOGGER_MODULE_OPTIONS,
+  LoggerModule,
+  LoggerService,
   MethodNotAllowedException,
   NotAcceptableException,
   NotFoundException,
@@ -2447,6 +3383,12 @@ var BadGatewayException = class extends BaseFieldException {
   UnsupportedMediaTypeException,
   ValidationException,
   VrittiAuthGuard,
-  getHttpStatusTitle
+  addCorrelationIdToResponse,
+  correlationStorage,
+  generateCorrelationId,
+  getCorrelationContext,
+  getHttpStatusTitle,
+  runWithCorrelationContext,
+  updateCorrelationContext
 });
 //# sourceMappingURL=index.cjs.map