@vritti/api-sdk 0.0.9 → 0.1.0

package/dist/index.cjs

@@ -222,6 +222,9 @@ var jwt = __toESM(require("jsonwebtoken"), 1);
 
 // src/database/services/primary-database.service.ts
 var import_common3 = require("@nestjs/common");
+var import_pg = require("pg");
+var import_node_postgres = require("drizzle-orm/node-postgres");
+var import_drizzle_orm = require("drizzle-orm");
 
 // src/database/constants.ts
 var DATABASE_MODULE_OPTIONS = Symbol("DATABASE_MODULE_OPTIONS");
@@ -250,8 +253,10 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
   }
   options;
   logger = new import_common3.Logger(_PrimaryDatabaseService.name);
-  /** Primary database client for querying tenant registry */
-  primaryDbClient;
+  /** PostgreSQL connection pool */
+  pool = null;
+  /** Drizzle database instance */
+  db = null;
   /** In-memory cache: Map<tenantIdentifier, TenantConfig> */
   tenantConfigCache = /* @__PURE__ */ new Map();
   /** Cache TTL in milliseconds */
@@ -262,28 +267,24 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
   }
   async onModuleInit() {
     if (this.options.primaryDb) {
-      await this.initializePrimaryDbClient();
+      await this.initializeDrizzleClient();
     }
   }
   /**
-  * Initialize connection to primary database
+  * Initialize connection to primary database using Drizzle
   */
-  async initializePrimaryDbClient() {
+  async initializeDrizzleClient() {
     try {
-      const PrimaryDbClient = this.options.prismaClientConstructor;
       const databaseUrl = this.buildPrimaryDbUrl();
-      this.primaryDbClient = new PrimaryDbClient({
-        datasources: {
-          db: {
-            url: databaseUrl
-          }
-        },
-        log: [
-          "error",
-          "warn"
-        ]
+      this.pool = new import_pg.Pool({
+        connectionString: databaseUrl,
+        max: this.options.maxConnections || 10
+      });
+      this.db = (0, import_node_postgres.drizzle)({
+        client: this.pool,
+        schema: this.options.drizzleSchema
       });
-      await this.primaryDbClient.$connect();
+      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);
@@ -298,7 +299,7 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
       throw new Error("Primary database configuration not provided");
     }
     const { host, port = 5432, username, password, database, schema = "public", sslMode = "require" } = this.options.primaryDb;
-    let url = `postgresql://${username}:${password}@${host}:${port}/${database}`;
+    let url = `postgresql://${username}:${encodeURIComponent(password)}@${host}:${port}/${database}`;
     const params = new URLSearchParams();
     if (schema) {
       params.set("schema", schema);
@@ -318,9 +319,9 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
     return url.replace(/:([^@]+)@/, ":****@");
   }
   /**
-  * Get tenant configuration by identifier (ID or slug)
+  * Get tenant configuration by identifier (ID or subdomain)
   *
-  * @param tenantIdentifier Tenant ID or slug
+  * @param tenantIdentifier Tenant ID or subdomain
   * @returns Tenant configuration or null if not found
   */
   async getTenantInfo(tenantIdentifier) {
@@ -330,45 +331,39 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
       return cached;
     }
     try {
-      if (!this.primaryDbClient) {
+      if (!this.db) {
         throw new Error("Primary database client not initialized");
       }
       this.logger.debug(`Querying primary database for tenant: ${tenantIdentifier}`);
-      const tenant = await this.primaryDbClient.tenant.findFirst({
-        where: {
-          OR: [
-            {
-              id: tenantIdentifier
-            },
-            {
-              subdomain: tenantIdentifier
-            }
-          ],
-          status: "ACTIVE"
-        },
-        include: {
-          databaseConfig: true
-        }
-      });
-      if (!tenant) {
+      const schema = this.options.drizzleSchema;
+      const { tenants, tenantDatabaseConfigs } = schema;
+      const result = await this.db.select().from(tenants).leftJoin(tenantDatabaseConfigs, (0, import_drizzle_orm.eq)(tenants.id, tenantDatabaseConfigs.tenantId)).where((0, import_drizzle_orm.or)((0, import_drizzle_orm.eq)(tenants.id, tenantIdentifier), (0, import_drizzle_orm.eq)(tenants.subdomain, tenantIdentifier))).limit(1);
+      if (!result.length) {
         this.logger.warn(`Tenant not found: ${tenantIdentifier}`);
         return null;
       }
+      const row = result[0];
+      const tenant = row.tenants;
+      const config = row.tenant_database_configs;
+      if (tenant.status !== "ACTIVE") {
+        this.logger.warn(`Tenant not active: ${tenantIdentifier}`);
+        return null;
+      }
       const info = {
         id: tenant.id,
         subdomain: tenant.subdomain,
         type: tenant.dbType,
         status: tenant.status,
         // For SHARED tenants: schema name
-        schemaName: tenant.databaseConfig?.dbSchema || void 0,
+        schemaName: config?.dbSchema || void 0,
         // For DEDICATED tenants: database configuration from TenantDatabaseConfig table
-        databaseName: tenant.databaseConfig?.dbName || void 0,
-        databaseHost: tenant.databaseConfig?.dbHost || void 0,
-        databasePort: tenant.databaseConfig?.dbPort || void 0,
-        databaseUsername: tenant.databaseConfig?.dbUsername ? this.decrypt(tenant.databaseConfig.dbUsername) : void 0,
-        databasePassword: tenant.databaseConfig?.dbPassword ? this.decrypt(tenant.databaseConfig.dbPassword) : void 0,
-        databaseSslMode: tenant.databaseConfig?.dbSslMode || void 0,
-        connectionPoolSize: tenant.databaseConfig?.connectionPoolSize || void 0
+        databaseName: config?.dbName || void 0,
+        databaseHost: config?.dbHost || void 0,
+        databasePort: config?.dbPort || void 0,
+        databaseUsername: config?.dbUsername ? this.decrypt(config.dbUsername) : void 0,
+        databasePassword: config?.dbPassword ? this.decrypt(config.dbPassword) : void 0,
+        databaseSslMode: config?.dbSslMode || void 0,
+        connectionPoolSize: config?.connectionPoolSize || void 0
       };
       this.cacheInfo(info);
       return info;
@@ -394,7 +389,7 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
   *
   * Useful when tenant settings are updated and cache needs to be invalidated
   *
-  * @param tenantIdentifier Tenant ID or slug
+  * @param tenantIdentifier Tenant ID or subdomain
   */
   clearTenantCache(tenantIdentifier) {
     const config = this.tenantConfigCache.get(tenantIdentifier);
@@ -413,17 +408,23 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
     this.logger.log(`Cleared ${size} cached tenant configs`);
   }
   /**
-  * Get the Prisma client for the primary database.
-  * This is a synchronous property that returns the initialized Prisma client.
+  * Get the Drizzle database instance for the primary database.
+  * This is a synchronous property that returns the initialized Drizzle client.
   *
-  * @returns Primary database client instance
+  * @returns Primary database Drizzle instance
   * @throws Error if primary database client is not initialized
   */
-  get prismaClient() {
-    if (!this.primaryDbClient) {
+  get drizzleClient() {
+    if (!this.db) {
       throw new Error("Primary database client not initialized");
     }
-    return this.primaryDbClient;
+    return this.db;
+  }
+  /**
+  * Get the Drizzle schema
+  */
+  get schema() {
+    return this.options.drizzleSchema;
   }
   /**
   * Decrypt database credentials
@@ -437,8 +438,8 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
     return encrypted;
   }
   async onModuleDestroy() {
-    if (this.primaryDbClient) {
-      await this.primaryDbClient.$disconnect();
+    if (this.pool) {
+      await this.pool.end();
       this.logger.log("Disconnected from primary database");
     }
   }
@@ -983,6 +984,8 @@ TenantContextInterceptor = _ts_decorate8([
 
 // src/database/services/tenant-database.service.ts
 var import_common9 = require("@nestjs/common");
+var import_pg2 = require("pg");
+var import_node_postgres2 = require("drizzle-orm/node-postgres");
 function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1007,7 +1010,7 @@ var TenantDatabaseService = class _TenantDatabaseService {
   options;
   tenantContext;
   logger = new import_common9.Logger(_TenantDatabaseService.name);
-  /** Connection pool: Map<cacheKey, DbClient> */
+  /** Connection pool: Map<cacheKey, TenantConnection> */
   clients = /* @__PURE__ */ new Map();
   /** Track last usage time for idle connection cleanup */
   clientLastUsed = /* @__PURE__ */ new Map();
@@ -1019,17 +1022,23 @@ var TenantDatabaseService = class _TenantDatabaseService {
     this.startConnectionCleaner();
   }
   /**
-  * Get the Prisma client for the current tenant's database.
+  * Get the Drizzle client for the current tenant's database.
   * This returns the tenant-scoped database client.
   *
-  * @returns Tenant-scoped database client instance
+  * @returns Tenant-scoped Drizzle database instance
   * @throws UnauthorizedException if tenant context not set
   * @throws InternalServerErrorException if connection fails
   */
-  get prismaClient() {
+  get drizzleClient() {
     return this.getDbClient();
   }
   /**
+  * Get the Drizzle schema
+  */
+  get schema() {
+    return this.options.drizzleSchema;
+  }
+  /**
   * Get tenant-scoped database client for the current request/message
   *
   * This method:
@@ -1037,66 +1046,61 @@ var TenantDatabaseService = class _TenantDatabaseService {
   * 2. Builds a connection URL based on tenant type
   * 3. Returns cached client if exists, otherwise creates new one
   *
-  * @returns Promise<Database client instance>
+  * @returns Drizzle database instance
   * @throws UnauthorizedException if tenant context not set
   * @throws InternalServerErrorException if connection fails
-  *
-  * @example
-  * const dbClient = await tenantDatabase.getDbClient<PrismaClient>();
-  * const users = await dbClient.user.findMany();
   */
-  async getDbClient() {
+  getDbClient() {
     const tenant = this.tenantContext.getTenant();
     const cacheKey = this.buildCacheKey(tenant);
-    if (this.clients.has(cacheKey)) {
+    const existing = this.clients.get(cacheKey);
+    if (existing) {
       this.clientLastUsed.set(cacheKey, Date.now());
       this.logger.debug(`Reusing cached connection: ${cacheKey}`);
-      return this.clients.get(cacheKey);
+      return existing.db;
     }
     this.logger.log(`Creating new database connection: ${cacheKey}`);
-    const client = await this.createDbClient(tenant);
-    this.clients.set(cacheKey, client);
+    const connection = this.createDbClientSync(tenant);
+    this.clients.set(cacheKey, connection);
     this.clientLastUsed.set(cacheKey, Date.now());
-    return client;
+    return connection.db;
   }
   /**
-  * Create a new database client for the given tenant
+  * Create a new database client for the given tenant (synchronous)
   */
-  async createDbClient(tenant) {
+  createDbClientSync(tenant) {
     try {
       const databaseUrl = this.buildTenantDbUrl(tenant);
-      const PrismaClient = await this.options.prismaClientConstructor;
-      const client = new PrismaClient({
-        datasources: {
-          db: {
-            url: databaseUrl
-          }
-        },
-        log: [
-          "error",
-          "warn"
-        ]
+      const pool = new import_pg2.Pool({
+        connectionString: databaseUrl,
+        max: tenant.connectionPoolSize || this.options.maxConnections || 10
+      });
+      const db = (0, import_node_postgres2.drizzle)({
+        client: pool,
+        schema: this.options.drizzleSchema
       });
-      await client.$connect();
       this.logger.log(`Connected to database for tenant: ${tenant.subdomain}`);
-      return client;
+      return {
+        pool,
+        db
+      };
     } catch (error) {
       this.logger.error(`Failed to create database connection for tenant: ${tenant.subdomain}`, error);
       throw new import_common9.InternalServerErrorException("Failed to connect to tenant database");
     }
   }
   /**
-  * Build connection URL for enterprise tenant (dedicated database)
+  * Build connection URL for tenant (dedicated database)
   */
   buildTenantDbUrl(tenant) {
     const { databaseHost, databasePort, databaseName, databaseUsername, databasePassword, databaseSslMode } = tenant;
     if (!databaseHost || !databaseName || !databaseUsername) {
-      throw new Error(`Enterprise tenant ${tenant.subdomain} missing database configuration`);
+      throw new Error(`Tenant ${tenant.subdomain} missing database configuration`);
     }
     const port = databasePort || 5432;
     const sslMode = databaseSslMode || "require";
-    const connectionUrl = `postgresql://${databaseUsername}:${databasePassword}@${databaseHost}:${port}/${databaseName}?sslmode=${sslMode}`;
-    this.logger.debug(`Enterprise connection URL: ${this.maskPassword(connectionUrl)}`);
+    const connectionUrl = `postgresql://${databaseUsername}:${encodeURIComponent(databasePassword || "")}@${databaseHost}:${port}/${databaseName}?sslmode=${sslMode}`;
+    this.logger.debug(`Tenant connection URL: ${this.maskPassword(connectionUrl)}`);
     return connectionUrl;
   }
   /**
@@ -1118,19 +1122,20 @@ var TenantDatabaseService = class _TenantDatabaseService {
   /**
   * Clean up idle connections that haven't been used recently
   */
-  cleanupIdleConnections() {
+  async cleanupIdleConnections() {
     const now = Date.now();
     const maxIdle = this.options.connectionCacheTTL || 3e5;
     let cleaned = 0;
     for (const [key, lastUsed] of this.clientLastUsed.entries()) {
       if (now - lastUsed > maxIdle) {
-        const client = this.clients.get(key);
-        if (client) {
-          client.$disconnect().then(() => {
+        const connection = this.clients.get(key);
+        if (connection) {
+          try {
+            await connection.pool.end();
             this.logger.debug(`Cleaned up idle connection: ${key}`);
-          }).catch((error) => {
+          } catch (error) {
             this.logger.error(`Error disconnecting idle client: ${key}`, error);
-          });
+          }
           this.clients.delete(key);
           this.clientLastUsed.delete(key);
           cleaned++;
@@ -1161,9 +1166,9 @@ var TenantDatabaseService = class _TenantDatabaseService {
       clearInterval(this.cleanupInterval);
     }
     this.logger.log(`Disconnecting ${this.clients.size} database connections`);
-    const disconnectPromises = Array.from(this.clients.entries()).map(async ([key, client]) => {
+    const disconnectPromises = Array.from(this.clients.entries()).map(async ([key, connection]) => {
       try {
-        await client.$disconnect();
+        await connection.pool.end();
         this.logger.debug(`Disconnected: ${key}`);
       } catch (error) {
         this.logger.error(`Error disconnecting client: ${key}`, error);
@@ -1299,56 +1304,64 @@ DatabaseModule = _ts_decorate10([
 
 // src/database/repositories/primary-base.repository.ts
 var import_common11 = require("@nestjs/common");
+var import_drizzle_orm2 = require("drizzle-orm");
 var PrimaryBaseRepository = class {
   static {
     __name(this, "PrimaryBaseRepository");
   }
   database;
+  table;
   logger;
-  modelGetter;
   /**
-  * Lazy getter for Prisma client.
+  * The table name extracted from the Drizzle table at runtime.
+  * Used to access the query API for this repository's table.
+  */
+  tableName;
+  /**
+  * Lazy getter for Drizzle client.
   * Accesses the client from the database service only when needed,
   * avoiding initialization timing issues with NestJS lifecycle.
   */
-  get prisma() {
-    return this.database.prismaClient;
+  get db() {
+    return this.database.drizzleClient;
   }
   /**
-  * Lazy getter for the Prisma model delegate.
-  * Returns the specific model (e.g., prisma.user, prisma.tenant) for this repository.
+  * Model query API for THIS repository's table (Prisma-like syntax)
+  * Scoped to only the table this repository manages.
+  * Returns a type-safe wrapper around Drizzle's RelationalQueryBuilder.
+  *
+  * @example
+  * ```typescript
+  * // Use relational queries with type safety
+  * const user = await this.model.findFirst({
+  *   where: eq(users.id, id),
+  *   with: { posts: true, profile: true }
+  * });
+  * ```
   */
   get model() {
-    return this.modelGetter(this.prisma);
+    return this.database.drizzleClient.query[this.tableName];
   }
   /**
   * Create a new repository instance
   *
   * @param database - The primary database service
-  * @param getModel - Function that returns the Prisma model delegate from the client
+  * @param table - The Drizzle table schema object
   *
   * @example
   * ```typescript
-  * // Standard usage with full parameter name
-  * constructor(database: PrimaryDatabaseService) {
-  *   super(database, (prisma) => prisma.user);
-  * }
-  *
-  * // Short syntax
-  * constructor(database: PrimaryDatabaseService) {
-  *   super(database, (p) => p.user);
-  * }
+  * import { users } from '@/db/schema';
   *
-  * // Complex model names
   * constructor(database: PrimaryDatabaseService) {
-  *   super(database, (p) => p.emailVerification);
+  *   super(database, users);
   * }
   * ```
   */
-  constructor(database, getModel) {
+  constructor(database, table) {
     this.database = database;
+    this.table = table;
+    this.tableName = (0, import_drizzle_orm2.getTableName)(table);
     this.logger = new import_common11.Logger(this.constructor.name);
-    this.modelGetter = getModel;
     this.logger.debug(`Initialized ${this.constructor.name}`);
   }
   /**
@@ -1361,21 +1374,20 @@ var PrimaryBaseRepository = class {
   * ```typescript
   * const user = await userRepository.create({
   *   email: 'user@example.com',
-  *   name: 'John Doe'
+  *   firstName: 'John'
   * });
   * ```
   */
   async create(data) {
     this.logger.log("Creating record");
-    return await this.model.create({
-      data
-    });
+    const results = await this.db.insert(this.table).values(data).returning();
+    return results[0];
   }
   /**
   * Find a single record by ID
   *
   * @param id - The record ID
-  * @returns Promise resolving to the record or null if not found
+  * @returns Promise resolving to the record or undefined if not found
   *
   * @example
   * ```typescript
@@ -1384,59 +1396,54 @@ var PrimaryBaseRepository = class {
   */
   async findById(id) {
     this.logger.debug(`Finding record by ID: ${id}`);
-    return await this.model.findUnique({
-      where: {
-        id
-      }
+    const idColumn = this.table.id;
+    return this.model.findFirst({
+      where: (0, import_drizzle_orm2.eq)(idColumn, id)
     });
   }
   /**
   * Find a single record with custom where clause
   *
-  * @param where - The where clause or findUnique args
-  * @returns Promise resolving to the record or null if not found
+  * @param where - SQL condition
+  * @returns Promise resolving to the record or undefined if not found
   *
   * @example
   * ```typescript
-  * // Simple where clause
-  * const user = await userRepository.findOne({ email: 'user@example.com' });
-  *
-  * // With include
-  * const user = await userRepository.findOne({
-  *   where: { email: 'user@example.com' },
-  *   include: { posts: true }
-  * });
+  * import { eq } from 'drizzle-orm';
+  * const user = await userRepository.findOne(eq(users.email, 'user@example.com'));
   * ```
   */
   async findOne(where) {
     this.logger.debug("Finding record with custom query");
-    return await this.model.findUnique(typeof where === "object" && "where" in where ? where : {
+    return this.model.findFirst({
       where
     });
   }
   /**
   * Find multiple records
   *
-  * @param args - Prisma findMany arguments (where, orderBy, take, skip, etc.)
+  * @param options - Query options (where, orderBy, limit, offset)
   * @returns Promise resolving to an array of records
   *
   * @example
   * ```typescript
+  * import { eq, desc } from 'drizzle-orm';
+  *
   * // Find all users
   * const users = await userRepository.findMany();
   *
   * // Find with filtering and pagination
   * const users = await userRepository.findMany({
-  *   where: { status: 'ACTIVE' },
-  *   orderBy: { createdAt: 'desc' },
-  *   take: 10,
-  *   skip: 0
+  *   where: eq(users.accountStatus, 'ACTIVE'),
+  *   orderBy: desc(users.createdAt),
+  *   limit: 10,
+  *   offset: 0
   * });
   * ```
   */
-  async findMany(args) {
+  async findMany(options) {
     this.logger.debug("Finding multiple records");
-    return await this.model.findMany(args);
+    return this.model.findMany(options);
   }
   /**
   * Update a record by ID
@@ -1448,41 +1455,40 @@ var PrimaryBaseRepository = class {
   * @example
   * ```typescript
   * const user = await userRepository.update('user-id-123', {
-  *   name: 'Jane Doe'
+  *   firstName: 'Jane'
   * });
   * ```
   */
   async update(id, data) {
     this.logger.log(`Updating record with ID: ${id}`);
-    return await this.model.update({
-      where: {
-        id
-      },
-      data
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.update(this.table).set(data).where((0, import_drizzle_orm2.eq)(idColumn, id)).returning();
+    return results[0];
   }
   /**
   * Update multiple records
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @param data - The data to update
   * @returns Promise resolving to the count of updated records
   *
   * @example
   * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
   * const result = await userRepository.updateMany(
-  *   { status: 'PENDING' },
-  *   { status: 'ACTIVE' }
+  *   eq(users.accountStatus, 'PENDING'),
+  *   { accountStatus: 'ACTIVE' }
   * );
   * console.log(`Updated ${result.count} users`);
   * ```
   */
   async updateMany(where, data) {
     this.logger.log("Updating multiple records");
-    return await this.model.updateMany({
-      where,
-      data
-    });
+    const result = await this.db.update(this.table).set(data).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
   }
   /**
   * Delete a record by ID
@@ -1497,127 +1503,143 @@ var PrimaryBaseRepository = class {
   */
   async delete(id) {
     this.logger.log(`Deleting record with ID: ${id}`);
-    return await this.model.delete({
-      where: {
-        id
-      }
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.delete(this.table).where((0, import_drizzle_orm2.eq)(idColumn, id)).returning();
+    return results[0];
   }
   /**
   * Delete multiple records
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @returns Promise resolving to the count of deleted records
   *
   * @example
   * ```typescript
-  * const result = await userRepository.deleteMany({
-  *   status: 'INACTIVE',
-  *   createdAt: { lt: new Date('2020-01-01') }
-  * });
+  * import { lt } from 'drizzle-orm';
+  *
+  * const result = await userRepository.deleteMany(
+  *   lt(users.createdAt, new Date('2020-01-01'))
+  * );
   * console.log(`Deleted ${result.count} users`);
   * ```
   */
   async deleteMany(where) {
     this.logger.log("Deleting multiple records");
-    return await this.model.deleteMany({
-      where
-    });
+    const result = await this.db.delete(this.table).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
   }
   /**
   * Count records
   *
-  * @param where - Optional where clause to filter records
+  * @param where - Optional SQL condition to filter records
   * @returns Promise resolving to the count of records
   *
   * @example
   * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
   * // Count all users
   * const total = await userRepository.count();
   *
   * // Count active users
-  * const activeCount = await userRepository.count({ status: 'ACTIVE' });
+  * const activeCount = await userRepository.count(
+  *   eq(users.accountStatus, 'ACTIVE')
+  * );
   * ```
   */
   async count(where) {
     this.logger.debug("Counting records");
-    return await this.model.count({
-      where
-    });
+    let query = this.db.select({
+      count: import_drizzle_orm2.sql`count(*)::int`
+    }).from(this.table).$dynamic();
+    if (where) {
+      query = query.where(where);
+    }
+    const results = await query;
+    return results[0].count;
   }
   /**
   * Check if a record exists
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @returns Promise resolving to true if at least one record exists, false otherwise
   *
   * @example
   * ```typescript
-  * const emailExists = await userRepository.exists({
-  *   email: 'user@example.com'
-  * });
+  * import { eq } from 'drizzle-orm';
+  *
+  * const emailExists = await userRepository.exists(
+  *   eq(users.email, 'user@example.com')
+  * );
   * ```
   */
   async exists(where) {
-    const count = await this.model.count({
-      where
-    });
+    const count = await this.count(where);
     return count > 0;
   }
 };
 
 // src/database/repositories/tenant-base.repository.ts
 var import_common12 = require("@nestjs/common");
+var import_drizzle_orm3 = require("drizzle-orm");
 var TenantBaseRepository = class {
   static {
     __name(this, "TenantBaseRepository");
   }
   database;
+  table;
   logger;
-  modelGetter;
   /**
-  * Lazy getter for Prisma client.
+  * The table name extracted from the Drizzle table at runtime.
+  * Used to access the query API for this repository's table.
+  */
+  tableName;
+  /**
+  * Lazy getter for Drizzle client.
   * Accesses the client from the database service only when needed,
   * avoiding initialization timing issues with NestJS lifecycle.
   */
-  get prisma() {
-    return this.database.prismaClient;
+  get db() {
+    return this.database.drizzleClient;
   }
   /**
-  * Lazy getter for the Prisma model delegate.
-  * Returns the specific model (e.g., prisma.product, prisma.order) for this repository.
+  * Model query API for THIS repository's table (Prisma-like syntax)
+  * Scoped to only the table this repository manages
+  *
+  * @example
+  * ```typescript
+  * // Use relational queries with type safety
+  * const product = await this.model.findFirst({
+  *   where: eq(products.id, id),
+  *   with: { category: true, variants: true }
+  * });
+  * ```
   */
   get model() {
-    return this.modelGetter(this.prisma);
+    return this.database.drizzleClient.query[this.tableName];
   }
   /**
   * Create a new repository instance
   *
   * @param database - The tenant database service
-  * @param getModel - Function that returns the Prisma model delegate from the client
+  * @param table - The Drizzle table schema object
   *
   * @example
   * ```typescript
-  * // Standard usage with full parameter name
-  * constructor(database: TenantDatabaseService) {
-  *   super(database, (prisma) => prisma.product);
-  * }
+  * import { products } from '@/db/schema';
   *
-  * // Short syntax
   * constructor(database: TenantDatabaseService) {
-  *   super(database, (p) => p.product);
-  * }
-  *
-  * // Complex model names
-  * constructor(database: TenantDatabaseService) {
-  *   super(database, (p) => p.inventoryItem);
+  *   super(database, products);
   * }
   * ```
   */
-  constructor(database, getModel) {
+  constructor(database, table) {
     this.database = database;
+    this.table = table;
+    this.tableName = (0, import_drizzle_orm3.getTableName)(table);
     this.logger = new import_common12.Logger(this.constructor.name);
-    this.modelGetter = getModel;
     this.logger.debug(`Initialized ${this.constructor.name}`);
   }
   /**
@@ -1637,9 +1659,8 @@ var TenantBaseRepository = class {
   */
   async create(data) {
     this.logger.log("Creating record");
-    return await this.model.create({
-      data
-    });
+    const results = await this.db.insert(this.table).values(data).returning();
+    return results[0];
   }
   /**
   * Find a single record by ID
@@ -1654,59 +1675,65 @@ var TenantBaseRepository = class {
   */
   async findById(id) {
     this.logger.debug(`Finding record by ID: ${id}`);
-    return await this.model.findUnique({
-      where: {
-        id
-      }
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.select().from(this.table).where((0, import_drizzle_orm3.eq)(idColumn, id)).limit(1);
+    return results[0] ?? null;
   }
   /**
   * Find a single record with custom where clause
   *
-  * @param where - The where clause or findUnique args
+  * @param where - SQL condition
   * @returns Promise resolving to the record or null if not found
   *
   * @example
   * ```typescript
-  * // Simple where clause
-  * const product = await productRepository.findOne({ sku: 'WDG-001' });
-  *
-  * // With include
-  * const product = await productRepository.findOne({
-  *   where: { sku: 'WDG-001' },
-  *   include: { category: true }
-  * });
+  * import { eq } from 'drizzle-orm';
+  * const product = await productRepository.findOne(eq(products.sku, 'WDG-001'));
   * ```
   */
   async findOne(where) {
     this.logger.debug("Finding record with custom query");
-    return await this.model.findUnique(typeof where === "object" && "where" in where ? where : {
-      where
-    });
+    const results = await this.db.select().from(this.table).where(where).limit(1);
+    return results[0] ?? null;
   }
   /**
   * Find multiple records
   *
-  * @param args - Prisma findMany arguments (where, orderBy, take, skip, etc.)
+  * @param options - Query options (where, orderBy, limit, offset)
   * @returns Promise resolving to an array of records
   *
   * @example
   * ```typescript
+  * import { eq, desc } from 'drizzle-orm';
+  *
   * // Find all products
   * const products = await productRepository.findMany();
   *
   * // Find with filtering and pagination
   * const products = await productRepository.findMany({
-  *   where: { status: 'ACTIVE' },
-  *   orderBy: { createdAt: 'desc' },
-  *   take: 10,
-  *   skip: 0
+  *   where: eq(products.status, 'ACTIVE'),
+  *   orderBy: desc(products.createdAt),
+  *   limit: 10,
+  *   offset: 0
   * });
   * ```
   */
-  async findMany(args) {
+  async findMany(options) {
     this.logger.debug("Finding multiple records");
-    return await this.model.findMany(args);
+    let query = this.db.select().from(this.table).$dynamic();
+    if (options?.where) {
+      query = query.where(options.where);
+    }
+    if (options?.orderBy) {
+      query = query.orderBy(options.orderBy);
+    }
+    if (options?.limit) {
+      query = query.limit(options.limit);
+    }
+    if (options?.offset) {
+      query = query.offset(options.offset);
+    }
+    return await query;
   }
   /**
   * Update a record by ID
@@ -1724,24 +1751,23 @@ var TenantBaseRepository = class {
   */
   async update(id, data) {
     this.logger.log(`Updating record with ID: ${id}`);
-    return await this.model.update({
-      where: {
-        id
-      },
-      data
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.update(this.table).set(data).where((0, import_drizzle_orm3.eq)(idColumn, id)).returning();
+    return results[0];
   }
   /**
   * Update multiple records
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @param data - The data to update
   * @returns Promise resolving to the count of updated records
   *
   * @example
   * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
   * const result = await productRepository.updateMany(
-  *   { status: 'PENDING' },
+  *   eq(products.status, 'PENDING'),
   *   { status: 'ACTIVE' }
   * );
   * console.log(`Updated ${result.count} products`);
@@ -1749,10 +1775,10 @@ var TenantBaseRepository = class {
   */
   async updateMany(where, data) {
     this.logger.log("Updating multiple records");
-    return await this.model.updateMany({
-      where,
-      data
-    });
+    const result = await this.db.update(this.table).set(data).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
   }
   /**
   * Delete a record by ID
@@ -1767,71 +1793,80 @@ var TenantBaseRepository = class {
   */
   async delete(id) {
     this.logger.log(`Deleting record with ID: ${id}`);
-    return await this.model.delete({
-      where: {
-        id
-      }
-    });
+    const idColumn = this.table.id;
+    const results = await this.db.delete(this.table).where((0, import_drizzle_orm3.eq)(idColumn, id)).returning();
+    return results[0];
   }
   /**
   * Delete multiple records
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @returns Promise resolving to the count of deleted records
   *
   * @example
   * ```typescript
-  * const result = await productRepository.deleteMany({
-  *   status: 'INACTIVE',
-  *   createdAt: { lt: new Date('2020-01-01') }
-  * });
+  * import { lt } from 'drizzle-orm';
+  *
+  * const result = await productRepository.deleteMany(
+  *   lt(products.createdAt, new Date('2020-01-01'))
+  * );
   * console.log(`Deleted ${result.count} products`);
   * ```
   */
   async deleteMany(where) {
     this.logger.log("Deleting multiple records");
-    return await this.model.deleteMany({
-      where
-    });
+    const result = await this.db.delete(this.table).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
   }
   /**
   * Count records
   *
-  * @param where - Optional where clause to filter records
+  * @param where - Optional SQL condition to filter records
   * @returns Promise resolving to the count of records
   *
   * @example
   * ```typescript
+  * import { eq } from 'drizzle-orm';
+  *
   * // Count all products
   * const total = await productRepository.count();
   *
   * // Count active products
-  * const activeCount = await productRepository.count({ status: 'ACTIVE' });
+  * const activeCount = await productRepository.count(
+  *   eq(products.status, 'ACTIVE')
+  * );
   * ```
   */
   async count(where) {
     this.logger.debug("Counting records");
-    return await this.model.count({
-      where
-    });
+    let query = this.db.select({
+      count: import_drizzle_orm3.sql`count(*)::int`
+    }).from(this.table).$dynamic();
+    if (where) {
+      query = query.where(where);
+    }
+    const results = await query;
+    return results[0].count;
   }
   /**
   * Check if a record exists
   *
-  * @param where - The where clause to match records
+  * @param where - SQL condition to match records
   * @returns Promise resolving to true if at least one record exists, false otherwise
   *
   * @example
   * ```typescript
-  * const skuExists = await productRepository.exists({
-  *   sku: 'WDG-001'
-  * });
+  * import { eq } from 'drizzle-orm';
+  *
+  * const skuExists = await productRepository.exists(
+  *   eq(products.sku, 'WDG-001')
+  * );
   * ```
   */
   async exists(where) {
-    const count = await this.model.count({
-      where
-    });
+    const count = await this.count(where);
     return count > 0;
   }
 };
@@ -1988,15 +2023,16 @@ var HttpExceptionFilter = class _HttpExceptionFilter {
       const exceptionResponse = exception.getResponse();
       if (typeof exceptionResponse === "object" && exceptionResponse !== null) {
         const responseObj = exceptionResponse;
-        if (responseObj.errors && Array.isArray(responseObj.errors)) {
+        if ("errors" in responseObj && Array.isArray(responseObj.errors)) {
           errors = responseObj.errors;
-          detail = responseObj.detail || exception.message;
-        } else if (responseObj.message && Array.isArray(responseObj.message)) {
+          detail = ("detail" in responseObj ? responseObj.detail : void 0) || exception.message;
+        } else if ("message" in responseObj && Array.isArray(responseObj.message)) {
           errors = responseObj.message.map((msg) => {
-            if (typeof msg === "object" && msg.property && msg.constraints) {
+            if (typeof msg === "object" && "property" in msg && "constraints" in msg) {
+              const constraintValues = Object.values(msg.constraints);
               return {
                 field: msg.property,
-                message: Object.values(msg.constraints)[0]
+                message: constraintValues[0] ?? "Validation failed"
               };
             }
             return {
@@ -2004,13 +2040,14 @@ var HttpExceptionFilter = class _HttpExceptionFilter {
             };
           });
           detail = "Validation failed";
-        } else if (responseObj.message) {
+        } else if ("message" in responseObj) {
+          const message = responseObj.message;
           errors = [
             {
-              message: Array.isArray(responseObj.message) ? responseObj.message.join(", ") : responseObj.message
+              message: Array.isArray(message) ? message.join(", ") : message
             }
           ];
-          detail = responseObj.error || exception.message;
+          detail = ("error" in responseObj ? responseObj.error : void 0) || exception.message;
         }
       } else if (typeof exceptionResponse === "string") {
         errors = [
@@ -3058,14 +3095,15 @@ function getLevelsUpTo(level) {
     "debug",
     "verbose"
   ];
-  const levelIndex = allLevels.indexOf(level);
-  if (levelIndex === -1) {
+  const isValidLevel = /* @__PURE__ */ __name((l) => allLevels.includes(l), "isValidLevel");
+  if (!isValidLevel(level)) {
     return [
       "error",
       "warn",
       "log"
     ];
   }
+  const levelIndex = allLevels.indexOf(level);
   return allLevels.slice(0, levelIndex + 1);
 }
 __name(getLevelsUpTo, "getLevelsUpTo");