@vritti/api-sdk 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -21,14 +21,833 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  getHello: () => getHello
+  DatabaseModule: () => DatabaseModule,
+  MessageTenantContextInterceptor: () => MessageTenantContextInterceptor,
+  PrimaryDatabaseService: () => PrimaryDatabaseService,
+  Tenant: () => Tenant,
+  TenantContextInterceptor: () => TenantContextInterceptor,
+  TenantContextService: () => TenantContextService,
+  TenantDatabaseService: () => TenantDatabaseService,
+  extractSubdomain: () => extractSubdomain
 });
 module.exports = __toCommonJS(index_exports);
-var getHello = /* @__PURE__ */ __name(() => {
-  return "Hello, World!";
-}, "getHello");
+
+// src/database/database.module.ts
+var import_common4 = require("@nestjs/common");
+
+// src/database/constants.ts
+var DATABASE_MODULE_OPTIONS = Symbol("DATABASE_MODULE_OPTIONS");
+
+// src/database/services/primary-database.service.ts
+var import_common = require("@nestjs/common");
+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);
+  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_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var PrimaryDatabaseService = class _PrimaryDatabaseService {
+  static {
+    __name(this, "PrimaryDatabaseService");
+  }
+  options;
+  logger = new import_common.Logger(_PrimaryDatabaseService.name);
+  /** Primary database client for querying tenant registry */
+  primaryDbClient;
+  /** 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.initializePrimaryDbClient();
+    }
+  }
+  /**
+  * Initialize connection to primary database
+  */
+  async initializePrimaryDbClient() {
+    try {
+      const PrimaryDbClient = this.options.prismaClientConstructor;
+      const databaseUrl = this.buildPrimaryDbUrl();
+      this.primaryDbClient = new PrimaryDbClient({
+        datasources: {
+          db: {
+            url: databaseUrl
+          }
+        },
+        log: [
+          "error",
+          "warn"
+        ]
+      });
+      await this.primaryDbClient.$connect();
+      this.logger.log("Connected to primary database (tenant registry)");
+    } catch (error) {
+      this.logger.error("Failed to connect to primary database", error);
+      throw new import_common.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}:${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 slug)
+  *
+  * @param tenantIdentifier Tenant ID or slug
+  * @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.primaryDbClient) {
+        throw new Error("Primary database client not initialized");
+      }
+      this.logger.debug(`Querying primary database for tenant: ${tenantIdentifier}`);
+      const tenant = await this.primaryDbClient.tenant.findFirst({
+        where: {
+          OR: [
+            {
+              id: tenantIdentifier
+            },
+            {
+              subDomain: tenantIdentifier
+            }
+          ],
+          status: "ACTIVE"
+        }
+      });
+      if (!tenant) {
+        this.logger.warn(`Tenant not found: ${tenantIdentifier}`);
+        return null;
+      }
+      const info = {
+        id: tenant.id,
+        subdomain: tenant.subdomain,
+        type: tenant.type,
+        status: tenant.status,
+        schemaName: tenant.schemaName || void 0,
+        databaseName: tenant.databaseName || void 0,
+        databaseHost: tenant.databaseHost || void 0,
+        databasePort: tenant.databasePort || void 0,
+        databaseUsername: tenant.databaseUsername ? this.decrypt(tenant.databaseUsername) : void 0,
+        databasePassword: tenant.databasePassword ? this.decrypt(tenant.databasePassword) : void 0,
+        databaseSslMode: tenant.databaseSslMode || void 0,
+        connectionPoolSize: tenant.connectionPoolSize || void 0
+      };
+      this.cacheInfo(info);
+      return info;
+    } catch (error) {
+      this.logger.error(`Failed to fetch tenant info: ${tenantIdentifier}`, error);
+      throw new import_common.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 slug
+  */
+  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 primary database client for direct database access
+  *
+  * This is useful for platform admin operations (creating tenants, billing, etc.)
+  *
+  * @returns Primary database client instance
+  * @throws Error if primary database client is not initialized
+  */
+  getPrimaryDbClient() {
+    if (!this.primaryDbClient) {
+      throw new Error("Primary database client not initialized. Are you in gateway mode?");
+    }
+    return this.primaryDbClient;
+  }
+  /**
+  * 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.primaryDbClient) {
+      await this.primaryDbClient.$disconnect();
+      this.logger.log("Disconnected from primary database");
+    }
+  }
+};
+PrimaryDatabaseService = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_param(0, (0, import_common.Inject)(DATABASE_MODULE_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions
+  ])
+], PrimaryDatabaseService);
+
+// src/database/services/tenant-context.service.ts
+var import_common2 = require("@nestjs/common");
+function _ts_decorate2(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_decorate2, "_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 import_common2.UnauthorizedException("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_decorate2([
+  (0, import_common2.Injectable)({
+    scope: import_common2.Scope.REQUEST
+  })
+], TenantContextService);
+
+// src/database/services/tenant-database.service.ts
+var import_common3 = require("@nestjs/common");
+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);
+  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_decorate3, "_ts_decorate");
+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 TenantDatabaseService = class _TenantDatabaseService {
+  static {
+    __name(this, "TenantDatabaseService");
+  }
+  options;
+  tenantContext;
+  logger = new import_common3.Logger(_TenantDatabaseService.name);
+  /** Connection pool: Map<cacheKey, DbClient> */
+  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();
+  }
+  /**
+  * 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 Promise<Database client instance>
+  * @throws UnauthorizedException if tenant context not set
+  * @throws InternalServerErrorException if connection fails
+  *
+  * @example
+  * const dbClient = await tenantDatabase.getDbClient<PrismaClient>();
+  * const users = await dbClient.user.findMany();
+  */
+  async getDbClient() {
+    const tenant = this.tenantContext.getTenant();
+    const cacheKey = this.buildCacheKey(tenant);
+    if (this.clients.has(cacheKey)) {
+      this.clientLastUsed.set(cacheKey, Date.now());
+      this.logger.debug(`Reusing cached connection: ${cacheKey}`);
+      return this.clients.get(cacheKey);
+    }
+    this.logger.log(`Creating new database connection: ${cacheKey}`);
+    const client = await this.createDbClient(tenant);
+    this.clients.set(cacheKey, client);
+    this.clientLastUsed.set(cacheKey, Date.now());
+    return client;
+  }
+  /**
+  * Create a new database client for the given tenant
+  */
+  async createDbClient(tenant) {
+    try {
+      const databaseUrl = this.buildTenantDbUrl(tenant);
+      const PrismaClient = await this.options.prismaClientConstructor;
+      const client = new PrismaClient({
+        datasources: {
+          db: {
+            url: databaseUrl
+          }
+        },
+        log: [
+          "error",
+          "warn"
+        ]
+      });
+      await client.$connect();
+      this.logger.log(`Connected to database for tenant: ${tenant.subdomain}`);
+      return client;
+    } catch (error) {
+      this.logger.error(`Failed to create database connection for tenant: ${tenant.subdomain}`, error);
+      throw new import_common3.InternalServerErrorException("Failed to connect to tenant database");
+    }
+  }
+  /**
+  * Build connection URL for enterprise tenant (dedicated database)
+  */
+  buildTenantDbUrl(tenant) {
+    const { databaseHost, databasePort, databaseName, databaseUsername, databasePassword, databaseSslMode } = tenant;
+    if (!databaseHost || !databaseName || !databaseUsername) {
+      throw new Error(`Enterprise tenant ${tenant.subdomain} missing database configuration`);
+    }
+    const port = databasePort || 5432;
+    const sslMode = databaseSslMode || "require";
+    const connectionUrl = `postgresql://${databaseUsername}:${databasePassword}@${databaseHost}:${port}/${databaseName}?sslmode=${sslMode}`;
+    this.logger.debug(`Enterprise connection URL: ${this.maskPassword(connectionUrl)}`);
+    return connectionUrl;
+  }
+  /**
+  * Build cache key for connection pooling
+  */
+  buildCacheKey(tenant) {
+    return `${tenant.type}:${tenant.databaseName}@${tenant.databaseHost}`;
+  }
+  /**
+  * Start periodic cleanup of idle connections
+  */
+  startConnectionCleaner() {
+    const interval = this.options.connectionCacheTTL || 3e5;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupIdleConnections();
+    }, interval);
+    this.logger.log(`Connection cleanup scheduled every ${interval / 1e3} seconds`);
+  }
+  /**
+  * Clean up idle connections that haven't been used recently
+  */
+  cleanupIdleConnections() {
+    const now = Date.now();
+    const maxIdle = this.options.connectionCacheTTL || 3e5;
+    let cleaned = 0;
+    for (const [key, lastUsed] of this.clientLastUsed.entries()) {
+      if (now - lastUsed > maxIdle) {
+        const client = this.clients.get(key);
+        if (client) {
+          client.$disconnect().then(() => {
+            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 current connection pool statistics
+  */
+  getPoolStats() {
+    return {
+      activeConnections: this.clients.size,
+      tenants: Array.from(this.clients.keys())
+    };
+  }
+  /**
+  * Mask password in connection URL for logging
+  */
+  maskPassword(url) {
+    return url.replace(/:([^@]+)@/, ":****@");
+  }
+  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, client]) => {
+      try {
+        await client.$disconnect();
+        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_decorate3([
+  (0, import_common3.Injectable)(),
+  _ts_param2(0, (0, import_common3.Inject)(DATABASE_MODULE_OPTIONS)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions,
+    typeof TenantContextService === "undefined" ? Object : TenantContextService
+  ])
+], TenantDatabaseService);
+
+// src/database/database.module.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");
+var DatabaseModule = class _DatabaseModule {
+  static {
+    __name(this, "DatabaseModule");
+  }
+  /**
+  * Synchronous configuration
+  *
+  * @param options Module configuration options
+  * @returns Dynamic module configuration
+  */
+  static forRoot(options) {
+    const providers = [
+      {
+        provide: DATABASE_MODULE_OPTIONS,
+        useValue: options
+      },
+      TenantDatabaseService,
+      TenantContextService,
+      PrimaryDatabaseService
+    ];
+    return {
+      module: _DatabaseModule,
+      providers,
+      exports: [
+        TenantDatabaseService,
+        TenantContextService,
+        PrimaryDatabaseService
+      ]
+    };
+  }
+  /**
+  * Asynchronous configuration (recommended)
+  *
+  * Allows injecting ConfigService or other dependencies
+  *
+  * @param options Async configuration options
+  * @returns Dynamic module configuration
+  *
+  * @example
+  * DatabaseModule.forRootAsync({
+  *   imports: [ConfigModule],
+  *   useFactory: async (config: ConfigService) => ({
+  *     cloudDatabaseUrl: config.get('CLOUD_DATABASE_URL'),
+  *     prismaClientConstructor: PrismaClient,
+  *     tenantResolver: 'subdomain',
+  *   }),
+  *   inject: [ConfigService],
+  * })
+  */
+  static forRootAsync(options) {
+    const asyncProvider = {
+      provide: DATABASE_MODULE_OPTIONS,
+      useFactory: options.useFactory,
+      inject: options.inject || []
+    };
+    return {
+      module: _DatabaseModule,
+      providers: [
+        asyncProvider,
+        TenantContextService,
+        PrimaryDatabaseService,
+        TenantDatabaseService
+      ],
+      exports: [
+        TenantDatabaseService,
+        TenantContextService,
+        PrimaryDatabaseService,
+        asyncProvider
+      ]
+    };
+  }
+};
+DatabaseModule = _ts_decorate4([
+  (0, import_common4.Global)(),
+  (0, import_common4.Module)({})
+], DatabaseModule);
+
+// src/database/interceptors/message-tenant-context.interceptor.ts
+var import_common5 = require("@nestjs/common");
+var import_operators = require("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_decorate5, "_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 MessageTenantContextInterceptor = class _MessageTenantContextInterceptor {
+  static {
+    __name(this, "MessageTenantContextInterceptor");
+  }
+  tenantContext;
+  logger = new import_common5.Logger(_MessageTenantContextInterceptor.name);
+  constructor(tenantContext) {
+    this.tenantContext = tenantContext;
+  }
+  intercept(context, next) {
+    const contextType = context.getType();
+    if (contextType === "rpc") {
+      const rpcContext = context.switchToRpc();
+      const payload = rpcContext.getData();
+      if (payload && payload.tenant) {
+        const tenant = payload.tenant;
+        this.logger.debug(`Setting tenant context from message: ${tenant.subdomain}`);
+        try {
+          this.tenantContext.setTenant(tenant);
+          this.logger.log(`Tenant context set: ${tenant.subdomain} (${tenant.type})`);
+        } catch (error) {
+          this.logger.error("Failed to set tenant context from message", error);
+        }
+      } else {
+        this.logger.warn("Message payload missing tenant information");
+      }
+    }
+    return next.handle().pipe((0, import_operators.tap)({
+      next: /* @__PURE__ */ __name(() => {
+        this.cleanupContext();
+      }, "next"),
+      error: /* @__PURE__ */ __name(() => {
+        this.cleanupContext();
+      }, "error"),
+      complete: /* @__PURE__ */ __name(() => {
+        this.cleanupContext();
+      }, "complete")
+    }));
+  }
+  /**
+  * Clean up tenant context after message is processed
+  */
+  cleanupContext() {
+    if (this.tenantContext.hasTenant()) {
+      const tenant = this.tenantContext.getTenantIdSafe();
+      this.tenantContext.clearTenant();
+      this.logger.debug(`Cleaned up tenant context: ${tenant}`);
+    }
+  }
+};
+MessageTenantContextInterceptor = _ts_decorate5([
+  (0, import_common5.Injectable)({
+    scope: import_common5.Scope.REQUEST
+  }),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof TenantContextService === "undefined" ? Object : TenantContextService
+  ])
+], MessageTenantContextInterceptor);
+
+// src/database/interceptors/tenant-context.interceptor.ts
+var import_common6 = require("@nestjs/common");
+
+// src/database/utils/subdomain-parser.util.ts
+function extractSubdomain(host) {
+  if (!host) {
+    return null;
+  }
+  const hostname = host.split(":")[0];
+  if (!hostname) {
+    return null;
+  }
+  const parts = hostname.split(".");
+  if (parts.length < 3) {
+    return null;
+  }
+  return parts[0] ?? null;
+}
+__name(extractSubdomain, "extractSubdomain");
+
+// src/database/interceptors/tenant-context.interceptor.ts
+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");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var TenantContextInterceptor = class _TenantContextInterceptor {
+  static {
+    __name(this, "TenantContextInterceptor");
+  }
+  tenantContext;
+  primaryDatabase;
+  options;
+  logger = new import_common6.Logger(_TenantContextInterceptor.name);
+  constructor(tenantContext, primaryDatabase, options) {
+    this.tenantContext = tenantContext;
+    this.primaryDatabase = primaryDatabase;
+    this.options = options;
+  }
+  async intercept(context, next) {
+    const request = context.switchToHttp().getRequest();
+    this.logger.debug(`Processing request: ${request.method} ${request.url}`);
+    try {
+      const tenantIdentifier = this.extractTenantIdentifier(request);
+      if (!tenantIdentifier) {
+        throw new import_common6.UnauthorizedException("Tenant identifier not found in request");
+      }
+      this.logger.debug(`Tenant identifier extracted: ${tenantIdentifier}`);
+      if (tenantIdentifier === "cloud") {
+        this.logger.log("Cloud platform access detected, skipping tenant context setup");
+        return next.handle();
+      }
+      const tenantInfo = await this.primaryDatabase.getTenantInfo(tenantIdentifier);
+      if (!tenantInfo) {
+        this.logger.warn(`Invalid tenant: ${tenantIdentifier}`);
+        throw new import_common6.UnauthorizedException("Invalid tenant");
+      }
+      if (tenantInfo.status !== "ACTIVE") {
+        this.logger.warn(`Tenant ${tenantIdentifier} has status: ${tenantInfo.status}`);
+        throw new import_common6.UnauthorizedException(`Tenant is ${tenantInfo.status}`);
+      }
+      this.logger.debug(`Tenant config loaded: ${tenantInfo.subdomain} (${tenantInfo.type})`);
+      this.tenantContext.setTenant(tenantInfo);
+      request.tenant = tenantInfo;
+      this.logger.log(`Tenant context set: ${tenantInfo.subdomain}`);
+    } catch (error) {
+      this.logger.error("Failed to set tenant context", error);
+      throw error;
+    }
+    return next.handle();
+  }
+  /**
+  * Extract tenant identifier: tries subdomain first, then falls back to header
+  */
+  extractTenantIdentifier(request) {
+    let tenantIdentifier = this.extractFromSubdomain(request);
+    if (!tenantIdentifier) {
+      tenantIdentifier = this.extractFromHeader(request);
+      if (tenantIdentifier) {
+        this.logger.debug("Using tenant from header (subdomain not found)");
+      }
+    }
+    return tenantIdentifier;
+  }
+  /**
+  * Extract tenant from subdomain
+  * @example acme.vritti.com → 'acme'
+  */
+  extractFromSubdomain(request) {
+    if (request.subdomain) {
+      return request.subdomain;
+    }
+    const host = request.headers?.host || request.hostname;
+    return extractSubdomain(host);
+  }
+  /**
+  * Extract tenant from HTTP headers
+  * Checks x-tenant-id and x-subdomain headers
+  */
+  extractFromHeader(request) {
+    const getHeader = /* @__PURE__ */ __name((key) => {
+      const value = request.headers?.[key];
+      return Array.isArray(value) ? value[0] : value;
+    }, "getHeader");
+    return getHeader("x-tenant-id") || getHeader("x-subdomain") || null;
+  }
+};
+TenantContextInterceptor = _ts_decorate6([
+  (0, import_common6.Injectable)({
+    scope: import_common6.Scope.REQUEST
+  }),
+  _ts_param3(2, (0, import_common6.Inject)(DATABASE_MODULE_OPTIONS)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof TenantContextService === "undefined" ? Object : TenantContextService,
+    typeof PrimaryDatabaseService === "undefined" ? Object : PrimaryDatabaseService,
+    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions
+  ])
+], TenantContextInterceptor);
+
+// src/database/decorators/tenant.decorator.ts
+var import_common7 = require("@nestjs/common");
+var Tenant = (0, import_common7.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();
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getHello
+  DatabaseModule,
+  MessageTenantContextInterceptor,
+  PrimaryDatabaseService,
+  Tenant,
+  TenantContextInterceptor,
+  TenantContextService,
+  TenantDatabaseService,
+  extractSubdomain
 });
 //# sourceMappingURL=index.cjs.map