@vritti/api-sdk 0.1.1 → 0.1.3

package/dist/index.js

@@ -13,6 +13,82 @@ import { Global, Module } from "@nestjs/common";
 // src/request/services/request.service.ts
 import { Inject, Injectable, Scope } from "@nestjs/common";
 import { REQUEST } from "@nestjs/core";
+
+// src/config/index.ts
+var defaultConfig = {
+  cookie: {
+    refreshCookieName: "vritti_refresh",
+    refreshCookieMaxAge: 30 * 24 * 60 * 60 * 1e3,
+    refreshCookiePath: "/",
+    refreshCookieSecure: process.env.NODE_ENV === "production",
+    refreshCookieSameSite: "strict"
+  },
+  jwt: {
+    accessTokenExpiry: "15m",
+    refreshTokenExpiry: "30d",
+    onboardingTokenExpiry: "24h",
+    validateTokenBinding: true
+  },
+  guard: {
+    tenantHeaderName: "x-tenant-id",
+    authHeaderName: "authorization",
+    tokenPrefix: "Bearer"
+  }
+};
+var currentConfig = {
+  ...defaultConfig
+};
+function defineConfig(config) {
+  return config;
+}
+__name(defineConfig, "defineConfig");
+function configureApiSdk(userConfig) {
+  currentConfig = {
+    cookie: {
+      ...defaultConfig.cookie,
+      ...userConfig.cookie || {}
+    },
+    jwt: {
+      ...defaultConfig.jwt,
+      ...userConfig.jwt || {}
+    },
+    guard: {
+      ...defaultConfig.guard,
+      ...userConfig.guard || {}
+    }
+  };
+}
+__name(configureApiSdk, "configureApiSdk");
+function getConfig() {
+  return currentConfig;
+}
+__name(getConfig, "getConfig");
+function resetConfig() {
+  currentConfig = {
+    ...defaultConfig
+  };
+}
+__name(resetConfig, "resetConfig");
+function getRefreshCookieOptions() {
+  return {
+    httpOnly: true,
+    secure: currentConfig.cookie.refreshCookieSecure,
+    sameSite: currentConfig.cookie.refreshCookieSameSite,
+    path: currentConfig.cookie.refreshCookiePath,
+    maxAge: currentConfig.cookie.refreshCookieMaxAge
+  };
+}
+__name(getRefreshCookieOptions, "getRefreshCookieOptions");
+function getJwtExpiry() {
+  return {
+    access: currentConfig.jwt.accessTokenExpiry,
+    refresh: currentConfig.jwt.refreshTokenExpiry,
+    onboarding: currentConfig.jwt.onboardingTokenExpiry
+  };
+}
+__name(getJwtExpiry, "getJwtExpiry");
+
+// src/request/services/request.service.ts
 function _ts_decorate(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);
@@ -30,7 +106,7 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
-var RequestService = class {
+var RequestService2 = class {
   static {
     __name(this, "RequestService");
   }
@@ -64,21 +140,22 @@ var RequestService = class {
     return type === "Bearer" && token ? token : null;
   }
   /**
-  * Extract refresh token from session-id cookie
-  * Cookie name: session-id
+  * Extract refresh token from httpOnly cookie
+  * Cookie name is configurable via api-sdk config
   * @returns Refresh token or null if not found
   */
   getRefreshToken() {
     try {
       const cookies = this.request.cookies;
       if (cookies && typeof cookies === "object") {
-        const sessionId = cookies["session-id"];
-        if (sessionId) {
-          return sessionId;
+        const config = getConfig();
+        const refreshToken = cookies[config.cookie.refreshCookieName];
+        if (refreshToken) {
+          return refreshToken;
         }
       }
       return null;
-    } catch (error) {
+    } catch (_error) {
       return null;
     }
   }
@@ -98,7 +175,7 @@ var RequestService = class {
     return this.request.headers || {};
   }
 };
-RequestService = _ts_decorate([
+RequestService2 = _ts_decorate([
   Injectable({
     scope: Scope.REQUEST
   }),
@@ -107,7 +184,7 @@ RequestService = _ts_decorate([
   _ts_metadata("design:paramtypes", [
     typeof FastifyRequest === "undefined" ? Object : FastifyRequest
   ])
-], RequestService);
+], RequestService2);
 
 // src/request/request.module.ts
 function _ts_decorate2(decorators, target, key, desc) {
@@ -126,31 +203,31 @@ RequestModule = _ts_decorate2([
   Global(),
   Module({
     providers: [
-      RequestService
+      RequestService2
     ],
     exports: [
-      RequestService
+      RequestService2
     ]
   })
 ], RequestModule);
 
 // src/auth/guards/vritti-auth.guard.ts
-import { Injectable as Injectable3, Logger as Logger2, Scope as Scope2, UnauthorizedException } from "@nestjs/common";
-import { ConfigService } from "@nestjs/config";
-import { Reflector } from "@nestjs/core";
-import { JwtService } from "@nestjs/jwt";
-import * as jwt from "jsonwebtoken";
-
-// src/database/services/primary-database.service.ts
-import { Inject as Inject2, Injectable as Injectable2, InternalServerErrorException, Logger } from "@nestjs/common";
-import { Pool } from "pg";
-import { drizzle } from "drizzle-orm/node-postgres";
-import { eq, or } from "drizzle-orm";
+import { Injectable as Injectable2, Logger as Logger2, Scope as Scope2, UnauthorizedException } from "@nestjs/common";
 
-// src/database/constants.ts
-var DATABASE_MODULE_OPTIONS = Symbol("DATABASE_MODULE_OPTIONS");
+// src/auth/utils/token-hash.util.ts
+import * as crypto from "crypto";
+function hashToken(token) {
+  return crypto.createHash("sha256").update(token).digest("hex");
+}
+__name(hashToken, "hashToken");
+function verifyTokenHash(token, expectedHash) {
+  const computedHash = hashToken(token);
+  if (computedHash.length !== expectedHash.length) return false;
+  return crypto.timingSafeEqual(Buffer.from(computedHash, "hex"), Buffer.from(expectedHash, "hex"));
+}
+__name(verifyTokenHash, "verifyTokenHash");
 
-// src/database/services/primary-database.service.ts
+// src/auth/guards/vritti-auth.guard.ts
 function _ts_decorate3(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);
@@ -162,247 +239,19 @@ function _ts_metadata2(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata2, "_ts_metadata");
-function _ts_param2(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param2, "_ts_param");
-var PrimaryDatabaseService = class _PrimaryDatabaseService {
-  static {
-    __name(this, "PrimaryDatabaseService");
-  }
-  options;
-  logger = new Logger(_PrimaryDatabaseService.name);
-  /** PostgreSQL connection pool */
-  pool = null;
-  /** Drizzle database instance */
-  db = null;
-  /** In-memory cache: Map<tenantIdentifier, TenantConfig> */
-  tenantConfigCache = /* @__PURE__ */ new Map();
-  /** Cache TTL in milliseconds */
-  cacheTTL;
-  constructor(options) {
-    this.options = options;
-    this.cacheTTL = options.connectionCacheTTL || 3e5;
-  }
-  async onModuleInit() {
-    if (this.options.primaryDb) {
-      await this.initializeDrizzleClient();
-    }
-  }
-  /**
-  * Initialize connection to primary database using Drizzle
-  */
-  async initializeDrizzleClient() {
-    try {
-      const databaseUrl = this.buildPrimaryDbUrl();
-      this.pool = new Pool({
-        connectionString: databaseUrl,
-        max: this.options.maxConnections || 10
-      });
-      this.logger.debug(`Schema keys passed to drizzle: [${Object.keys(this.options.drizzleSchema || {}).join(", ")}]`);
-      this.logger.debug(`Relations keys passed to drizzle: [${Object.keys(this.options.drizzleRelations || {}).join(", ")}]`);
-      this.db = drizzle({
-        client: this.pool,
-        schema: this.options.drizzleSchema,
-        relations: this.options.drizzleRelations
-      });
-      this.logger.debug(`Drizzle query keys after init: [${Object.keys(this.db.query || {}).join(", ")}]`);
-      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);
-      throw new InternalServerErrorException("Failed to initialize tenant registry");
-    }
-  }
-  /**
-  * Build connection URL from primary database properties
-  */
-  buildPrimaryDbUrl() {
-    if (!this.options.primaryDb) {
-      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}:${encodeURIComponent(password)}@${host}:${port}/${database}`;
-    const params = new URLSearchParams();
-    if (schema) {
-      params.set("schema", schema);
-    }
-    params.set("sslmode", sslMode);
-    const queryString = params.toString();
-    if (queryString) {
-      url += `?${queryString}`;
-    }
-    this.logger.debug(`Primary DB connection URL: ${this.maskPassword(url)}`);
-    return url;
-  }
-  /**
-  * Mask password in connection URL for logging
-  */
-  maskPassword(url) {
-    return url.replace(/:([^@]+)@/, ":****@");
-  }
-  /**
-  * Get tenant configuration by identifier (ID or subdomain)
-  *
-  * @param tenantIdentifier Tenant ID or subdomain
-  * @returns Tenant configuration or null if not found
-  */
-  async getTenantInfo(tenantIdentifier) {
-    const cached = this.tenantConfigCache.get(tenantIdentifier);
-    if (cached) {
-      this.logger.debug(`Cache hit for tenant: ${tenantIdentifier}`);
-      return cached;
-    }
-    try {
-      if (!this.db) {
-        throw new Error("Primary database client not initialized");
-      }
-      this.logger.debug(`Querying primary database for tenant: ${tenantIdentifier}`);
-      const schema = this.options.drizzleSchema;
-      const { tenants, tenantDatabaseConfigs } = schema;
-      const result = await this.db.select().from(tenants).leftJoin(tenantDatabaseConfigs, eq(tenants.id, tenantDatabaseConfigs.tenantId)).where(or(eq(tenants.id, tenantIdentifier), 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: config?.dbSchema || void 0,
-        // For DEDICATED tenants: database configuration from TenantDatabaseConfig table
-        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;
-    } catch (error) {
-      this.logger.error(`Failed to fetch tenant info: ${tenantIdentifier}`, error);
-      throw new InternalServerErrorException("Failed to resolve tenant");
-    }
-  }
-  /**
-  * Cache tenant information with TTL
-  */
-  cacheInfo(info) {
-    this.tenantConfigCache.set(info.id, info);
-    this.tenantConfigCache.set(info.subdomain, info);
-    setTimeout(() => {
-      this.tenantConfigCache.delete(info.id);
-      this.tenantConfigCache.delete(info.subdomain);
-      this.logger.debug(`Cache expired for tenant: ${info.subdomain}`);
-    }, this.cacheTTL);
-  }
-  /**
-  * Clear cached tenant information
-  *
-  * Useful when tenant settings are updated and cache needs to be invalidated
-  *
-  * @param tenantIdentifier Tenant ID or subdomain
-  */
-  clearTenantCache(tenantIdentifier) {
-    const config = this.tenantConfigCache.get(tenantIdentifier);
-    if (config) {
-      this.tenantConfigCache.delete(config.id);
-      this.tenantConfigCache.delete(config.subdomain);
-      this.logger.log(`Cleared cache for tenant: ${tenantIdentifier}`);
-    }
-  }
-  /**
-  * Clear all cached tenant configurations
-  */
-  clearAllCaches() {
-    const size = this.tenantConfigCache.size;
-    this.tenantConfigCache.clear();
-    this.logger.log(`Cleared ${size} cached tenant configs`);
-  }
-  /**
-  * Get the Drizzle database instance for the primary database.
-  * This is a synchronous property that returns the initialized Drizzle client.
-  *
-  * @returns Primary database Drizzle instance
-  * @throws Error if primary database client is not initialized
-  */
-  get drizzleClient() {
-    if (!this.db) {
-      throw new Error("Primary database client not initialized");
-    }
-    return this.db;
-  }
-  /**
-  * Get the Drizzle schema
-  */
-  get schema() {
-    return this.options.drizzleSchema;
-  }
-  /**
-  * Decrypt database credentials
-  *
-  * Override this method to implement your encryption strategy
-  *
-  * @param encrypted Encrypted value
-  * @returns Decrypted value
-  */
-  decrypt(encrypted) {
-    return encrypted;
-  }
-  async onModuleDestroy() {
-    if (this.pool) {
-      await this.pool.end();
-      this.logger.log("Disconnected from primary database");
-    }
-  }
-};
-PrimaryDatabaseService = _ts_decorate3([
-  Injectable2(),
-  _ts_param2(0, Inject2(DATABASE_MODULE_OPTIONS)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions
-  ])
-], PrimaryDatabaseService);
-
-// src/auth/guards/vritti-auth.guard.ts
-function _ts_decorate4(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_decorate4, "_ts_decorate");
-function _ts_metadata3(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata3, "_ts_metadata");
 var VrittiAuthGuard = class _VrittiAuthGuard {
   static {
     __name(this, "VrittiAuthGuard");
   }
   reflector;
-  configService;
+  _configService;
   jwtService;
   primaryDatabase;
   requestService;
   logger = new Logger2(_VrittiAuthGuard.name);
-  constructor(reflector, configService, jwtService, primaryDatabase, requestService) {
+  constructor(reflector, _configService, jwtService, primaryDatabase, requestService) {
     this.reflector = reflector;
-    this.configService = configService;
+    this._configService = _configService;
     this.jwtService = jwtService;
     this.primaryDatabase = primaryDatabase;
     this.requestService = requestService;
@@ -439,6 +288,7 @@ var VrittiAuthGuard = class _VrittiAuthGuard {
         }
         const validatedToken2 = this.validateAccessToken(accessToken);
         this.logger.debug("Onboarding token validated successfully");
+        this.validateRefreshTokenBinding(context, validatedToken2);
         const userId2 = validatedToken2.userId;
         request.user = {
           id: userId2
@@ -451,13 +301,7 @@ var VrittiAuthGuard = class _VrittiAuthGuard {
       }
       const validatedToken = this.validateAccessToken(accessToken);
       this.logger.debug("Access token validated successfully");
-      const refreshToken = this.requestService.getRefreshToken();
-      if (!refreshToken) {
-        this.logger.warn("Refresh token (session-id) not found in cookies");
-        throw new UnauthorizedException("Refresh token not found");
-      }
-      this.validateRefreshToken(refreshToken);
-      this.logger.debug("Refresh token validated successfully");
+      this.validateRefreshTokenBinding(context, validatedToken);
       const userId = validatedToken.userId;
       request.user = {
         id: userId
@@ -528,68 +372,44 @@ var VrittiAuthGuard = class _VrittiAuthGuard {
     }
   }
   /**
-  * Validate refresh token with proper expiry checks
-  * Throws UnauthorizedException if token is invalid or expired
-  */
-  validateRefreshToken(token) {
-    const jwtSecret = this.configService.get("JWT_REFRESH_SECRET") || this.configService.get("JWT_SECRET");
-    this.validateRefreshTokenWithSecret(token, jwtSecret);
-  }
-  /**
-  * Helper to validate refresh token with specific secret
+  * Validate that the access token is bound to the refresh token in the cookie.
+  * This prevents token theft - a stolen access token is useless without the
+  * corresponding refresh token cookie.
+  *
+  * @param context - The execution context containing the request
+  * @param validatedToken - The decoded and validated JWT token
+  * @throws UnauthorizedException if token binding validation fails
   */
-  validateRefreshTokenWithSecret(token, secret) {
-    if (!secret) {
-      this.logger.error("JWT secret not configured for refresh token validation");
-      throw new UnauthorizedException("Server configuration error");
+  validateRefreshTokenBinding(context, validatedToken) {
+    const config = getConfig();
+    if (!config.jwt.validateTokenBinding) {
+      this.logger.debug("Token binding validation is disabled");
+      return;
     }
-    try {
-      const decoded = jwt.verify(token, secret, {
-        algorithms: [
-          "HS256",
-          "HS512",
-          "RS256"
-        ]
-      });
-      this.logger.debug(`Refresh token decoded for user: ${decoded.userId}`);
-      if (decoded.exp) {
-        const expiryTime = decoded.exp * 1e3;
-        const currentTime = Date.now();
-        if (currentTime > expiryTime) {
-          this.logger.warn("Refresh token has expired");
-          throw new UnauthorizedException("Refresh token has expired. Please login again");
-        }
-        const timeRemaining = expiryTime - currentTime;
-        this.logger.debug(`Refresh token valid for ${Math.floor(timeRemaining / 1e3)} more seconds`);
-      }
-    } catch (error) {
-      if (error instanceof UnauthorizedException) {
-        throw error;
-      }
-      const jwtError = error;
-      if (jwtError?.name === "TokenExpiredError") {
-        this.logger.warn(`Refresh token expired at: ${jwtError?.expiredAt}`);
-        throw new UnauthorizedException("Refresh token has expired. Please login again");
-      }
-      if (jwtError?.name === "JsonWebTokenError") {
-        this.logger.warn(`Refresh token verification failed: ${jwtError?.message}`);
-        throw new UnauthorizedException("Invalid refresh token");
-      }
-      if (jwtError?.name === "NotBeforeError") {
-        this.logger.warn("Refresh token used before valid (nbf claim)");
-        throw new UnauthorizedException("Refresh token not yet valid");
-      }
-      this.logger.error("Unexpected error validating refresh token", error);
-      throw new UnauthorizedException("Refresh token validation failed");
+    if (!validatedToken.refreshTokenHash) {
+      this.logger.debug("Token does not contain refreshTokenHash, skipping binding validation");
+      return;
+    }
+    const request = context.switchToHttp().getRequest();
+    const cookies = request.cookies || {};
+    const refreshToken = cookies[config.cookie.refreshCookieName];
+    if (!refreshToken) {
+      this.logger.warn("Session validation failed - refresh token cookie not found");
+      throw new UnauthorizedException("Session validation failed");
     }
+    if (!verifyTokenHash(refreshToken, validatedToken.refreshTokenHash)) {
+      this.logger.warn("Session validation failed - token binding mismatch");
+      throw new UnauthorizedException("Session validation failed");
+    }
+    this.logger.debug("Token binding validated successfully");
   }
 };
-VrittiAuthGuard = _ts_decorate4([
-  Injectable3({
+VrittiAuthGuard = _ts_decorate3([
+  Injectable2({
     scope: Scope2.REQUEST
   }),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof Reflector === "undefined" ? Object : Reflector,
     typeof ConfigService === "undefined" ? Object : ConfigService,
     typeof JwtService === "undefined" ? Object : JwtService,
@@ -599,13 +419,13 @@ VrittiAuthGuard = _ts_decorate4([
 ], VrittiAuthGuard);
 
 // src/auth/auth-config.module.ts
-function _ts_decorate5(decorators, target, key, desc) {
+function _ts_decorate4(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_decorate5, "_ts_decorate");
+__name(_ts_decorate4, "_ts_decorate");
 var AuthConfigModule = class _AuthConfigModule {
   static {
     __name(this, "AuthConfigModule");
@@ -653,117 +473,40 @@ var AuthConfigModule = class _AuthConfigModule {
     };
   }
 };
-AuthConfigModule = _ts_decorate5([
+AuthConfigModule = _ts_decorate4([
   Global2(),
   Module2({})
 ], AuthConfigModule);
 
+// src/auth/decorators/onboarding.decorator.ts
+import { SetMetadata } from "@nestjs/common";
+var Onboarding = /* @__PURE__ */ __name(() => SetMetadata("isOnboarding", true), "Onboarding");
+
+// src/auth/decorators/public.decorator.ts
+import { SetMetadata as SetMetadata2 } from "@nestjs/common";
+var Public = /* @__PURE__ */ __name(() => SetMetadata2("isPublic", true), "Public");
+
 // src/database/database.module.ts
 import { Global as Global3, Module as Module3 } from "@nestjs/common";
 import { APP_INTERCEPTOR } from "@nestjs/core";
 
-// src/database/interceptors/message-tenant-context.interceptor.ts
-import { Injectable as Injectable5, Logger as Logger3, Scope as Scope4 } from "@nestjs/common";
-import { tap } from "rxjs/operators";
-
-// src/database/services/tenant-context.service.ts
-import { Injectable as Injectable4, Scope as Scope3, UnauthorizedException as UnauthorizedException2 } from "@nestjs/common";
-function _ts_decorate6(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_decorate6, "_ts_decorate");
-var TenantContextService = class {
-  static {
-    __name(this, "TenantContextService");
-  }
-  tenantInfo = null;
-  /**
-  * Set tenant information for this request/message
-  *
-  * This is typically called by:
-  * - TenantContextInterceptor (for HTTP requests in gateway)
-  * - MessageTenantContextInterceptor (for RabbitMQ messages in microservices)
-  * - Manual context setup in message handlers
-  *
-  * @param tenantInfo Complete tenant information
-  * @throws Error if tenant context is already set (prevents accidental overwrites)
-  */
-  setTenant(tenantInfo) {
-    if (this.tenantInfo) {
-      throw new Error("Tenant context already set for this request");
-    }
-    this.tenantInfo = tenantInfo;
-  }
-  /**
-  * Get tenant information for this request/message
-  *
-  * @returns Tenant information
-  * @throws UnauthorizedException if tenant context hasn't been set
-  */
-  getTenant() {
-    if (!this.tenantInfo) {
-      throw new UnauthorizedException2("Tenant context not set");
-    }
-    return this.tenantInfo;
-  }
-  /**
-  * Check if tenant context has been set
-  *
-  * @returns true if tenant context is available
-  */
-  hasTenant() {
-    return this.tenantInfo !== null;
-  }
-  /**
-  * Clear tenant context
-  *
-  * This is useful for cleanup in RabbitMQ message handlers
-  * after the message has been processed.
-  *
-  * HTTP requests don't need manual cleanup as the service
-  * instance is destroyed when the request ends.
-  */
-  clearTenant() {
-    this.tenantInfo = null;
-  }
-  /**
-  * Get tenant ID safely (returns null if not set)
-  *
-  * @returns Tenant ID or null
-  */
-  getTenantIdSafe() {
-    return this.tenantInfo?.id ?? null;
-  }
-  /**
-  * Get tenant subdomain safely (returns null if not set)
-  *
-  * @returns Tenant subdomain or null
-  */
-  getTenantSubdomainSafe() {
-    return this.tenantInfo?.subdomain ?? null;
-  }
-};
-TenantContextService = _ts_decorate6([
-  Injectable4({
-    scope: Scope3.REQUEST
-  })
-], TenantContextService);
+// src/database/constants.ts
+var DATABASE_MODULE_OPTIONS = Symbol("DATABASE_MODULE_OPTIONS");
 
 // src/database/interceptors/message-tenant-context.interceptor.ts
-function _ts_decorate7(decorators, target, key, desc) {
+import { Injectable as Injectable3, Logger as Logger3, Scope as Scope3 } from "@nestjs/common";
+import { tap } from "rxjs/operators";
+function _ts_decorate5(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_decorate7, "_ts_decorate");
-function _ts_metadata4(k, v) {
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata3(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata4, "_ts_metadata");
+__name(_ts_metadata3, "_ts_metadata");
 var MessageTenantContextInterceptor = class _MessageTenantContextInterceptor {
   static {
     __name(this, "MessageTenantContextInterceptor");
@@ -778,7 +521,7 @@ var MessageTenantContextInterceptor = class _MessageTenantContextInterceptor {
     if (contextType === "rpc") {
       const rpcContext = context.switchToRpc();
       const payload = rpcContext.getData();
-      if (payload && payload.tenant) {
+      if (payload?.tenant) {
         const tenant = payload.tenant;
         this.logger.debug(`Setting tenant context from message: ${tenant.subdomain}`);
         try {
@@ -814,30 +557,29 @@ var MessageTenantContextInterceptor = class _MessageTenantContextInterceptor {
     }
   }
 };
-MessageTenantContextInterceptor = _ts_decorate7([
-  Injectable5({
-    scope: Scope4.REQUEST
+MessageTenantContextInterceptor = _ts_decorate5([
+  Injectable3({
+    scope: Scope3.REQUEST
   }),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
     typeof TenantContextService === "undefined" ? Object : TenantContextService
   ])
 ], MessageTenantContextInterceptor);
 
 // src/database/interceptors/tenant-context.interceptor.ts
-import { Injectable as Injectable6, Logger as Logger4, Scope as Scope5, UnauthorizedException as UnauthorizedException3 } from "@nestjs/common";
-import { Reflector as Reflector2 } from "@nestjs/core";
-function _ts_decorate8(decorators, target, key, desc) {
+import { Injectable as Injectable4, Logger as Logger4, Scope as Scope4, UnauthorizedException as UnauthorizedException2 } from "@nestjs/common";
+function _ts_decorate6(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_decorate8, "_ts_decorate");
-function _ts_metadata5(k, v) {
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata5, "_ts_metadata");
+__name(_ts_metadata4, "_ts_metadata");
 var TenantContextInterceptor = class _TenantContextInterceptor {
   static {
     __name(this, "TenantContextInterceptor");
@@ -867,7 +609,7 @@ var TenantContextInterceptor = class _TenantContextInterceptor {
         return next.handle();
       }
       if (!tenantIdentifier) {
-        throw new UnauthorizedException3("Tenant identifier not found in request");
+        throw new UnauthorizedException2("Tenant identifier not found in request");
       }
       this.logger.debug(`Tenant identifier extracted: ${tenantIdentifier}`);
       if (tenantIdentifier === "cloud") {
@@ -877,11 +619,11 @@ var TenantContextInterceptor = class _TenantContextInterceptor {
       const tenantInfo = await this.primaryDatabase.getTenantInfo(tenantIdentifier);
       if (!tenantInfo) {
         this.logger.warn(`Invalid tenant: ${tenantIdentifier}`);
-        throw new UnauthorizedException3("Invalid tenant");
+        throw new UnauthorizedException2("Invalid tenant");
       }
       if (tenantInfo.status !== "ACTIVE") {
         this.logger.warn(`Tenant ${tenantIdentifier} has status: ${tenantInfo.status}`);
-        throw new UnauthorizedException3(`Tenant is ${tenantInfo.status}`);
+        throw new UnauthorizedException2(`Tenant is ${tenantInfo.status}`);
       }
       this.logger.debug(`Tenant config loaded: ${tenantInfo.subdomain} (${tenantInfo.type})`);
       this.tenantContext.setTenant(tenantInfo);
@@ -894,657 +636,686 @@ var TenantContextInterceptor = class _TenantContextInterceptor {
     return next.handle();
   }
 };
-TenantContextInterceptor = _ts_decorate8([
-  Injectable6({
-    scope: Scope5.REQUEST
+TenantContextInterceptor = _ts_decorate6([
+  Injectable4({
+    scope: Scope4.REQUEST
   }),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
-    typeof Reflector2 === "undefined" ? Object : Reflector2,
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector,
     typeof TenantContextService === "undefined" ? Object : TenantContextService,
     typeof PrimaryDatabaseService === "undefined" ? Object : PrimaryDatabaseService,
     typeof RequestService === "undefined" ? Object : RequestService
   ])
 ], TenantContextInterceptor);
 
-// src/database/services/tenant-database.service.ts
-import { Inject as Inject3, Injectable as Injectable7, InternalServerErrorException as InternalServerErrorException2, Logger as Logger5 } from "@nestjs/common";
-import { Pool as Pool2 } from "pg";
-import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
-function _ts_decorate9(decorators, target, key, desc) {
+// src/database/services/primary-database.service.ts
+import { Inject as Inject2, Injectable as Injectable5, InternalServerErrorException, Logger as Logger5 } from "@nestjs/common";
+import { eq, or } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+function _ts_decorate7(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_decorate9, "_ts_decorate");
-function _ts_metadata6(k, v) {
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata5(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata6, "_ts_metadata");
-function _ts_param3(paramIndex, decorator) {
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param3, "_ts_param");
-var TenantDatabaseService = class _TenantDatabaseService {
+__name(_ts_param2, "_ts_param");
+var PrimaryDatabaseService2 = class _PrimaryDatabaseService {
   static {
-    __name(this, "TenantDatabaseService");
+    __name(this, "PrimaryDatabaseService");
   }
   options;
-  tenantContext;
-  logger = new Logger5(_TenantDatabaseService.name);
-  /** Connection pool: Map<cacheKey, TenantConnection> */
-  clients = /* @__PURE__ */ new Map();
-  /** Track last usage time for idle connection cleanup */
-  clientLastUsed = /* @__PURE__ */ new Map();
-  /** Cleanup interval timer */
-  cleanupInterval;
-  constructor(options, tenantContext) {
+  logger = new Logger5(_PrimaryDatabaseService.name);
+  /** PostgreSQL connection pool */
+  pool = null;
+  /** Drizzle database instance */
+  db = null;
+  /** In-memory cache: Map<tenantIdentifier, TenantConfig> */
+  tenantConfigCache = /* @__PURE__ */ new Map();
+  /** Cache TTL in milliseconds */
+  cacheTTL;
+  constructor(options) {
     this.options = options;
-    this.tenantContext = tenantContext;
-    this.startConnectionCleaner();
+    this.cacheTTL = options.connectionCacheTTL || 3e5;
   }
-  /**
-  * Get the Drizzle client for the current tenant's database.
-  * This returns the tenant-scoped database client.
-  *
-  * @returns Tenant-scoped Drizzle database instance
-  * @throws UnauthorizedException if tenant context not set
-  * @throws InternalServerErrorException if connection fails
-  */
-  get drizzleClient() {
-    return this.getDbClient();
+  async onModuleInit() {
+    if (this.options.primaryDb) {
+      await this.initializeDrizzleClient();
+    }
   }
   /**
-  * Get the Drizzle schema
+  * Initialize connection to primary database using Drizzle
   */
-  get schema() {
-    return this.options.drizzleSchema;
+  async initializeDrizzleClient() {
+    try {
+      const databaseUrl = this.buildPrimaryDbUrl();
+      this.pool = new Pool({
+        connectionString: databaseUrl,
+        max: this.options.maxConnections || 10
+      });
+      this.logger.debug(`Schema keys passed to drizzle: [${Object.keys(this.options.drizzleSchema || {}).join(", ")}]`);
+      this.logger.debug(`Relations keys passed to drizzle: [${Object.keys(this.options.drizzleRelations || {}).join(", ")}]`);
+      this.db = drizzle({
+        client: this.pool,
+        schema: this.options.drizzleSchema,
+        relations: this.options.drizzleRelations
+      });
+      this.logger.debug(`Drizzle query keys after init: [${Object.keys(this.db.query || {}).join(", ")}]`);
+      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);
+      throw new InternalServerErrorException("Failed to initialize tenant registry");
+    }
   }
   /**
-  * Get tenant-scoped database client for the current request/message
-  *
-  * This method:
-  * 1. Gets tenant info from TenantContextService
-  * 2. Builds a connection URL based on tenant type
-  * 3. Returns cached client if exists, otherwise creates new one
-  *
-  * @returns Drizzle database instance
-  * @throws UnauthorizedException if tenant context not set
-  * @throws InternalServerErrorException if connection fails
+  * Build connection URL from primary database properties
   */
-  getDbClient() {
-    const tenant = this.tenantContext.getTenant();
-    const cacheKey = this.buildCacheKey(tenant);
-    const existing = this.clients.get(cacheKey);
-    if (existing) {
-      this.clientLastUsed.set(cacheKey, Date.now());
-      this.logger.debug(`Reusing cached connection: ${cacheKey}`);
-      return existing.db;
+  buildPrimaryDbUrl() {
+    if (!this.options.primaryDb) {
+      throw new Error("Primary database configuration not provided");
     }
-    this.logger.log(`Creating new database connection: ${cacheKey}`);
-    const connection = this.createDbClientSync(tenant);
-    this.clients.set(cacheKey, connection);
-    this.clientLastUsed.set(cacheKey, Date.now());
-    return connection.db;
+    const { host, port = 5432, username, password, database, schema = "public", sslMode = "require" } = this.options.primaryDb;
+    let url = `postgresql://${username}:${encodeURIComponent(password)}@${host}:${port}/${database}`;
+    const params = new URLSearchParams();
+    if (schema) {
+      params.set("schema", schema);
+    }
+    params.set("sslmode", sslMode);
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    this.logger.debug(`Primary DB connection URL: ${this.maskPassword(url)}`);
+    return url;
   }
   /**
-  * Create a new database client for the given tenant (synchronous)
+  * Mask password in connection URL for logging
   */
-  createDbClientSync(tenant) {
+  maskPassword(url) {
+    return url.replace(/:([^@]+)@/, ":****@");
+  }
+  /**
+  * Get tenant configuration by identifier (ID or subdomain)
+  *
+  * @param tenantIdentifier Tenant ID or subdomain
+  * @returns Tenant configuration or null if not found
+  */
+  async getTenantInfo(tenantIdentifier) {
+    const cached = this.tenantConfigCache.get(tenantIdentifier);
+    if (cached) {
+      this.logger.debug(`Cache hit for tenant: ${tenantIdentifier}`);
+      return cached;
+    }
     try {
-      const databaseUrl = this.buildTenantDbUrl(tenant);
-      const pool = new Pool2({
-        connectionString: databaseUrl,
-        max: tenant.connectionPoolSize || this.options.maxConnections || 10
-      });
-      const db = drizzle2({
-        client: pool,
-        schema: this.options.drizzleSchema
-      });
-      this.logger.log(`Connected to database for tenant: ${tenant.subdomain}`);
-      return {
-        pool,
-        db
+      if (!this.db) {
+        throw new Error("Primary database client not initialized");
+      }
+      this.logger.debug(`Querying primary database for tenant: ${tenantIdentifier}`);
+      const schema = this.options.drizzleSchema;
+      const { tenants, tenantDatabaseConfigs } = schema;
+      const result = await this.db.select().from(tenants).leftJoin(tenantDatabaseConfigs, eq(tenants.id, tenantDatabaseConfigs.tenantId)).where(or(eq(tenants.id, tenantIdentifier), 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: config?.dbSchema || void 0,
+        // For DEDICATED tenants: database configuration from TenantDatabaseConfig table
+        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;
     } catch (error) {
-      this.logger.error(`Failed to create database connection for tenant: ${tenant.subdomain}`, error);
-      throw new InternalServerErrorException2("Failed to connect to tenant database");
+      this.logger.error(`Failed to fetch tenant info: ${tenantIdentifier}`, error);
+      throw new InternalServerErrorException("Failed to resolve tenant");
     }
   }
   /**
-  * Build connection URL for tenant (dedicated database)
+  * Cache tenant information with TTL
   */
-  buildTenantDbUrl(tenant) {
-    const { databaseHost, databasePort, databaseName, databaseUsername, databasePassword, databaseSslMode } = tenant;
-    if (!databaseHost || !databaseName || !databaseUsername) {
-      throw new Error(`Tenant ${tenant.subdomain} missing database configuration`);
-    }
-    const port = databasePort || 5432;
-    const sslMode = databaseSslMode || "require";
-    const connectionUrl = `postgresql://${databaseUsername}:${encodeURIComponent(databasePassword || "")}@${databaseHost}:${port}/${databaseName}?sslmode=${sslMode}`;
-    this.logger.debug(`Tenant connection URL: ${this.maskPassword(connectionUrl)}`);
-    return connectionUrl;
+  cacheInfo(info) {
+    this.tenantConfigCache.set(info.id, info);
+    this.tenantConfigCache.set(info.subdomain, info);
+    setTimeout(() => {
+      this.tenantConfigCache.delete(info.id);
+      this.tenantConfigCache.delete(info.subdomain);
+      this.logger.debug(`Cache expired for tenant: ${info.subdomain}`);
+    }, this.cacheTTL);
   }
   /**
-  * Build cache key for connection pooling
+  * Clear cached tenant information
+  *
+  * Useful when tenant settings are updated and cache needs to be invalidated
+  *
+  * @param tenantIdentifier Tenant ID or subdomain
   */
-  buildCacheKey(tenant) {
-    return `${tenant.type}:${tenant.databaseName}@${tenant.databaseHost}`;
+  clearTenantCache(tenantIdentifier) {
+    const config = this.tenantConfigCache.get(tenantIdentifier);
+    if (config) {
+      this.tenantConfigCache.delete(config.id);
+      this.tenantConfigCache.delete(config.subdomain);
+      this.logger.log(`Cleared cache for tenant: ${tenantIdentifier}`);
+    }
   }
   /**
-  * Start periodic cleanup of idle connections
+  * Clear all cached tenant configurations
   */
-  startConnectionCleaner() {
-    const interval = this.options.connectionCacheTTL || 3e5;
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupIdleConnections();
-    }, interval);
-    this.logger.log(`Connection cleanup scheduled every ${interval / 1e3} seconds`);
+  clearAllCaches() {
+    const size = this.tenantConfigCache.size;
+    this.tenantConfigCache.clear();
+    this.logger.log(`Cleared ${size} cached tenant configs`);
   }
   /**
-  * Clean up idle connections that haven't been used recently
+  * Get the Drizzle database instance for the primary database.
+  * This is a synchronous property that returns the initialized Drizzle client.
+  *
+  * @returns Primary database Drizzle instance
+  * @throws Error if primary database client is not initialized
   */
-  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 connection = this.clients.get(key);
-        if (connection) {
-          try {
-            await connection.pool.end();
-            this.logger.debug(`Cleaned up idle connection: ${key}`);
-          } catch (error) {
-            this.logger.error(`Error disconnecting idle client: ${key}`, error);
-          }
-          this.clients.delete(key);
-          this.clientLastUsed.delete(key);
-          cleaned++;
-        }
-      }
-    }
-    if (cleaned > 0) {
-      this.logger.log(`Cleaned up ${cleaned} idle connections`);
+  get drizzleClient() {
+    if (!this.db) {
+      throw new Error("Primary database client not initialized");
     }
+    return this.db;
   }
   /**
-  * Get current connection pool statistics
+  * Get the Drizzle schema
   */
-  getPoolStats() {
-    return {
-      activeConnections: this.clients.size,
-      tenants: Array.from(this.clients.keys())
-    };
+  get schema() {
+    return this.options.drizzleSchema;
   }
   /**
-  * Mask password in connection URL for logging
+  * Decrypt database credentials
+  *
+  * Override this method to implement your encryption strategy
+  *
+  * @param encrypted Encrypted value
+  * @returns Decrypted value
   */
-  maskPassword(url) {
-    return url.replace(/:([^@]+)@/, ":****@");
+  decrypt(encrypted) {
+    return encrypted;
   }
   async onModuleDestroy() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
+    if (this.pool) {
+      await this.pool.end();
+      this.logger.log("Disconnected from primary database");
     }
-    this.logger.log(`Disconnecting ${this.clients.size} database connections`);
-    const disconnectPromises = Array.from(this.clients.entries()).map(async ([key, connection]) => {
-      try {
-        await connection.pool.end();
-        this.logger.debug(`Disconnected: ${key}`);
-      } catch (error) {
-        this.logger.error(`Error disconnecting client: ${key}`, error);
-      }
-    });
-    await Promise.all(disconnectPromises);
-    this.logger.log("All database connections closed");
   }
 };
-TenantDatabaseService = _ts_decorate9([
-  Injectable7(),
-  _ts_param3(0, Inject3(DATABASE_MODULE_OPTIONS)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
-    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions,
-    typeof TenantContextService === "undefined" ? Object : TenantContextService
+PrimaryDatabaseService2 = _ts_decorate7([
+  Injectable5(),
+  _ts_param2(0, Inject2(DATABASE_MODULE_OPTIONS)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions
   ])
-], TenantDatabaseService);
+], PrimaryDatabaseService2);
 
-// src/database/database.module.ts
-function _ts_decorate10(decorators, target, key, desc) {
+// src/database/services/tenant-context.service.ts
+import { Injectable as Injectable6, Scope as Scope5, UnauthorizedException as UnauthorizedException3 } from "@nestjs/common";
+function _ts_decorate8(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_decorate10, "_ts_decorate");
-var DatabaseModule = class _DatabaseModule {
+__name(_ts_decorate8, "_ts_decorate");
+var TenantContextService2 = class {
   static {
-    __name(this, "DatabaseModule");
+    __name(this, "TenantContextService");
   }
+  tenantInfo = null;
   /**
-  * Configure DatabaseModule for Gateway/HTTP mode (multi-tenant web servers)
-  *
-  * This mode is for API Gateways that handle HTTP requests:
-  * - Automatically registers TenantContextInterceptor
-  * - Extracts tenant from subdomain or x-tenant-id header
-  * - Queries primary database for tenant configuration
-  * - Provides PrimaryDatabaseService for tenant lookup
+  * Set tenant information for this request/message
   *
-  * @param options Async configuration options
-  * @returns Dynamic module configuration with HTTP interceptor
+  * This is typically called by:
+  * - TenantContextInterceptor (for HTTP requests in gateway)
+  * - MessageTenantContextInterceptor (for RabbitMQ messages in microservices)
+  * - Manual context setup in message handlers
   *
-  * @example
-  * DatabaseModule.forServer({
-  *   inject: [ConfigService],
-  *   useFactory: (config: ConfigService) => ({
-  *     primaryDb: {
-  *       host: config.get('PRIMARY_DB_HOST'),
-  *       port: config.get('PRIMARY_DB_PORT'),
-  *       username: config.get('PRIMARY_DB_USERNAME'),
-  *       password: config.get('PRIMARY_DB_PASSWORD'),
-  *       database: config.get('PRIMARY_DB_DATABASE'),
-  *     },
-  *     prismaClientConstructor: PrismaClient,
-  *   }),
-  * })
+  * @param tenantInfo Complete tenant information
+  * @throws Error if tenant context is already set (prevents accidental overwrites)
   */
-  static forServer(options) {
-    return this.createDynamicModule(options, "server");
+  setTenant(tenantInfo) {
+    if (this.tenantInfo) {
+      throw new Error("Tenant context already set for this request");
+    }
+    this.tenantInfo = tenantInfo;
   }
   /**
-  * Configure DatabaseModule for Microservice/Messaging mode (RabbitMQ workers)
-  *
-  * This mode is for microservices that process messages from queues:
-  * - Automatically registers MessageTenantContextInterceptor
-  * - Extracts tenant from RabbitMQ message patterns
-  * - No primary database needed (tenant comes from message context)
-  *
-  * @param options Async configuration options
-  * @returns Dynamic module configuration with message interceptor
+  * Get tenant information for this request/message
   *
-  * @example
-  * DatabaseModule.forMicroservice({
-  *   inject: [ConfigService],
-  *   useFactory: (config: ConfigService) => ({
-  *     prismaClientConstructor: PrismaClient,
-  *   }),
-  * })
+  * @returns Tenant information
+  * @throws UnauthorizedException if tenant context hasn't been set
   */
-  static forMicroservice(options) {
-    return this.createDynamicModule(options, "microservice");
+  getTenant() {
+    if (!this.tenantInfo) {
+      throw new UnauthorizedException3("Tenant context not set");
+    }
+    return this.tenantInfo;
   }
   /**
-  * Internal helper to create dynamic module with conditional interceptor registration
+  * Check if tenant context has been set
   *
-  * @param options Configuration options
-  * @param mode Mode of operation (gateway or microservice)
-  * @returns Dynamic module configuration
+  * @returns true if tenant context is available
   */
-  static createDynamicModule(options, mode) {
-    const asyncProvider = {
-      provide: DATABASE_MODULE_OPTIONS,
-      useFactory: options.useFactory,
-      inject: options.inject || []
-    };
-    const providers = [
-      asyncProvider,
-      TenantContextService,
-      PrimaryDatabaseService,
-      TenantDatabaseService
-    ];
-    if (mode === "server") {
-      providers.push({
-        provide: APP_INTERCEPTOR,
-        useClass: TenantContextInterceptor
-      });
-    } else {
-      providers.push({
-        provide: APP_INTERCEPTOR,
-        useClass: MessageTenantContextInterceptor
-      });
-    }
-    return {
-      module: _DatabaseModule,
-      imports: [
-        RequestModule
-      ],
-      providers,
-      exports: [
-        TenantDatabaseService,
-        TenantContextService,
-        PrimaryDatabaseService,
-        asyncProvider
-      ]
-    };
-  }
-};
-DatabaseModule = _ts_decorate10([
-  Global3(),
-  Module3({})
-], DatabaseModule);
-
-// src/database/repositories/primary-base.repository.ts
-import { Logger as Logger6 } from "@nestjs/common";
-import { eq as eq2, sql, getTableName } from "drizzle-orm";
-var PrimaryBaseRepository = class {
-  static {
-    __name(this, "PrimaryBaseRepository");
+  hasTenant() {
+    return this.tenantInfo !== null;
   }
-  database;
-  table;
-  logger;
-  /**
-  * 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.
+  * Clear tenant context
+  *
+  * This is useful for cleanup in RabbitMQ message handlers
+  * after the message has been processed.
+  *
+  * HTTP requests don't need manual cleanup as the service
+  * instance is destroyed when the request ends.
   */
-  get db() {
-    return this.database.drizzleClient;
+  clearTenant() {
+    this.tenantInfo = null;
   }
   /**
-  * Model query API for THIS repository's table (Drizzle v2 relational queries)
-  * Scoped to only the table this repository manages.
-  * Returns a type-safe wrapper around Drizzle's RelationalQueryBuilder.
+  * Get tenant ID safely (returns null if not set)
   *
-  * @example
-  * ```typescript
-  * // Use relational queries with v2 object-based where syntax
-  * const user = await this.model.findFirst({
-  *   where: { id },
-  *   with: { posts: true, profile: true }
-  * });
-  * ```
+  * @returns Tenant ID or null
   */
-  get model() {
-    const query = this.database.drizzleClient.query;
-    const queryKeys = Object.keys(query || {});
-    this.logger.debug(`Looking for '${this.tableName}' in query keys: [${queryKeys.join(", ")}]`);
-    const model = query[this.tableName];
-    if (!model) {
-      this.logger.error(`Table '${this.tableName}' not found in query object. Available: [${queryKeys.join(", ")}]`);
-    }
-    return model;
+  getTenantIdSafe() {
+    return this.tenantInfo?.id ?? null;
   }
   /**
-  * Create a new repository instance
-  *
-  * @param database - The primary database service
-  * @param table - The Drizzle table schema object
-  *
-  * @example
-  * ```typescript
-  * import { users } from '@/db/schema';
+  * Get tenant subdomain safely (returns null if not set)
   *
-  * constructor(database: PrimaryDatabaseService) {
-  *   super(database, users);
-  * }
-  * ```
+  * @returns Tenant subdomain or null
   */
-  constructor(database, table) {
-    this.database = database;
-    this.table = table;
-    this.tableName = getTableName(table);
-    this.logger = new Logger6(this.constructor.name);
-    this.logger.debug(`Initialized ${this.constructor.name}`);
-    this.logger.debug(`Table name from getTableName: '${this.tableName}'`);
+  getTenantSubdomainSafe() {
+    return this.tenantInfo?.subdomain ?? null;
+  }
+};
+TenantContextService2 = _ts_decorate8([
+  Injectable6({
+    scope: Scope5.REQUEST
+  })
+], TenantContextService2);
+
+// src/database/services/tenant-database.service.ts
+import { Inject as Inject3, Injectable as Injectable7, InternalServerErrorException as InternalServerErrorException2, Logger as Logger6 } from "@nestjs/common";
+import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
+import { Pool as Pool2 } from "pg";
+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);
+  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_decorate9, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var TenantDatabaseService = class _TenantDatabaseService {
+  static {
+    __name(this, "TenantDatabaseService");
+  }
+  options;
+  tenantContext;
+  logger = new Logger6(_TenantDatabaseService.name);
+  /** Connection pool: Map<cacheKey, TenantConnection> */
+  clients = /* @__PURE__ */ new Map();
+  /** Track last usage time for idle connection cleanup */
+  clientLastUsed = /* @__PURE__ */ new Map();
+  /** Cleanup interval timer */
+  cleanupInterval;
+  constructor(options, tenantContext) {
+    this.options = options;
+    this.tenantContext = tenantContext;
+    this.startConnectionCleaner();
   }
   /**
-  * Create a new record
-  *
-  * @param data - The data to create the record with
-  * @returns Promise resolving to the created record
+  * Get the Drizzle client for the current tenant's database.
+  * This returns the tenant-scoped database client.
   *
-  * @example
-  * ```typescript
-  * const user = await userRepository.create({
-  *   email: 'user@example.com',
-  *   firstName: 'John'
-  * });
-  * ```
+  * @returns Tenant-scoped Drizzle database instance
+  * @throws UnauthorizedException if tenant context not set
+  * @throws InternalServerErrorException if connection fails
   */
-  async create(data) {
-    this.logger.log("Creating record");
-    const results = await this.db.insert(this.table).values(data).returning();
-    return results[0];
+  get drizzleClient() {
+    return this.getDbClient();
   }
   /**
-  * Find a single record by ID
-  *
-  * @param id - The record ID
-  * @returns Promise resolving to the record or undefined if not found
-  *
-  * @example
-  * ```typescript
-  * const user = await userRepository.findById('user-id-123');
-  * ```
+  * Get the Drizzle schema
   */
-  async findById(id) {
-    this.logger.debug(`Finding record by ID: ${id}`);
-    return this.model.findFirst({
-      where: {
-        id
-      }
-    });
+  get schema() {
+    return this.options.drizzleSchema;
   }
   /**
-  * Find a single record with custom where clause (Drizzle v2 object-based syntax)
-  *
-  * @param where - Object-based filter condition
-  * @returns Promise resolving to the record or undefined if not found
-  *
-  * @example
-  * ```typescript
-  * // Simple equality
-  * const user = await userRepository.findOne({ email: 'user@example.com' });
+  * Get tenant-scoped database client for the current request/message
   *
-  * // With operators
-  * const user = await userRepository.findOne({ age: { gte: 18 } });
+  * This method:
+  * 1. Gets tenant info from TenantContextService
+  * 2. Builds a connection URL based on tenant type
+  * 3. Returns cached client if exists, otherwise creates new one
   *
-  * // Multiple conditions (AND)
-  * const user = await userRepository.findOne({
-  *   email: 'user@example.com',
-  *   status: 'ACTIVE'
-  * });
-  * ```
+  * @returns Drizzle database instance
+  * @throws UnauthorizedException if tenant context not set
+  * @throws InternalServerErrorException if connection fails
   */
-  async findOne(where) {
-    this.logger.debug("Finding record with custom query");
-    return this.model.findFirst({
-      where
-    });
+  getDbClient() {
+    const tenant = this.tenantContext.getTenant();
+    const cacheKey = this.buildCacheKey(tenant);
+    const existing = this.clients.get(cacheKey);
+    if (existing) {
+      this.clientLastUsed.set(cacheKey, Date.now());
+      this.logger.debug(`Reusing cached connection: ${cacheKey}`);
+      return existing.db;
+    }
+    this.logger.log(`Creating new database connection: ${cacheKey}`);
+    const connection = this.createDbClientSync(tenant);
+    this.clients.set(cacheKey, connection);
+    this.clientLastUsed.set(cacheKey, Date.now());
+    return connection.db;
   }
   /**
-  * Find multiple records (Drizzle v2 object-based syntax)
-  *
-  * @param options - Query options (where, orderBy, limit, offset)
-  * @returns Promise resolving to an array of records
-  *
-  * @example
-  * ```typescript
-  * // Find all users
-  * const users = await userRepository.findMany();
-  *
-  * // Find with filtering and pagination (v2 object syntax)
-  * const users = await userRepository.findMany({
-  *   where: { accountStatus: 'ACTIVE' },
-  *   orderBy: { createdAt: 'desc' },
-  *   limit: 10,
-  *   offset: 0
-  * });
-  *
-  * // Multiple conditions
-  * const users = await userRepository.findMany({
-  *   where: {
-  *     AND: [
-  *       { status: 'ACTIVE' },
-  *       { age: { gte: 18 } }
-  *     ]
-  *   }
-  * });
-  * ```
+  * Create a new database client for the given tenant (synchronous)
   */
-  async findMany(options) {
-    this.logger.debug("Finding multiple records");
-    return this.model.findMany(options);
+  createDbClientSync(tenant) {
+    try {
+      const databaseUrl = this.buildTenantDbUrl(tenant);
+      const pool = new Pool2({
+        connectionString: databaseUrl,
+        max: tenant.connectionPoolSize || this.options.maxConnections || 10
+      });
+      const db = drizzle2({
+        client: pool,
+        schema: this.options.drizzleSchema
+      });
+      this.logger.log(`Connected to database for tenant: ${tenant.subdomain}`);
+      return {
+        pool,
+        db
+      };
+    } catch (error) {
+      this.logger.error(`Failed to create database connection for tenant: ${tenant.subdomain}`, error);
+      throw new InternalServerErrorException2("Failed to connect to tenant database");
+    }
   }
   /**
-  * Update a record by ID
-  *
-  * @param id - The record ID
-  * @param data - The data to update
-  * @returns Promise resolving to the updated record
-  *
-  * @example
-  * ```typescript
-  * const user = await userRepository.update('user-id-123', {
-  *   firstName: 'Jane'
-  * });
-  * ```
+  * Build connection URL for tenant (dedicated database)
   */
-  async update(id, data) {
-    this.logger.log(`Updating record with ID: ${id}`);
-    const idColumn = this.table.id;
-    const results = await this.db.update(this.table).set(data).where(eq2(idColumn, id)).returning();
-    return results[0];
+  buildTenantDbUrl(tenant) {
+    const { databaseHost, databasePort, databaseName, databaseUsername, databasePassword, databaseSslMode } = tenant;
+    if (!databaseHost || !databaseName || !databaseUsername) {
+      throw new Error(`Tenant ${tenant.subdomain} missing database configuration`);
+    }
+    const port = databasePort || 5432;
+    const sslMode = databaseSslMode || "require";
+    const connectionUrl = `postgresql://${databaseUsername}:${encodeURIComponent(databasePassword || "")}@${databaseHost}:${port}/${databaseName}?sslmode=${sslMode}`;
+    this.logger.debug(`Tenant connection URL: ${this.maskPassword(connectionUrl)}`);
+    return connectionUrl;
   }
   /**
-  * Update multiple 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(
-  *   eq(users.accountStatus, 'PENDING'),
-  *   { accountStatus: 'ACTIVE' }
-  * );
-  * console.log(`Updated ${result.count} users`);
-  * ```
+  * Build cache key for connection pooling
   */
-  async updateMany(where, data) {
-    this.logger.log("Updating multiple records");
-    const result = await this.db.update(this.table).set(data).where(where);
-    return {
-      count: result.rowCount ?? 0
-    };
+  buildCacheKey(tenant) {
+    return `${tenant.type}:${tenant.databaseName}@${tenant.databaseHost}`;
   }
   /**
-  * Delete a record by ID
-  *
-  * @param id - The record ID
-  * @returns Promise resolving to the deleted record
-  *
-  * @example
-  * ```typescript
-  * const user = await userRepository.delete('user-id-123');
-  * ```
+  * Start periodic cleanup of idle connections
   */
-  async delete(id) {
-    this.logger.log(`Deleting record with ID: ${id}`);
-    const idColumn = this.table.id;
-    const results = await this.db.delete(this.table).where(eq2(idColumn, id)).returning();
-    return results[0];
+  startConnectionCleaner() {
+    const interval = this.options.connectionCacheTTL || 3e5;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupIdleConnections();
+    }, interval);
+    this.logger.log(`Connection cleanup scheduled every ${interval / 1e3} seconds`);
   }
   /**
-  * Delete multiple records
-  *
-  * @param where - SQL condition to match records
-  * @returns Promise resolving to the count of deleted records
-  *
-  * @example
-  * ```typescript
-  * import { lt } from 'drizzle-orm';
-  *
-  * const result = await userRepository.deleteMany(
-  *   lt(users.createdAt, new Date('2020-01-01'))
-  * );
-  * console.log(`Deleted ${result.count} users`);
-  * ```
+  * Clean up idle connections that haven't been used recently
   */
-  async deleteMany(where) {
-    this.logger.log("Deleting multiple records");
-    const result = await this.db.delete(this.table).where(where);
-    return {
-      count: result.rowCount ?? 0
-    };
+  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 connection = this.clients.get(key);
+        if (connection) {
+          try {
+            await connection.pool.end();
+            this.logger.debug(`Cleaned up idle connection: ${key}`);
+          } catch (error) {
+            this.logger.error(`Error disconnecting idle client: ${key}`, error);
+          }
+          this.clients.delete(key);
+          this.clientLastUsed.delete(key);
+          cleaned++;
+        }
+      }
+    }
+    if (cleaned > 0) {
+      this.logger.log(`Cleaned up ${cleaned} idle connections`);
+    }
   }
   /**
-  * Count 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(
-  *   eq(users.accountStatus, 'ACTIVE')
-  * );
-  * ```
+  * Get current connection pool statistics
   */
-  async count(where) {
-    this.logger.debug("Counting records");
-    let query = this.db.select({
-      count: sql`count(*)::int`
-    }).from(this.table).$dynamic();
-    if (where) {
-      query = query.where(where);
-    }
-    const results = await query;
-    return results[0].count;
+  getPoolStats() {
+    return {
+      activeConnections: this.clients.size,
+      tenants: Array.from(this.clients.keys())
+    };
   }
   /**
-  * Check if a record exists
-  *
-  * @param where - SQL condition to match records
-  * @returns Promise resolving to true if at least one record exists, false otherwise
-  *
-  * @example
-  * ```typescript
-  * import { eq } from 'drizzle-orm';
-  *
-  * const emailExists = await userRepository.exists(
-  *   eq(users.email, 'user@example.com')
-  * );
-  * ```
+  * Mask password in connection URL for logging
   */
-  async exists(where) {
-    const count = await this.count(where);
-    return count > 0;
+  maskPassword(url) {
+    return url.replace(/:([^@]+)@/, ":****@");
   }
-};
-
-// src/database/repositories/tenant-base.repository.ts
-import { Logger as Logger7 } from "@nestjs/common";
-import { eq as eq3, sql as sql2, getTableName as getTableName2 } from "drizzle-orm";
-var TenantBaseRepository = class {
-  static {
-    __name(this, "TenantBaseRepository");
+  async onModuleDestroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.logger.log(`Disconnecting ${this.clients.size} database connections`);
+    const disconnectPromises = Array.from(this.clients.entries()).map(async ([key, connection]) => {
+      try {
+        await connection.pool.end();
+        this.logger.debug(`Disconnected: ${key}`);
+      } catch (error) {
+        this.logger.error(`Error disconnecting client: ${key}`, error);
+      }
+    });
+    await Promise.all(disconnectPromises);
+    this.logger.log("All database connections closed");
+  }
+};
+TenantDatabaseService = _ts_decorate9([
+  Injectable7(),
+  _ts_param3(0, Inject3(DATABASE_MODULE_OPTIONS)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions,
+    typeof TenantContextService === "undefined" ? Object : TenantContextService
+  ])
+], TenantDatabaseService);
+
+// src/database/database.module.ts
+function _ts_decorate10(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_decorate10, "_ts_decorate");
+var DatabaseModule = class _DatabaseModule {
+  static {
+    __name(this, "DatabaseModule");
+  }
+  /**
+  * Configure DatabaseModule for Gateway/HTTP mode (multi-tenant web servers)
+  *
+  * This mode is for API Gateways that handle HTTP requests:
+  * - Automatically registers TenantContextInterceptor
+  * - Extracts tenant from subdomain or x-tenant-id header
+  * - Queries primary database for tenant configuration
+  * - Provides PrimaryDatabaseService for tenant lookup
+  *
+  * @param options Async configuration options
+  * @returns Dynamic module configuration with HTTP interceptor
+  *
+  * @example
+  * DatabaseModule.forServer({
+  *   inject: [ConfigService],
+  *   useFactory: (config: ConfigService) => ({
+  *     primaryDb: {
+  *       host: config.get('PRIMARY_DB_HOST'),
+  *       port: config.get('PRIMARY_DB_PORT'),
+  *       username: config.get('PRIMARY_DB_USERNAME'),
+  *       password: config.get('PRIMARY_DB_PASSWORD'),
+  *       database: config.get('PRIMARY_DB_DATABASE'),
+  *     },
+  *     prismaClientConstructor: PrismaClient,
+  *   }),
+  * })
+  */
+  static forServer(options) {
+    return _DatabaseModule.createDynamicModule(options, "server");
+  }
+  /**
+  * Configure DatabaseModule for Microservice/Messaging mode (RabbitMQ workers)
+  *
+  * This mode is for microservices that process messages from queues:
+  * - Automatically registers MessageTenantContextInterceptor
+  * - Extracts tenant from RabbitMQ message patterns
+  * - No primary database needed (tenant comes from message context)
+  *
+  * @param options Async configuration options
+  * @returns Dynamic module configuration with message interceptor
+  *
+  * @example
+  * DatabaseModule.forMicroservice({
+  *   inject: [ConfigService],
+  *   useFactory: (config: ConfigService) => ({
+  *     prismaClientConstructor: PrismaClient,
+  *   }),
+  * })
+  */
+  static forMicroservice(options) {
+    return _DatabaseModule.createDynamicModule(options, "microservice");
+  }
+  /**
+  * Internal helper to create dynamic module with conditional interceptor registration
+  *
+  * @param options Configuration options
+  * @param mode Mode of operation (gateway or microservice)
+  * @returns Dynamic module configuration
+  */
+  static createDynamicModule(options, mode) {
+    const asyncProvider = {
+      provide: DATABASE_MODULE_OPTIONS,
+      useFactory: options.useFactory,
+      inject: options.inject || []
+    };
+    const providers = [
+      asyncProvider,
+      TenantContextService2,
+      PrimaryDatabaseService2,
+      TenantDatabaseService
+    ];
+    if (mode === "server") {
+      providers.push({
+        provide: APP_INTERCEPTOR,
+        useClass: TenantContextInterceptor
+      });
+    } else {
+      providers.push({
+        provide: APP_INTERCEPTOR,
+        useClass: MessageTenantContextInterceptor
+      });
+    }
+    return {
+      module: _DatabaseModule,
+      imports: [
+        RequestModule
+      ],
+      providers,
+      exports: [
+        TenantDatabaseService,
+        TenantContextService2,
+        PrimaryDatabaseService2,
+        asyncProvider
+      ]
+    };
+  }
+};
+DatabaseModule = _ts_decorate10([
+  Global3(),
+  Module3({})
+], DatabaseModule);
+
+// src/database/decorators/tenant.decorator.ts
+import { createParamDecorator } from "@nestjs/common";
+var Tenant = createParamDecorator((_data, ctx) => {
+  const request = ctx.switchToHttp().getRequest();
+  const tenantContext = request.app?.get?.(TenantContextService2);
+  if (!tenantContext) {
+    throw new Error("TenantContextService not found.");
+  }
+  return tenantContext.getTenant();
+});
+
+// src/database/repositories/primary-base.repository.ts
+import { Logger as Logger7 } from "@nestjs/common";
+import { eq as eq2, getTableName, sql } from "drizzle-orm";
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+__name(snakeToCamel, "snakeToCamel");
+var PrimaryBaseRepository = class {
+  static {
+    __name(this, "PrimaryBaseRepository");
   }
   database;
   table;
   logger;
   /**
   * The table name extracted from the Drizzle table at runtime.
-  * Used to access the query API for this repository's table.
+  * Stored in camelCase to match Drizzle's query object keys.
+  * Example: 'email_verifications' -> 'emailVerifications'
   */
   tableName;
   /**
@@ -1556,42 +1327,52 @@ var TenantBaseRepository = class {
     return this.database.drizzleClient;
   }
   /**
-  * Model query API for THIS repository's table (Prisma-like syntax)
-  * Scoped to only the table this repository manages
+  * Model query API for THIS repository's table (Drizzle v2 relational queries)
+  * 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 product = await this.model.findFirst({
-  *   where: eq(products.id, id),
-  *   with: { category: true, variants: true }
+  * // Use relational queries with v2 object-based where syntax
+  * const user = await this.model.findFirst({
+  *   where: { id },
+  *   with: { posts: true, profile: true }
   * });
   * ```
   */
   get model() {
-    return this.database.drizzleClient.query[this.tableName];
+    const query = this.database.drizzleClient.query;
+    const queryKeys = Object.keys(query || {});
+    this.logger.debug(`Looking for '${this.tableName}' in query keys: [${queryKeys.join(", ")}]`);
+    const model = query[this.tableName];
+    if (!model) {
+      this.logger.error(`Table '${this.tableName}' not found in query object. Available: [${queryKeys.join(", ")}]`);
+    }
+    return model;
   }
   /**
   * Create a new repository instance
   *
-  * @param database - The tenant database service
+  * @param database - The primary database service
   * @param table - The Drizzle table schema object
   *
   * @example
   * ```typescript
-  * import { products } from '@/db/schema';
+  * import { users } from '@/db/schema';
   *
-  * constructor(database: TenantDatabaseService) {
-  *   super(database, products);
+  * constructor(database: PrimaryDatabaseService) {
+  *   super(database, users);
   * }
   * ```
   */
   constructor(database, table) {
     this.database = database;
     this.table = table;
-    this.tableName = getTableName2(table);
+    const dbTableName = getTableName(table);
+    this.tableName = snakeToCamel(dbTableName);
     this.logger = new Logger7(this.constructor.name);
     this.logger.debug(`Initialized ${this.constructor.name}`);
+    this.logger.debug(`Table name: '${dbTableName}' -> query key: '${this.tableName}'`);
   }
   /**
   * Create a new record
@@ -1601,10 +1382,9 @@ var TenantBaseRepository = class {
   *
   * @example
   * ```typescript
-  * const product = await productRepository.create({
-  *   name: 'Widget',
-  *   sku: 'WDG-001',
-  *   price: 9.99
+  * const user = await userRepository.create({
+  *   email: 'user@example.com',
+  *   firstName: 'John'
   * });
   * ```
   */
@@ -1617,74 +1397,81 @@ var TenantBaseRepository = class {
   * 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
-  * const product = await productRepository.findById('product-id-123');
+  * const user = await userRepository.findById('user-id-123');
   * ```
   */
   async findById(id) {
     this.logger.debug(`Finding record by ID: ${id}`);
-    const idColumn = this.table.id;
-    const results = await this.db.select().from(this.table).where(eq3(idColumn, id)).limit(1);
-    return results[0] ?? null;
+    return this.model.findFirst({
+      where: {
+        id
+      }
+    });
   }
   /**
-  * Find a single record with custom where clause
+  * Find a single record with custom where clause (Drizzle v2 object-based syntax)
   *
-  * @param where - SQL condition
-  * @returns Promise resolving to the record or null if not found
+  * @param where - Object-based filter condition
+  * @returns Promise resolving to the record or undefined if not found
   *
   * @example
   * ```typescript
-  * import { eq } from 'drizzle-orm';
-  * const product = await productRepository.findOne(eq(products.sku, 'WDG-001'));
+  * // Simple equality
+  * const user = await userRepository.findOne({ email: 'user@example.com' });
+  *
+  * // With operators
+  * const user = await userRepository.findOne({ age: { gte: 18 } });
+  *
+  * // Multiple conditions (AND)
+  * const user = await userRepository.findOne({
+  *   email: 'user@example.com',
+  *   status: 'ACTIVE'
+  * });
   * ```
   */
   async findOne(where) {
     this.logger.debug("Finding record with custom query");
-    const results = await this.db.select().from(this.table).where(where).limit(1);
-    return results[0] ?? null;
+    return this.model.findFirst({
+      where
+    });
   }
   /**
-  * Find multiple records
+  * Find multiple records (Drizzle v2 object-based syntax)
   *
   * @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 all users
+  * const users = await userRepository.findMany();
   *
-  * // Find with filtering and pagination
-  * const products = await productRepository.findMany({
-  *   where: eq(products.status, 'ACTIVE'),
-  *   orderBy: desc(products.createdAt),
+  * // Find with filtering and pagination (v2 object syntax)
+  * const users = await userRepository.findMany({
+  *   where: { accountStatus: 'ACTIVE' },
+  *   orderBy: { createdAt: 'desc' },
   *   limit: 10,
   *   offset: 0
   * });
+  *
+  * // Multiple conditions
+  * const users = await userRepository.findMany({
+  *   where: {
+  *     AND: [
+  *       { status: 'ACTIVE' },
+  *       { age: { gte: 18 } }
+  *     ]
+  *   }
+  * });
   * ```
   */
   async findMany(options) {
     this.logger.debug("Finding multiple records");
-    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;
+    return this.model.findMany(options);
   }
   /**
   * Update a record by ID
@@ -1695,15 +1482,15 @@ var TenantBaseRepository = class {
   *
   * @example
   * ```typescript
-  * const product = await productRepository.update('product-id-123', {
-  *   price: 12.99
+  * const user = await userRepository.update('user-id-123', {
+  *   firstName: 'Jane'
   * });
   * ```
   */
   async update(id, data) {
     this.logger.log(`Updating record with ID: ${id}`);
     const idColumn = this.table.id;
-    const results = await this.db.update(this.table).set(data).where(eq3(idColumn, id)).returning();
+    const results = await this.db.update(this.table).set(data).where(eq2(idColumn, id)).returning();
     return results[0];
   }
   /**
@@ -1717,11 +1504,11 @@ var TenantBaseRepository = class {
   * ```typescript
   * import { eq } from 'drizzle-orm';
   *
-  * const result = await productRepository.updateMany(
-  *   eq(products.status, 'PENDING'),
-  *   { status: 'ACTIVE' }
+  * const result = await userRepository.updateMany(
+  *   eq(users.accountStatus, 'PENDING'),
+  *   { accountStatus: 'ACTIVE' }
   * );
-  * console.log(`Updated ${result.count} products`);
+  * console.log(`Updated ${result.count} users`);
   * ```
   */
   async updateMany(where, data) {
@@ -1739,13 +1526,13 @@ var TenantBaseRepository = class {
   *
   * @example
   * ```typescript
-  * const product = await productRepository.delete('product-id-123');
+  * const user = await userRepository.delete('user-id-123');
   * ```
   */
   async delete(id) {
     this.logger.log(`Deleting record with ID: ${id}`);
     const idColumn = this.table.id;
-    const results = await this.db.delete(this.table).where(eq3(idColumn, id)).returning();
+    const results = await this.db.delete(this.table).where(eq2(idColumn, id)).returning();
     return results[0];
   }
   /**
@@ -1758,10 +1545,10 @@ var TenantBaseRepository = class {
   * ```typescript
   * import { lt } from 'drizzle-orm';
   *
-  * const result = await productRepository.deleteMany(
-  *   lt(products.createdAt, new Date('2020-01-01'))
+  * const result = await userRepository.deleteMany(
+  *   lt(users.createdAt, new Date('2020-01-01'))
   * );
-  * console.log(`Deleted ${result.count} products`);
+  * console.log(`Deleted ${result.count} users`);
   * ```
   */
   async deleteMany(where) {
@@ -1781,19 +1568,19 @@ var TenantBaseRepository = class {
   * ```typescript
   * import { eq } from 'drizzle-orm';
   *
-  * // Count all products
-  * const total = await productRepository.count();
+  * // Count all users
+  * const total = await userRepository.count();
   *
-  * // Count active products
-  * const activeCount = await productRepository.count(
-  *   eq(products.status, 'ACTIVE')
+  * // Count active users
+  * const activeCount = await userRepository.count(
+  *   eq(users.accountStatus, 'ACTIVE')
   * );
   * ```
   */
   async count(where) {
     this.logger.debug("Counting records");
     let query = this.db.select({
-      count: sql2`count(*)::int`
+      count: sql`count(*)::int`
     }).from(this.table).$dynamic();
     if (where) {
       query = query.where(where);
@@ -1811,8 +1598,8 @@ var TenantBaseRepository = class {
   * ```typescript
   * import { eq } from 'drizzle-orm';
   *
-  * const skuExists = await productRepository.exists(
-  *   eq(products.sku, 'WDG-001')
+  * const emailExists = await userRepository.exists(
+  *   eq(users.email, 'user@example.com')
   * );
   * ```
   */
@@ -1822,218 +1609,302 @@ var TenantBaseRepository = class {
   }
 };
 
-// src/database/decorators/tenant.decorator.ts
-import { createParamDecorator } from "@nestjs/common";
-var Tenant = createParamDecorator((data, ctx) => {
-  const request = ctx.switchToHttp().getRequest();
-  const tenantContext = request.app?.get?.(TenantContextService);
-  if (!tenantContext) {
-    throw new Error("TenantContextService not found.");
-  }
-  return tenantContext.getTenant();
-});
-
-// src/auth/decorators/onboarding.decorator.ts
-import { SetMetadata } from "@nestjs/common";
-var Onboarding = /* @__PURE__ */ __name(() => SetMetadata("isOnboarding", true), "Onboarding");
-
-// src/auth/decorators/public.decorator.ts
-import { SetMetadata as SetMetadata2 } from "@nestjs/common";
-var Public = /* @__PURE__ */ __name(() => SetMetadata2("isPublic", true), "Public");
-
-// src/http/http.module.ts
-import { Module as Module4 } from "@nestjs/common";
-
-// src/http/guards/csrf.guard.ts
-import { ForbiddenException, Injectable as Injectable8, Logger as Logger8 } from "@nestjs/common";
-import { Reflector as Reflector3 } from "@nestjs/core";
-function _ts_decorate11(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_decorate11, "_ts_decorate");
-function _ts_metadata7(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata7, "_ts_metadata");
-var CsrfGuard = class _CsrfGuard {
+// src/database/repositories/tenant-base.repository.ts
+import { Logger as Logger8 } from "@nestjs/common";
+import { eq as eq3, getTableName as getTableName2, sql as sql2 } from "drizzle-orm";
+var TenantBaseRepository = class {
   static {
-    __name(this, "CsrfGuard");
-  }
-  reflector;
-  logger = new Logger8(_CsrfGuard.name);
-  constructor(reflector) {
-    this.reflector = reflector;
+    __name(this, "TenantBaseRepository");
   }
-  async canActivate(context) {
-    const request = context.switchToHttp().getRequest();
-    const reply = context.switchToHttp().getResponse();
-    const safeMethods = [
-      "GET",
-      "HEAD",
-      "OPTIONS"
-    ];
-    if (safeMethods.includes(request.method)) {
-      return true;
-    }
-    try {
-      const fastifyInstance = request.server;
-      if (!fastifyInstance.csrfProtection) {
-        this.logger.error("CSRF protection plugin not found. Ensure @fastify/csrf-protection is registered.");
-        throw new ForbiddenException("CSRF protection not configured");
-      }
-      await new Promise((resolve, reject) => {
-        fastifyInstance.csrfProtection(request, reply, (err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        });
-      });
-      this.logger.debug(`CSRF validation successful for ${request.method} ${request.url}`);
-      return true;
-    } catch (error) {
-      this.logger.warn(`CSRF validation failed for ${request.method} ${request.url}: ${error instanceof Error ? error.message : "Unknown error"}`);
-      throw new ForbiddenException({
-        errors: [
-          {
-            field: "csrf",
-            message: "Invalid or missing CSRF token"
-          }
-        ],
-        message: "CSRF validation failed"
-      });
-    }
+  database;
+  table;
+  logger;
+  /**
+  * 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 db() {
+    return this.database.drizzleClient;
   }
-};
-CsrfGuard = _ts_decorate11([
-  Injectable8(),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", [
-    typeof Reflector3 === "undefined" ? Object : Reflector3
-  ])
-], CsrfGuard);
-
-// src/http/http.module.ts
-function _ts_decorate12(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_decorate12, "_ts_decorate");
-var HttpModule = class {
-  static {
-    __name(this, "HttpModule");
+  /**
+  * 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.database.drizzleClient.query[this.tableName];
   }
-};
-HttpModule = _ts_decorate12([
-  Module4({
-    providers: [
-      CsrfGuard
-    ],
-    exports: [
-      CsrfGuard
-    ]
-  })
-], HttpModule);
-
-// src/filters/http-exception.filter.ts
-import { Catch, HttpException, HttpStatus, Logger as Logger9 } from "@nestjs/common";
-function _ts_decorate13(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_decorate13, "_ts_decorate");
-function getHttpStatusTitle(status) {
-  const enumKey = Object.entries(HttpStatus).find(([key, value]) => value === status && isNaN(Number(key)))?.[0];
-  if (!enumKey) {
-    return "Error";
+  /**
+  * Create a new repository instance
+  *
+  * @param database - The tenant database service
+  * @param table - The Drizzle table schema object
+  *
+  * @example
+  * ```typescript
+  * import { products } from '@/db/schema';
+  *
+  * constructor(database: TenantDatabaseService) {
+  *   super(database, products);
+  * }
+  * ```
+  */
+  constructor(database, table) {
+    this.database = database;
+    this.table = table;
+    this.tableName = getTableName2(table);
+    this.logger = new Logger8(this.constructor.name);
+    this.logger.debug(`Initialized ${this.constructor.name}`);
   }
-  return enumKey.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
-}
-__name(getHttpStatusTitle, "getHttpStatusTitle");
-var HttpExceptionFilter = class _HttpExceptionFilter {
-  static {
-    __name(this, "HttpExceptionFilter");
+  /**
+  * Create a new record
+  *
+  * @param data - The data to create the record with
+  * @returns Promise resolving to the created record
+  *
+  * @example
+  * ```typescript
+  * const product = await productRepository.create({
+  *   name: 'Widget',
+  *   sku: 'WDG-001',
+  *   price: 9.99
+  * });
+  * ```
+  */
+  async create(data) {
+    this.logger.log("Creating record");
+    const results = await this.db.insert(this.table).values(data).returning();
+    return results[0];
   }
-  logger = new Logger9(_HttpExceptionFilter.name);
-  catch(exception, host) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse();
-    let status = HttpStatus.INTERNAL_SERVER_ERROR;
-    let errors = [];
-    let detail = "Internal server error";
-    if (exception instanceof HttpException) {
-      status = exception.getStatus();
-      const exceptionResponse = exception.getResponse();
-      if (typeof exceptionResponse === "object" && exceptionResponse !== null) {
-        const responseObj = exceptionResponse;
-        if ("errors" in responseObj && Array.isArray(responseObj.errors)) {
-          errors = responseObj.errors;
-          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" && "property" in msg && "constraints" in msg) {
-              const constraintValues = Object.values(msg.constraints);
-              return {
-                field: msg.property,
-                message: constraintValues[0] ?? "Validation failed"
-              };
-            }
-            return {
-              message: typeof msg === "string" ? msg : JSON.stringify(msg)
-            };
-          });
-          detail = "Validation failed";
-        } else if ("message" in responseObj) {
-          const message = responseObj.message;
-          errors = [
-            {
-              message: Array.isArray(message) ? message.join(", ") : message
-            }
-          ];
-          detail = ("error" in responseObj ? responseObj.error : void 0) || exception.message;
-        }
-      } else if (typeof exceptionResponse === "string") {
-        errors = [
-          {
-            message: exceptionResponse
-          }
-        ];
-        detail = exceptionResponse;
-      }
-    } else {
-      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"
-        }
-      ];
+  /**
+  * Find a single record by ID
+  *
+  * @param id - The record ID
+  * @returns Promise resolving to the record or null if not found
+  *
+  * @example
+  * ```typescript
+  * const product = await productRepository.findById('product-id-123');
+  * ```
+  */
+  async findById(id) {
+    this.logger.debug(`Finding record by ID: ${id}`);
+    const idColumn = this.table.id;
+    const results = await this.db.select().from(this.table).where(eq3(idColumn, id)).limit(1);
+    return results[0] ?? null;
+  }
+  /**
+  * Find a single record with custom where clause
+  *
+  * @param where - SQL condition
+  * @returns Promise resolving to the record or null if not found
+  *
+  * @example
+  * ```typescript
+  * 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");
+    const results = await this.db.select().from(this.table).where(where).limit(1);
+    return results[0] ?? null;
+  }
+  /**
+  * Find multiple records
+  *
+  * @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: eq(products.status, 'ACTIVE'),
+  *   orderBy: desc(products.createdAt),
+  *   limit: 10,
+  *   offset: 0
+  * });
+  * ```
+  */
+  async findMany(options) {
+    this.logger.debug("Finding multiple records");
+    let query = this.db.select().from(this.table).$dynamic();
+    if (options?.where) {
+      query = query.where(options.where);
     }
-    const problemDetails = {
-      title: getHttpStatusTitle(status),
-      status,
-      detail,
-      errors
+    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
+  *
+  * @param id - The record ID
+  * @param data - The data to update
+  * @returns Promise resolving to the updated record
+  *
+  * @example
+  * ```typescript
+  * const product = await productRepository.update('product-id-123', {
+  *   price: 12.99
+  * });
+  * ```
+  */
+  async update(id, data) {
+    this.logger.log(`Updating record with ID: ${id}`);
+    const idColumn = this.table.id;
+    const results = await this.db.update(this.table).set(data).where(eq3(idColumn, id)).returning();
+    return results[0];
+  }
+  /**
+  * Update multiple 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(
+  *   eq(products.status, 'PENDING'),
+  *   { status: 'ACTIVE' }
+  * );
+  * console.log(`Updated ${result.count} products`);
+  * ```
+  */
+  async updateMany(where, data) {
+    this.logger.log("Updating multiple records");
+    const result = await this.db.update(this.table).set(data).where(where);
+    return {
+      count: result.rowCount ?? 0
     };
-    response.status(status).send(problemDetails);
+  }
+  /**
+  * Delete a record by ID
+  *
+  * @param id - The record ID
+  * @returns Promise resolving to the deleted record
+  *
+  * @example
+  * ```typescript
+  * const product = await productRepository.delete('product-id-123');
+  * ```
+  */
+  async delete(id) {
+    this.logger.log(`Deleting record with ID: ${id}`);
+    const idColumn = this.table.id;
+    const results = await this.db.delete(this.table).where(eq3(idColumn, id)).returning();
+    return results[0];
+  }
+  /**
+  * Delete multiple records
+  *
+  * @param where - SQL condition to match records
+  * @returns Promise resolving to the count of deleted records
+  *
+  * @example
+  * ```typescript
+  * 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");
+    const result = await this.db.delete(this.table).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
+  }
+  /**
+  * Count 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(
+  *   eq(products.status, 'ACTIVE')
+  * );
+  * ```
+  */
+  async count(where) {
+    this.logger.debug("Counting records");
+    let query = this.db.select({
+      count: sql2`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 - SQL condition to match records
+  * @returns Promise resolving to true if at least one record exists, false otherwise
+  *
+  * @example
+  * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
+  * const skuExists = await productRepository.exists(
+  *   eq(products.sku, 'WDG-001')
+  * );
+  * ```
+  */
+  async exists(where) {
+    const count = await this.count(where);
+    return count > 0;
   }
 };
-HttpExceptionFilter = _ts_decorate13([
-  Catch()
-], HttpExceptionFilter);
+
+// src/exceptions/bad-gateway.exception.ts
+import { HttpStatus as HttpStatus2 } from "@nestjs/common";
 
 // src/exceptions/base-field.exception.ts
-import { HttpException as HttpException2, HttpStatus as HttpStatus2 } from "@nestjs/common";
-var BaseFieldException = class extends HttpException2 {
+import { HttpException, HttpStatus } from "@nestjs/common";
+var BaseFieldException = class extends HttpException {
   static {
     __name(this, "BaseFieldException");
   }
@@ -2043,7 +1914,7 @@ var BaseFieldException = class extends HttpException2 {
     let finalDetail;
     if (Array.isArray(statusOrMessageOrErrors)) {
       errors = statusOrMessageOrErrors;
-      httpStatus = messageOrStatus || HttpStatus2.BAD_REQUEST;
+      httpStatus = messageOrStatus || HttpStatus.BAD_REQUEST;
       finalDetail = typeof statusOrDetail === "string" ? statusOrDetail : void 0;
     } else if (typeof statusOrMessageOrErrors === "string" && typeof messageOrStatus === "string") {
       errors = [
@@ -2081,8 +1952,26 @@ var BaseFieldException = class extends HttpException2 {
   }
 };
 
-// src/exceptions/bad-request.exception.ts
-import { HttpStatus as HttpStatus3 } from "@nestjs/common";
+// src/exceptions/bad-gateway.exception.ts
+var BadGatewayException = class extends BaseFieldException {
+  static {
+    __name(this, "BadGatewayException");
+  }
+  constructor(messageOrField, fieldMessageOrDetail, detail) {
+    if (Array.isArray(messageOrField)) {
+      super(messageOrField, HttpStatus2.BAD_GATEWAY, fieldMessageOrDetail);
+    } else if (detail !== void 0) {
+      super(messageOrField, fieldMessageOrDetail, HttpStatus2.BAD_GATEWAY, detail);
+    } else if (fieldMessageOrDetail) {
+      super(messageOrField, fieldMessageOrDetail, HttpStatus2.BAD_GATEWAY);
+    } else {
+      super(messageOrField, HttpStatus2.BAD_GATEWAY);
+    }
+  }
+};
+
+// src/exceptions/bad-request.exception.ts
+import { HttpStatus as HttpStatus3 } from "@nestjs/common";
 var BadRequestException = class extends BaseFieldException {
   static {
     __name(this, "BadRequestException");
@@ -2100,28 +1989,28 @@ var BadRequestException = class extends BaseFieldException {
   }
 };
 
-// src/exceptions/unauthorized.exception.ts
+// src/exceptions/conflict.exception.ts
 import { HttpStatus as HttpStatus4 } from "@nestjs/common";
-var UnauthorizedException4 = class extends BaseFieldException {
+var ConflictException = class extends BaseFieldException {
   static {
-    __name(this, "UnauthorizedException");
+    __name(this, "ConflictException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus4.UNAUTHORIZED, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus4.CONFLICT, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus4.UNAUTHORIZED, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus4.CONFLICT, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus4.UNAUTHORIZED);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus4.CONFLICT);
     } else {
-      super(messageOrField, HttpStatus4.UNAUTHORIZED);
+      super(messageOrField, HttpStatus4.CONFLICT);
     }
   }
 };
 
 // src/exceptions/forbidden.exception.ts
 import { HttpStatus as HttpStatus5 } from "@nestjs/common";
-var ForbiddenException2 = class extends BaseFieldException {
+var ForbiddenException = class extends BaseFieldException {
   static {
     __name(this, "ForbiddenException");
   }
@@ -2138,222 +2027,230 @@ var ForbiddenException2 = class extends BaseFieldException {
   }
 };
 
-// src/exceptions/not-found.exception.ts
+// src/exceptions/gone.exception.ts
 import { HttpStatus as HttpStatus6 } from "@nestjs/common";
-var NotFoundException = class extends BaseFieldException {
+var GoneException = class extends BaseFieldException {
   static {
-    __name(this, "NotFoundException");
+    __name(this, "GoneException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus6.NOT_FOUND, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus6.GONE, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus6.NOT_FOUND, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus6.GONE, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus6.NOT_FOUND);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus6.GONE);
     } else {
-      super(messageOrField, HttpStatus6.NOT_FOUND);
+      super(messageOrField, HttpStatus6.GONE);
     }
   }
 };
 
-// src/exceptions/conflict.exception.ts
+// src/exceptions/internal-server-error.exception.ts
 import { HttpStatus as HttpStatus7 } from "@nestjs/common";
-var ConflictException = class extends BaseFieldException {
+var InternalServerErrorException3 = class extends BaseFieldException {
   static {
-    __name(this, "ConflictException");
+    __name(this, "InternalServerErrorException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus7.CONFLICT, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus7.INTERNAL_SERVER_ERROR, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus7.CONFLICT, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus7.INTERNAL_SERVER_ERROR, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus7.CONFLICT);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus7.INTERNAL_SERVER_ERROR);
     } else {
-      super(messageOrField, HttpStatus7.CONFLICT);
+      super(messageOrField, HttpStatus7.INTERNAL_SERVER_ERROR);
     }
   }
 };
 
-// src/exceptions/internal-server-error.exception.ts
+// src/exceptions/method-not-allowed.exception.ts
 import { HttpStatus as HttpStatus8 } from "@nestjs/common";
-var InternalServerErrorException3 = class extends BaseFieldException {
+var MethodNotAllowedException = class extends BaseFieldException {
   static {
-    __name(this, "InternalServerErrorException");
+    __name(this, "MethodNotAllowedException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus8.INTERNAL_SERVER_ERROR, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus8.METHOD_NOT_ALLOWED, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus8.INTERNAL_SERVER_ERROR, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus8.METHOD_NOT_ALLOWED, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus8.INTERNAL_SERVER_ERROR);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus8.METHOD_NOT_ALLOWED);
     } else {
-      super(messageOrField, HttpStatus8.INTERNAL_SERVER_ERROR);
+      super(messageOrField, HttpStatus8.METHOD_NOT_ALLOWED);
     }
   }
 };
 
-// src/exceptions/validation.exception.ts
+// src/exceptions/not-acceptable.exception.ts
 import { HttpStatus as HttpStatus9 } from "@nestjs/common";
-var ValidationException = class extends BaseFieldException {
+var NotAcceptableException = class extends BaseFieldException {
   static {
-    __name(this, "ValidationException");
+    __name(this, "NotAcceptableException");
   }
-  constructor(errors, detail) {
-    super(errors, HttpStatus9.BAD_REQUEST, detail);
+  constructor(messageOrField, fieldMessageOrDetail, detail) {
+    if (Array.isArray(messageOrField)) {
+      super(messageOrField, HttpStatus9.NOT_ACCEPTABLE, fieldMessageOrDetail);
+    } else if (detail !== void 0) {
+      super(messageOrField, fieldMessageOrDetail, HttpStatus9.NOT_ACCEPTABLE, detail);
+    } else if (fieldMessageOrDetail) {
+      super(messageOrField, fieldMessageOrDetail, HttpStatus9.NOT_ACCEPTABLE);
+    } else {
+      super(messageOrField, HttpStatus9.NOT_ACCEPTABLE);
+    }
   }
 };
 
-// src/exceptions/unprocessable-entity.exception.ts
+// src/exceptions/not-found.exception.ts
 import { HttpStatus as HttpStatus10 } from "@nestjs/common";
-var UnprocessableEntityException = class extends BaseFieldException {
+var NotFoundException = class extends BaseFieldException {
   static {
-    __name(this, "UnprocessableEntityException");
+    __name(this, "NotFoundException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus10.UNPROCESSABLE_ENTITY, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus10.NOT_FOUND, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus10.UNPROCESSABLE_ENTITY, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus10.NOT_FOUND, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus10.UNPROCESSABLE_ENTITY);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus10.NOT_FOUND);
     } else {
-      super(messageOrField, HttpStatus10.UNPROCESSABLE_ENTITY);
+      super(messageOrField, HttpStatus10.NOT_FOUND);
     }
   }
 };
 
-// src/exceptions/too-many-requests.exception.ts
+// src/exceptions/not-implemented.exception.ts
 import { HttpStatus as HttpStatus11 } from "@nestjs/common";
-var TooManyRequestsException = class extends BaseFieldException {
+var NotImplementedException = class extends BaseFieldException {
   static {
-    __name(this, "TooManyRequestsException");
+    __name(this, "NotImplementedException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus11.TOO_MANY_REQUESTS, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus11.NOT_IMPLEMENTED, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus11.TOO_MANY_REQUESTS, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus11.NOT_IMPLEMENTED, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus11.TOO_MANY_REQUESTS);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus11.NOT_IMPLEMENTED);
     } else {
-      super(messageOrField, HttpStatus11.TOO_MANY_REQUESTS);
+      super(messageOrField, HttpStatus11.NOT_IMPLEMENTED);
     }
   }
 };
 
-// src/exceptions/service-unavailable.exception.ts
+// src/exceptions/payload-too-large.exception.ts
 import { HttpStatus as HttpStatus12 } from "@nestjs/common";
-var ServiceUnavailableException = class extends BaseFieldException {
+var PayloadTooLargeException = class extends BaseFieldException {
   static {
-    __name(this, "ServiceUnavailableException");
+    __name(this, "PayloadTooLargeException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus12.SERVICE_UNAVAILABLE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus12.PAYLOAD_TOO_LARGE, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus12.SERVICE_UNAVAILABLE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus12.PAYLOAD_TOO_LARGE, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus12.SERVICE_UNAVAILABLE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus12.PAYLOAD_TOO_LARGE);
     } else {
-      super(messageOrField, HttpStatus12.SERVICE_UNAVAILABLE);
+      super(messageOrField, HttpStatus12.PAYLOAD_TOO_LARGE);
     }
   }
 };
 
-// src/exceptions/method-not-allowed.exception.ts
+// src/exceptions/request-timeout.exception.ts
 import { HttpStatus as HttpStatus13 } from "@nestjs/common";
-var MethodNotAllowedException = class extends BaseFieldException {
+var RequestTimeoutException = class extends BaseFieldException {
   static {
-    __name(this, "MethodNotAllowedException");
+    __name(this, "RequestTimeoutException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus13.METHOD_NOT_ALLOWED, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus13.REQUEST_TIMEOUT, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus13.METHOD_NOT_ALLOWED, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus13.REQUEST_TIMEOUT, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus13.METHOD_NOT_ALLOWED);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus13.REQUEST_TIMEOUT);
     } else {
-      super(messageOrField, HttpStatus13.METHOD_NOT_ALLOWED);
+      super(messageOrField, HttpStatus13.REQUEST_TIMEOUT);
     }
   }
 };
 
-// src/exceptions/gone.exception.ts
+// src/exceptions/service-unavailable.exception.ts
 import { HttpStatus as HttpStatus14 } from "@nestjs/common";
-var GoneException = class extends BaseFieldException {
+var ServiceUnavailableException = class extends BaseFieldException {
   static {
-    __name(this, "GoneException");
+    __name(this, "ServiceUnavailableException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus14.GONE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus14.SERVICE_UNAVAILABLE, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus14.GONE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus14.SERVICE_UNAVAILABLE, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus14.GONE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus14.SERVICE_UNAVAILABLE);
     } else {
-      super(messageOrField, HttpStatus14.GONE);
+      super(messageOrField, HttpStatus14.SERVICE_UNAVAILABLE);
     }
   }
 };
 
-// src/exceptions/not-acceptable.exception.ts
+// src/exceptions/too-many-requests.exception.ts
 import { HttpStatus as HttpStatus15 } from "@nestjs/common";
-var NotAcceptableException = class extends BaseFieldException {
+var TooManyRequestsException = class extends BaseFieldException {
   static {
-    __name(this, "NotAcceptableException");
+    __name(this, "TooManyRequestsException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus15.NOT_ACCEPTABLE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus15.TOO_MANY_REQUESTS, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus15.NOT_ACCEPTABLE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus15.TOO_MANY_REQUESTS, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus15.NOT_ACCEPTABLE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus15.TOO_MANY_REQUESTS);
     } else {
-      super(messageOrField, HttpStatus15.NOT_ACCEPTABLE);
+      super(messageOrField, HttpStatus15.TOO_MANY_REQUESTS);
     }
   }
 };
 
-// src/exceptions/request-timeout.exception.ts
+// src/exceptions/unauthorized.exception.ts
 import { HttpStatus as HttpStatus16 } from "@nestjs/common";
-var RequestTimeoutException = class extends BaseFieldException {
+var UnauthorizedException4 = class extends BaseFieldException {
   static {
-    __name(this, "RequestTimeoutException");
+    __name(this, "UnauthorizedException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus16.REQUEST_TIMEOUT, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus16.UNAUTHORIZED, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus16.REQUEST_TIMEOUT, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus16.UNAUTHORIZED, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus16.REQUEST_TIMEOUT);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus16.UNAUTHORIZED);
     } else {
-      super(messageOrField, HttpStatus16.REQUEST_TIMEOUT);
+      super(messageOrField, HttpStatus16.UNAUTHORIZED);
     }
   }
 };
 
-// src/exceptions/payload-too-large.exception.ts
+// src/exceptions/unprocessable-entity.exception.ts
 import { HttpStatus as HttpStatus17 } from "@nestjs/common";
-var PayloadTooLargeException = class extends BaseFieldException {
+var UnprocessableEntityException = class extends BaseFieldException {
   static {
-    __name(this, "PayloadTooLargeException");
+    __name(this, "UnprocessableEntityException");
   }
   constructor(messageOrField, fieldMessageOrDetail, detail) {
     if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus17.PAYLOAD_TOO_LARGE, fieldMessageOrDetail);
+      super(messageOrField, HttpStatus17.UNPROCESSABLE_ENTITY, fieldMessageOrDetail);
     } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus17.PAYLOAD_TOO_LARGE, detail);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus17.UNPROCESSABLE_ENTITY, detail);
     } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus17.PAYLOAD_TOO_LARGE);
+      super(messageOrField, fieldMessageOrDetail, HttpStatus17.UNPROCESSABLE_ENTITY);
     } else {
-      super(messageOrField, HttpStatus17.PAYLOAD_TOO_LARGE);
+      super(messageOrField, HttpStatus17.UNPROCESSABLE_ENTITY);
     }
   }
 };
@@ -2377,103 +2274,445 @@ var UnsupportedMediaTypeException = class extends BaseFieldException {
   }
 };
 
-// src/exceptions/not-implemented.exception.ts
+// src/exceptions/validation.exception.ts
 import { HttpStatus as HttpStatus19 } from "@nestjs/common";
-var NotImplementedException = class extends BaseFieldException {
+var ValidationException = class extends BaseFieldException {
   static {
-    __name(this, "NotImplementedException");
+    __name(this, "ValidationException");
   }
-  constructor(messageOrField, fieldMessageOrDetail, detail) {
-    if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus19.NOT_IMPLEMENTED, fieldMessageOrDetail);
-    } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus19.NOT_IMPLEMENTED, detail);
-    } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus19.NOT_IMPLEMENTED);
+  constructor(errors, detail) {
+    super(errors, HttpStatus19.BAD_REQUEST, detail);
+  }
+};
+
+// src/filters/http-exception.filter.ts
+import { Catch, HttpException as HttpException2, HttpStatus as HttpStatus20, Logger as Logger9 } from "@nestjs/common";
+function _ts_decorate11(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_decorate11, "_ts_decorate");
+function getHttpStatusTitle(status) {
+  const enumKey = Object.entries(HttpStatus20).find(([key, value]) => value === status && Number.isNaN(Number(key)))?.[0];
+  if (!enumKey) {
+    return "Error";
+  }
+  return enumKey.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+__name(getHttpStatusTitle, "getHttpStatusTitle");
+var HttpExceptionFilter = class _HttpExceptionFilter {
+  static {
+    __name(this, "HttpExceptionFilter");
+  }
+  logger = new Logger9(_HttpExceptionFilter.name);
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    let status = HttpStatus20.INTERNAL_SERVER_ERROR;
+    let errors = [];
+    let detail = "Internal server error";
+    if (exception instanceof HttpException2) {
+      status = exception.getStatus();
+      const exceptionResponse = exception.getResponse();
+      if (typeof exceptionResponse === "object" && exceptionResponse !== null) {
+        const responseObj = exceptionResponse;
+        if ("errors" in responseObj && Array.isArray(responseObj.errors)) {
+          errors = responseObj.errors;
+          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" && "property" in msg && "constraints" in msg) {
+              const constraintValues = Object.values(msg.constraints);
+              return {
+                field: msg.property,
+                message: constraintValues[0] ?? "Validation failed"
+              };
+            }
+            return {
+              message: typeof msg === "string" ? msg : JSON.stringify(msg)
+            };
+          });
+          detail = "Validation failed";
+        } else if ("message" in responseObj) {
+          const message = responseObj.message;
+          errors = [
+            {
+              message: Array.isArray(message) ? message.join(", ") : message
+            }
+          ];
+          detail = ("error" in responseObj ? responseObj.error : void 0) || exception.message;
+        }
+      } else if (typeof exceptionResponse === "string") {
+        errors = [
+          {
+            message: exceptionResponse
+          }
+        ];
+        detail = exceptionResponse;
+      }
     } else {
-      super(messageOrField, HttpStatus19.NOT_IMPLEMENTED);
+      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"
+        }
+      ];
     }
+    const problemDetails = {
+      title: getHttpStatusTitle(status),
+      status,
+      detail,
+      errors
+    };
+    response.status(status).send(problemDetails);
   }
 };
+HttpExceptionFilter = _ts_decorate11([
+  Catch()
+], HttpExceptionFilter);
 
-// src/exceptions/bad-gateway.exception.ts
-import { HttpStatus as HttpStatus20 } from "@nestjs/common";
-var BadGatewayException = class extends BaseFieldException {
+// src/http/guards/csrf.guard.ts
+import { ForbiddenException as ForbiddenException2, Injectable as Injectable8, Logger as Logger10 } from "@nestjs/common";
+function _ts_decorate12(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_decorate12, "_ts_decorate");
+var CsrfGuard = class _CsrfGuard {
   static {
-    __name(this, "BadGatewayException");
+    __name(this, "CsrfGuard");
   }
-  constructor(messageOrField, fieldMessageOrDetail, detail) {
-    if (Array.isArray(messageOrField)) {
-      super(messageOrField, HttpStatus20.BAD_GATEWAY, fieldMessageOrDetail);
-    } else if (detail !== void 0) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus20.BAD_GATEWAY, detail);
-    } else if (fieldMessageOrDetail) {
-      super(messageOrField, fieldMessageOrDetail, HttpStatus20.BAD_GATEWAY);
-    } else {
-      super(messageOrField, HttpStatus20.BAD_GATEWAY);
+  logger = new Logger10(_CsrfGuard.name);
+  async canActivate(context) {
+    const request = context.switchToHttp().getRequest();
+    const reply = context.switchToHttp().getResponse();
+    const safeMethods = [
+      "GET",
+      "HEAD",
+      "OPTIONS"
+    ];
+    if (safeMethods.includes(request.method)) {
+      return true;
+    }
+    try {
+      const fastifyInstance = request.server;
+      if (!fastifyInstance.csrfProtection) {
+        this.logger.error("CSRF protection plugin not found. Ensure @fastify/csrf-protection is registered.");
+        throw new ForbiddenException2("CSRF protection not configured");
+      }
+      await new Promise((resolve, reject) => {
+        fastifyInstance.csrfProtection(request, reply, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+      this.logger.debug(`CSRF validation successful for ${request.method} ${request.url}`);
+      return true;
+    } catch (error) {
+      this.logger.warn(`CSRF validation failed for ${request.method} ${request.url}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      throw new ForbiddenException2({
+        errors: [
+          {
+            field: "csrf",
+            message: "Invalid or missing CSRF token"
+          }
+        ],
+        message: "CSRF validation failed"
+      });
+    }
+  }
+};
+CsrfGuard = _ts_decorate12([
+  Injectable8()
+], CsrfGuard);
+
+// src/http/http.module.ts
+import { Module as Module4 } from "@nestjs/common";
+function _ts_decorate13(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_decorate13, "_ts_decorate");
+var HttpModule = class {
+  static {
+    __name(this, "HttpModule");
+  }
+};
+HttpModule = _ts_decorate13([
+  Module4({
+    providers: [
+      CsrfGuard
+    ],
+    exports: [
+      CsrfGuard
+    ]
+  })
+], HttpModule);
+
+// src/logger/interceptors/http-logger.interceptor.ts
+import { Injectable as Injectable9, Optional } from "@nestjs/common";
+import { catchError, tap as tap2 } from "rxjs/operators";
+
+// src/logger/utils/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+var correlationStorage = new 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 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/interceptors/http-logger.interceptor.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_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_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(tap2(() => {
+      if (this.enableResponseLog) {
+        const duration = Date.now() - startTime;
+        this.logResponse(request, response, duration);
+      }
+    }), 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_decorate14([
+  Injectable9(),
+  _ts_param4(1, Optional()),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof LoggerService === "undefined" ? Object : LoggerService,
+    typeof HttpLoggerOptions === "undefined" ? Object : HttpLoggerOptions
+  ])
+], HttpLoggerInterceptor);
+
+// src/logger/logger.module.ts
+import { Global as Global4, Logger as Logger11, Module as Module5 } from "@nestjs/common";
+
+// src/logger/middleware/correlation-id.middleware.ts
+import { Injectable as Injectable10 } from "@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_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_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
+      });
     }
   }
 };
-
-// src/logger/logger.module.ts
-import { Global as Global4, Module as Module5, Logger as Logger11 } from "@nestjs/common";
+CorrelationIdMiddleware = _ts_decorate15([
+  Injectable10(),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof CorrelationIdMiddlewareOptions === "undefined" ? Object : CorrelationIdMiddlewareOptions
+  ])
+], CorrelationIdMiddleware);
 
 // src/logger/services/logger.service.ts
-import { Injectable as Injectable9, Logger as Logger10, Optional } from "@nestjs/common";
+import { Injectable as Injectable11, Optional as Optional2 } from "@nestjs/common";
 import { createLogger, format, transports } from "winston";
 import DailyRotateFile from "winston-daily-rotate-file";
-
-// src/logger/utils/index.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID } from "crypto";
-var correlationStorage = new 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 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) {
+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_decorate14, "_ts_decorate");
-function _ts_metadata8(k, v) {
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata9(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) {
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
+__name(_ts_param5, "_ts_param");
 var LoggerService2 = class _LoggerService {
   static {
     __name(this, "LoggerService");
@@ -2526,7 +2765,8 @@ var LoggerService2 = class _LoggerService {
         ].filter(Boolean);
         let output = parts.join(" ");
         if (trace) {
-          output += "\n" + trace;
+          output += `
+${trace}`;
         }
         return output;
       }), format.colorize({
@@ -2674,210 +2914,16 @@ var LoggerService2 = class _LoggerService {
     return childLogger;
   }
 };
-LoggerService2 = _ts_decorate14([
-  Injectable9(),
-  _ts_param4(0, Optional()),
-  _ts_param4(1, Optional()),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
-    typeof LoggerModuleOptions === "undefined" ? Object : LoggerModuleOptions,
-    typeof Logger10 === "undefined" ? Object : Logger10
-  ])
-], LoggerService2);
-
-// src/logger/middleware/correlation-id.middleware.ts
-import { Injectable as Injectable10 } from "@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([
-  Injectable10(),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
-    typeof CorrelationIdMiddlewareOptions === "undefined" ? Object : CorrelationIdMiddlewareOptions
-  ])
-], CorrelationIdMiddleware);
-
-// src/logger/interceptors/http-logger.interceptor.ts
-import { Injectable as Injectable11, Optional as Optional2 } from "@nestjs/common";
-import { tap as tap2, catchError } from "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(tap2(() => {
-      if (this.enableResponseLog) {
-        const duration = Date.now() - startTime;
-        this.logResponse(request, response, duration);
-      }
-    }), 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([
+LoggerService2 = _ts_decorate16([
   Injectable11(),
+  _ts_param5(0, Optional2()),
   _ts_param5(1, Optional2()),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
-    typeof LoggerService === "undefined" ? Object : LoggerService,
-    typeof HttpLoggerOptions === "undefined" ? Object : HttpLoggerOptions
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof LoggerModuleOptions === "undefined" ? Object : LoggerModuleOptions,
+    typeof Logger === "undefined" ? Object : Logger
   ])
-], HttpLoggerInterceptor);
+], LoggerService2);
 
 // src/logger/logger.module.ts
 function _ts_decorate17(decorators, target, key, desc) {
@@ -3150,7 +3196,7 @@ var LoggerModule = class _LoggerModule {
   * ```
   */
   static forRootAsync(options) {
-    const asyncProviders = this.createAsyncProviders(options);
+    const asyncProviders = _LoggerModule.createAsyncProviders(options);
     return {
       module: _LoggerModule,
       imports: options.imports || [],
@@ -3226,7 +3272,7 @@ var LoggerModule = class _LoggerModule {
   * Configures middleware for the module.
   * Middleware is registered globally in main.ts using Fastify hooks.
   */
-  configure(consumer) {
+  configure(_consumer) {
   }
   /**
   * Creates async providers for dynamic module configuration.
@@ -3234,11 +3280,11 @@ var LoggerModule = class _LoggerModule {
   static createAsyncProviders(options) {
     if (options.useFactory) {
       return [
-        this.createAsyncOptionsProvider(options)
+        _LoggerModule.createAsyncOptionsProvider(options)
       ];
     }
     const providers = [
-      this.createAsyncOptionsProvider(options)
+      _LoggerModule.createAsyncOptionsProvider(options)
     ];
     if (options.useClass) {
       providers.push({
@@ -3256,7 +3302,7 @@ var LoggerModule = class _LoggerModule {
       return {
         provide: LOGGER_MODULE_OPTIONS,
         useFactory: /* @__PURE__ */ __name(async (...args) => {
-          const userOptions = await options.useFactory(...args);
+          const userOptions = await options.useFactory?.(...args);
           return mergeWithDefaults(userOptions);
         }, "useFactory"),
         inject: options.inject || []
@@ -3303,7 +3349,7 @@ export {
   CsrfGuard,
   DEFAULT_CORRELATION_HEADER,
   DatabaseModule,
-  ForbiddenException2 as ForbiddenException,
+  ForbiddenException,
   GoneException,
   HttpExceptionFilter,
   HttpLoggerInterceptor,
@@ -3319,13 +3365,13 @@ export {
   Onboarding,
   PayloadTooLargeException,
   PrimaryBaseRepository,
-  PrimaryDatabaseService,
+  PrimaryDatabaseService2 as PrimaryDatabaseService,
   Public,
   RequestTimeoutException,
   ServiceUnavailableException,
   Tenant,
   TenantBaseRepository,
-  TenantContextService,
+  TenantContextService2 as TenantContextService,
   TenantDatabaseService,
   TooManyRequestsException,
   UnauthorizedException4 as UnauthorizedException,
@@ -3334,11 +3380,19 @@ export {
   ValidationException,
   VrittiAuthGuard,
   addCorrelationIdToResponse,
+  configureApiSdk,
   correlationStorage,
+  defineConfig,
   generateCorrelationId,
+  getConfig,
   getCorrelationContext,
   getHttpStatusTitle,
+  getJwtExpiry,
+  getRefreshCookieOptions,
+  hashToken,
+  resetConfig,
   runWithCorrelationContext,
-  updateCorrelationContext
+  updateCorrelationContext,
+  verifyTokenHash
 };
 //# sourceMappingURL=index.js.map