@vritti/api-sdk 0.0.9 → 0.1.1

package/dist/index.d.cts

@@ -1,5 +1,8 @@
 import * as _nestjs_common from '@nestjs/common';
 import { DynamicModule, OnModuleDestroy, OnModuleInit, Logger, CanActivate, ExecutionContext, ExceptionFilter, ArgumentsHost, HttpException, HttpStatus, ModuleMetadata, Type, NestModule, MiddlewareConsumer, LoggerService as LoggerService$1, NestMiddleware, NestInterceptor, CallHandler } from '@nestjs/common';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { InferInsertModel, InferSelectModel, SQL } from 'drizzle-orm';
+import { PgTable } from 'drizzle-orm/pg-core';
 import { ConfigService } from '@nestjs/config';
 import { Reflector } from '@nestjs/core';
 import { JwtService } from '@nestjs/jwt';
@@ -81,6 +84,34 @@ declare class AuthConfigModule {
     static forRootAsync(): DynamicModule;
 }
 
+/**
+ * Schema Registry Interface
+ *
+ * Projects augment this interface to register their Drizzle schema.
+ * This enables type-safe db.query access without passing schema types everywhere.
+ *
+ * @example
+ * // In your project's schema.registry.ts:
+ * declare module '@vritti/api-sdk' {
+ *   interface SchemaRegistry {
+ *     schema: typeof import('./schema');
+ *   }
+ * }
+ */
+interface SchemaRegistry {
+}
+/**
+ * Extracts the registered schema type.
+ * Falls back to Record<string, unknown> if no schema is registered.
+ */
+type RegisteredSchema = SchemaRegistry extends {
+    schema: infer S;
+} ? S : Record<string, unknown>;
+/**
+ * Type alias for the Drizzle database client with registered schema
+ */
+type TypedDrizzleClient = NodePgDatabase<RegisteredSchema>;
+
 /**
  * Primary database connection configuration
  */
@@ -97,8 +128,8 @@ interface PrimaryDbConfig {
     database: string;
     /** Default schema (default: 'public') */
     schema?: string;
-    /** SSL mode: 'require' | 'prefer' | 'disable' (default: 'require') */
-    sslMode?: 'require' | 'prefer' | 'disable';
+    /** SSL mode: 'require' | 'prefer' | 'disable' | 'no-verify' (default: 'require') */
+    sslMode?: 'require' | 'prefer' | 'disable' | 'no-verify';
 }
 /**
  * Configuration options for DatabaseModule
@@ -120,11 +151,17 @@ interface DatabaseModuleOptions {
      */
     primaryDb: PrimaryDbConfig;
     /**
-     * Primary database client constructor (for querying tenant registry)
-     * Only required in gateway mode
-     * @example import { PrismaClient } from '@prisma/client'
+     * Drizzle schema object containing all tables
+     * Import your schema from db/schema/index.ts and pass it here
+     * @example import * as schema from '@/db/schema'
+     */
+    drizzleSchema: RegisteredSchema;
+    /**
+     * Drizzle relations object from defineRelations()
+     * Required for relational queries (db.query.*.findFirst/findMany)
+     * @example import { relations } from '@/db/schema'
      */
-    prismaClientConstructor: any;
+    drizzleRelations?: Record<string, any>;
     /**
      * Connection cache TTL in milliseconds
      * Idle connections will be closed after this period
@@ -356,7 +393,7 @@ declare class TenantContextService {
  * Service responsible for managing tenant-scoped database connections
  *
  * This service:
- * - Maintains a connection pool (Map<cacheKey, DbClient>)
+ * - Maintains a connection pool (Map<cacheKey, TenantConnection>)
  * - Creates new connections dynamically based on tenant context
  * - Reuses existing connections for the same tenant
  * - Supports both cloud schemas and enterprise databases
@@ -364,14 +401,14 @@ declare class TenantContextService {
  *
  * @example
  * // In a controller or service
- * const dbClient = await this.tenantDatabase.getDbClient<PrismaClient>();
- * const users = await dbClient.user.findMany();
+ * const db = this.tenantDatabase.drizzleClient;
+ * const users = await db.select().from(usersTable);
  */
 declare class TenantDatabaseService implements OnModuleDestroy {
     private readonly options;
     private readonly tenantContext;
     private readonly logger;
-    /** Connection pool: Map<cacheKey, DbClient> */
+    /** Connection pool: Map<cacheKey, TenantConnection> */
     private readonly clients;
     /** Track last usage time for idle connection cleanup */
     private readonly clientLastUsed;
@@ -379,14 +416,18 @@ declare class TenantDatabaseService implements OnModuleDestroy {
     private cleanupInterval?;
     constructor(options: DatabaseModuleOptions, tenantContext: TenantContextService);
     /**
-     * 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(): any;
+    get drizzleClient(): TypedDrizzleClient;
+    /**
+     * Get the Drizzle schema
+     */
+    get schema(): Record<string, unknown>;
     /**
      * Get tenant-scoped database client for the current request/message
      *
@@ -395,21 +436,17 @@ declare class TenantDatabaseService implements OnModuleDestroy {
      * 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();
      */
     private getDbClient;
     /**
-     * Create a new database client for the given tenant
+     * Create a new database client for the given tenant (synchronous)
      */
-    private createDbClient;
+    private createDbClientSync;
     /**
-     * Build connection URL for enterprise tenant (dedicated database)
+     * Build connection URL for tenant (dedicated database)
      */
     private buildTenantDbUrl;
     /**
@@ -455,8 +492,10 @@ declare class TenantDatabaseService implements OnModuleDestroy {
 declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
     private readonly options;
     private readonly logger;
-    /** Primary database client for querying tenant registry */
-    private primaryDbClient;
+    /** PostgreSQL connection pool */
+    private pool;
+    /** Drizzle database instance */
+    private db;
     /** In-memory cache: Map<tenantIdentifier, TenantConfig> */
     private readonly tenantConfigCache;
     /** Cache TTL in milliseconds */
@@ -464,9 +503,9 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
     constructor(options: DatabaseModuleOptions);
     onModuleInit(): Promise<void>;
     /**
-     * Initialize connection to primary database
+     * Initialize connection to primary database using Drizzle
      */
-    private initializePrimaryDbClient;
+    private initializeDrizzleClient;
     /**
      * Build connection URL from primary database properties
      */
@@ -476,9 +515,9 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
      */
     private maskPassword;
     /**
-     * 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
      */
     getTenantInfo(tenantIdentifier: string): Promise<TenantInfo | null>;
@@ -491,7 +530,7 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
      *
      * 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: string): void;
     /**
@@ -499,13 +538,17 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
      */
     clearAllCaches(): void;
     /**
-     * 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(): any;
+    get drizzleClient(): TypedDrizzleClient;
+    /**
+     * Get the Drizzle schema
+     */
+    get schema(): typeof this$1.options.drizzleSchema;
     /**
      * Decrypt database credentials
      *
@@ -519,90 +562,147 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
 }
 
 /**
- * Abstract base repository for primary database operations.
+ * Drizzle ORM v2 object-based where filter type.
+ * Supports simple equality, operators, AND/OR/NOT, and RAW SQL.
+ *
+ * @example
+ * ```typescript
+ * // Simple equality
+ * { email: 'user@example.com' }
+ *
+ * // With operators
+ * { age: { gt: 18, lt: 65 } }
+ *
+ * // AND/OR combinations
+ * { AND: [{ status: 'ACTIVE' }, { age: { gte: 18 } }] }
+ *
+ * // RAW SQL expression
+ * { RAW: (table) => sql`${table.email} ILIKE '%@gmail.com'` }
+ * ```
+ */
+type RelationsWhereFilter = Record<string, any>;
+/**
+ * Type-safe wrapper for Drizzle's RelationalQueryBuilder (v2 API).
+ * This interface matches the method signatures of RelationalQueryBuilder
+ * but properly binds the TSelect generic for type safety.
+ *
+ * We use this instead of RelationalQueryBuilder directly because
+ * TypeScript cannot infer TSelect from the generic base repository context.
+ *
+ * @remarks
+ * Drizzle ORM v2 uses object-based `where` filters instead of SQL expressions.
+ * See: https://orm.drizzle.team/docs/relations-v1-v2
+ */
+interface TypedRelationalQueryBuilder<TSelect> {
+    findFirst(config?: {
+        where?: RelationsWhereFilter;
+        with?: Record<string, unknown>;
+        columns?: Record<string, boolean>;
+    }): Promise<TSelect | undefined>;
+    findMany(config?: {
+        where?: RelationsWhereFilter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
+        limit?: number;
+        offset?: number;
+        with?: Record<string, unknown>;
+        columns?: Record<string, boolean>;
+    }): Promise<TSelect[]>;
+}
+/**
+ * Abstract base repository for primary database operations using Drizzle ORM.
  * Provides common CRUD operations with automatic logging.
  *
- * @template TModel - The Prisma model type
- * @template TCreateDTO - DTO type for create operations
- * @template TUpdateDTO - DTO type for update operations
+ * @template TTable - The Drizzle table type (must be registered in SchemaRegistry)
+ * @template TInsert - Type for insert operations (inferred from table.$inferInsert)
+ * @template TSelect - Type for select operations (inferred from table.$inferSelect)
+ *
+ * @remarks
+ * **Type Assertion Pattern:** This repository uses `as any` casts when passing
+ * the generic table to Drizzle methods. This is necessary because TypeScript
+ * cannot prove that a generic `TTable extends PgTable` satisfies Drizzle's
+ * stricter internal type requirements for `insert()`, `update()`, and `delete()`.
+ *
+ * The public API maintains full type safety:
+ * - Input parameters are typed as `TInsert` (inferred from table)
+ * - Return values are typed as `TSelect` (inferred from table)
+ * - The casts are implementation details that don't leak to consumers
  *
  * @example
  * ```typescript
- * // Using the model delegate pattern (RECOMMENDED)
- * // Type-safe, IDE autocomplete, refactor-friendly
- * @Injectable()
- * export class UserRepository extends PrimaryBaseRepository<
- *   User,
- *   CreateUserDto,
- *   UpdateUserDto
- * > {
- *   constructor(database: PrimaryDatabaseService) {
- *     super(database, (prisma) => prisma.user);  // ✅ Type-safe with autocomplete!
- *   }
+ * import { users } from '@/db/schema';
  *
- *   // Add custom methods as needed
- *   async findByEmail(email: string): Promise<User | null> {
- *     return this.model.findUnique({ where: { email } });
- *   }
- * }
+ * type User = typeof users.$inferSelect;
+ * type NewUser = typeof users.$inferInsert;
  *
- * // Short syntax is also supported
  * @Injectable()
- * export class TenantRepository extends PrimaryBaseRepository<Tenant> {
+ * export class UserRepository extends PrimaryBaseRepository<typeof users> {
  *   constructor(database: PrimaryDatabaseService) {
- *     super(database, (p) => p.tenant);  // ✅ Concise!
+ *     super(database, users);
  *   }
- * }
  *
- * // Works with complex model names
- * @Injectable()
- * export class EmailVerificationRepository extends PrimaryBaseRepository<EmailVerification> {
- *   constructor(database: PrimaryDatabaseService) {
- *     super(database, (p) => p.emailVerification);  // ✅ Matches Prisma naming
+ *   // Use Drizzle v2 object-based where syntax (recommended)
+ *   async findByEmail(email: string): Promise<User | undefined> {
+ *     return this.model.findFirst({
+ *       where: { email },
+ *     });
+ *   }
+ *
+ *   // With relations
+ *   async findWithRelations(id: string): Promise<User | undefined> {
+ *     return this.model.findFirst({
+ *       where: { id },
+ *       with: { posts: true, profile: true }
+ *     });
  *   }
  * }
  * ```
  */
-declare abstract class PrimaryBaseRepository<TModel, TCreateDTO = any, TUpdateDTO = any> {
+declare abstract class PrimaryBaseRepository<TTable extends PgTable, TInsert = InferInsertModel<TTable>, TSelect = InferSelectModel<TTable>> {
     protected readonly database: PrimaryDatabaseService;
+    protected readonly table: TTable;
     protected readonly logger: Logger;
-    private readonly 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.
+     */
+    private readonly tableName;
+    /**
+     * Lazy getter for Drizzle client.
      * Accesses the client from the database service only when needed,
      * avoiding initialization timing issues with NestJS lifecycle.
      */
-    protected get prisma(): any;
+    protected get db(): TypedDrizzleClient;
     /**
-     * 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 (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 v2 object-based where syntax
+     * const user = await this.model.findFirst({
+     *   where: { id },
+     *   with: { posts: true, profile: true }
+     * });
+     * ```
      */
-    protected get model(): any;
+    protected get model(): TypedRelationalQueryBuilder<TSelect>;
     /**
      * 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: PrimaryDatabaseService, getModel: (prisma: any) => any);
+    constructor(database: PrimaryDatabaseService, table: TTable);
     /**
      * Create a new record
      *
@@ -613,46 +713,49 @@ declare abstract class PrimaryBaseRepository<TModel, TCreateDTO = any, TUpdateDT
      * ```typescript
      * const user = await userRepository.create({
      *   email: 'user@example.com',
-     *   name: 'John Doe'
+     *   firstName: 'John'
      * });
      * ```
      */
-    create(data: TCreateDTO): Promise<TModel>;
+    create(data: TInsert): Promise<TSelect>;
     /**
      * 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 user = await userRepository.findById('user-id-123');
      * ```
      */
-    findById(id: string): Promise<TModel | null>;
+    findById(id: string): Promise<TSelect | undefined>;
     /**
-     * Find a single record with custom where clause
+     * Find a single record with custom where clause (Drizzle v2 object-based syntax)
      *
-     * @param where - The where clause or findUnique args
-     * @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
-     * // Simple where clause
+     * // Simple equality
      * const user = await userRepository.findOne({ email: 'user@example.com' });
      *
-     * // With include
+     * // With operators
+     * const user = await userRepository.findOne({ age: { gte: 18 } });
+     *
+     * // Multiple conditions (AND)
      * const user = await userRepository.findOne({
-     *   where: { email: 'user@example.com' },
-     *   include: { posts: true }
+     *   email: 'user@example.com',
+     *   status: 'ACTIVE'
      * });
      * ```
      */
-    findOne(where: any): Promise<TModel | null>;
+    findOne(where: RelationsWhereFilter): Promise<TSelect | undefined>;
     /**
-     * Find multiple records
+     * Find multiple records (Drizzle v2 object-based syntax)
      *
-     * @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
@@ -660,16 +763,31 @@ declare abstract class PrimaryBaseRepository<TModel, TCreateDTO = any, TUpdateDT
      * // Find all users
      * const users = await userRepository.findMany();
      *
-     * // Find with filtering and pagination
+     * // Find with filtering and pagination (v2 object syntax)
      * const users = await userRepository.findMany({
-     *   where: { status: 'ACTIVE' },
+     *   where: { accountStatus: 'ACTIVE' },
      *   orderBy: { createdAt: 'desc' },
-     *   take: 10,
-     *   skip: 0
+     *   limit: 10,
+     *   offset: 0
+     * });
+     *
+     * // Multiple conditions
+     * const users = await userRepository.findMany({
+     *   where: {
+     *     AND: [
+     *       { status: 'ACTIVE' },
+     *       { age: { gte: 18 } }
+     *     ]
+     *   }
      * });
      * ```
      */
-    findMany(args?: any): Promise<TModel[]>;
+    findMany(options?: {
+        where?: RelationsWhereFilter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
+        limit?: number;
+        offset?: number;
+    }): Promise<TSelect[]>;
     /**
      * Update a record by ID
      *
@@ -680,28 +798,30 @@ declare abstract class PrimaryBaseRepository<TModel, TCreateDTO = any, TUpdateDT
      * @example
      * ```typescript
      * const user = await userRepository.update('user-id-123', {
-     *   name: 'Jane Doe'
+     *   firstName: 'Jane'
      * });
      * ```
      */
-    update(id: string, data: TUpdateDTO): Promise<TModel>;
+    update(id: string, data: Partial<TInsert>): Promise<TSelect>;
     /**
      * 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`);
      * ```
      */
-    updateMany(where: any, data: TUpdateDTO): Promise<{
+    updateMany(where: SQL, data: Partial<TInsert>): Promise<{
         count: number;
     }>;
     /**
@@ -715,142 +835,166 @@ declare abstract class PrimaryBaseRepository<TModel, TCreateDTO = any, TUpdateDT
      * const user = await userRepository.delete('user-id-123');
      * ```
      */
-    delete(id: string): Promise<TModel>;
+    delete(id: string): Promise<TSelect>;
     /**
      * 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`);
      * ```
      */
-    deleteMany(where: any): Promise<{
+    deleteMany(where: SQL): Promise<{
         count: number;
     }>;
     /**
      * 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')
+     * );
      * ```
      */
-    count(where?: any): Promise<number>;
+    count(where?: SQL): Promise<number>;
     /**
      * 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')
+     * );
      * ```
      */
-    exists(where: any): Promise<boolean>;
+    exists(where: SQL): Promise<boolean>;
 }
 
 /**
- * Abstract base repository for tenant-scoped database operations.
+ * Type helper to extract table name from Drizzle table.
+ * TTable['_']['name'] gives us the string literal type (e.g., 'products')
+ */
+type ExtractTableName<TTable extends PgTable> = TTable['_']['name'];
+/**
+ * Abstract base repository for tenant-scoped database operations using Drizzle ORM.
  * All operations are automatically scoped to the current tenant.
  *
- * @template TModel - The Prisma model type
- * @template TCreateDTO - DTO type for create operations
- * @template TUpdateDTO - DTO type for update operations
+ * @template TTable - The Drizzle table type (must be registered in SchemaRegistry)
+ * @template TInsert - Type for insert operations (inferred from table.$inferInsert)
+ * @template TSelect - Type for select operations (inferred from table.$inferSelect)
+ *
+ * @remarks
+ * **Type Assertion Pattern:** This repository uses `as any` casts when passing
+ * the generic table to Drizzle methods. This is necessary because TypeScript
+ * cannot prove that a generic `TTable extends PgTable` satisfies Drizzle's
+ * stricter internal type requirements for `insert()`, `update()`, and `delete()`.
+ *
+ * The public API maintains full type safety:
+ * - Input parameters are typed as `TInsert` (inferred from table)
+ * - Return values are typed as `TSelect` (inferred from table)
+ * - The casts are implementation details that don't leak to consumers
  *
  * @example
  * ```typescript
- * // Using the model delegate pattern (RECOMMENDED)
- * // Type-safe, IDE autocomplete, refactor-friendly
+ * import { products } from '@/db/schema';
+ *
+ * type Product = typeof products.$inferSelect;
+ * type NewProduct = typeof products.$inferInsert;
+ *
  * @Injectable()
- * export class ProductRepository extends TenantBaseRepository<
- *   Product,
- *   CreateProductDto,
- *   UpdateProductDto
- * > {
+ * export class ProductRepository extends TenantBaseRepository<typeof products> {
  *   constructor(database: TenantDatabaseService) {
- *     super(database, (prisma) => prisma.product);  // ✅ Type-safe with autocomplete!
+ *     super(database, products);
  *   }
  *
- *   // Add custom methods as needed
+ *   // Use SQL-builder syntax
  *   async findBySku(sku: string): Promise<Product | null> {
- *     return this.model.findUnique({ where: { sku } });
+ *     const [result] = await this.db
+ *       .select()
+ *       .from(this.table)
+ *       .where(eq(products.sku, sku))
+ *       .limit(1);
+ *     return result ?? null;
  *   }
- * }
  *
- * // Short syntax is also supported
- * @Injectable()
- * export class OrderRepository extends TenantBaseRepository<Order> {
- *   constructor(database: TenantDatabaseService) {
- *     super(database, (p) => p.order);  // ✅ Concise!
- *   }
- * }
- *
- * // Works with complex model names
- * @Injectable()
- * export class InventoryItemRepository extends TenantBaseRepository<InventoryItem> {
- *   constructor(database: TenantDatabaseService) {
- *     super(database, (p) => p.inventoryItem);  // ✅ Matches Prisma naming
+ *   // Use Prisma-like relational query syntax
+ *   async findWithRelations(id: string): Promise<Product | null> {
+ *     return await this.model.findFirst({
+ *       where: eq(products.id, id),
+ *       with: { category: true, variants: true }
+ *     });
  *   }
  * }
  * ```
  */
-declare abstract class TenantBaseRepository<TModel, TCreateDTO = any, TUpdateDTO = any> {
+declare abstract class TenantBaseRepository<TTable extends PgTable, TInsert = InferInsertModel<TTable>, TSelect = InferSelectModel<TTable>> {
     protected readonly database: TenantDatabaseService;
+    protected readonly table: TTable;
     protected readonly logger: Logger;
-    private readonly 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.
+     */
+    private readonly tableName;
+    /**
+     * Lazy getter for Drizzle client.
      * Accesses the client from the database service only when needed,
      * avoiding initialization timing issues with NestJS lifecycle.
      */
-    protected get prisma(): any;
+    protected get db(): TypedDrizzleClient;
     /**
-     * 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 }
+     * });
+     * ```
      */
-    protected get model(): any;
+    protected get model(): TypedDrizzleClient['query'][ExtractTableName<TTable> & keyof TypedDrizzleClient['query']];
     /**
      * Create a new repository instance
      *
      * @param database - The tenant database service
-     * @param getModel - Function that returns the Prisma model delegate from the client
+     * @param table - The Drizzle table schema object
      *
      * @example
      * ```typescript
-     * // Standard usage with full parameter name
-     * constructor(database: TenantDatabaseService) {
-     *   super(database, (prisma) => prisma.product);
-     * }
-     *
-     * // Short syntax
-     * constructor(database: TenantDatabaseService) {
-     *   super(database, (p) => p.product);
-     * }
+     * import { products } from '@/db/schema';
      *
-     * // Complex model names
      * constructor(database: TenantDatabaseService) {
-     *   super(database, (p) => p.inventoryItem);
+     *   super(database, products);
      * }
      * ```
      */
-    constructor(database: TenantDatabaseService, getModel: (prisma: any) => any);
+    constructor(database: TenantDatabaseService, table: TTable);
     /**
      * Create a new record
      *
@@ -866,7 +1010,7 @@ declare abstract class TenantBaseRepository<TModel, TCreateDTO = any, TUpdateDTO
      * });
      * ```
      */
-    create(data: TCreateDTO): Promise<TModel>;
+    create(data: TInsert): Promise<TSelect>;
     /**
      * Find a single record by ID
      *
@@ -878,47 +1022,48 @@ declare abstract class TenantBaseRepository<TModel, TCreateDTO = any, TUpdateDTO
      * const product = await productRepository.findById('product-id-123');
      * ```
      */
-    findById(id: string): Promise<TModel | null>;
+    findById(id: string): Promise<TSelect | 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'));
      * ```
      */
-    findOne(where: any): Promise<TModel | null>;
+    findOne(where: SQL): Promise<TSelect | 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
      * });
      * ```
      */
-    findMany(args?: any): Promise<TModel[]>;
+    findMany(options?: {
+        where?: SQL;
+        orderBy?: SQL;
+        limit?: number;
+        offset?: number;
+    }): Promise<TSelect[]>;
     /**
      * Update a record by ID
      *
@@ -933,24 +1078,26 @@ declare abstract class TenantBaseRepository<TModel, TCreateDTO = any, TUpdateDTO
      * });
      * ```
      */
-    update(id: string, data: TUpdateDTO): Promise<TModel>;
+    update(id: string, data: Partial<TInsert>): Promise<TSelect>;
     /**
      * 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`);
      * ```
      */
-    updateMany(where: any, data: TUpdateDTO): Promise<{
+    updateMany(where: SQL, data: Partial<TInsert>): Promise<{
         count: number;
     }>;
     /**
@@ -964,55 +1111,62 @@ declare abstract class TenantBaseRepository<TModel, TCreateDTO = any, TUpdateDTO
      * const product = await productRepository.delete('product-id-123');
      * ```
      */
-    delete(id: string): Promise<TModel>;
+    delete(id: string): Promise<TSelect>;
     /**
      * 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`);
      * ```
      */
-    deleteMany(where: any): Promise<{
+    deleteMany(where: SQL): Promise<{
         count: number;
     }>;
     /**
      * 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')
+     * );
      * ```
      */
-    count(where?: any): Promise<number>;
+    count(where?: SQL): Promise<number>;
     /**
      * 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')
+     * );
      * ```
      */
-    exists(where: any): Promise<boolean>;
+    exists(where: SQL): Promise<boolean>;
 }
 
 declare class RequestService {
@@ -1336,7 +1490,7 @@ declare class HttpExceptionFilter implements ExceptionFilter {
     catch(exception: unknown, host: ArgumentsHost): void;
 }
 
-interface FieldError$1 {
+interface FieldError {
     field?: string;
     message: string;
 }
@@ -1346,13 +1500,9 @@ interface ProblemDetails {
     detail: string;
 }
 interface ApiErrorResponse extends ProblemDetails {
-    errors: FieldError$1[];
+    errors: FieldError[];
 }
 
-interface FieldError {
-    field?: string;
-    message: string;
-}
 declare abstract class BaseFieldException extends HttpException {
     constructor(statusOrMessageOrErrors: HttpStatus | string | FieldError[], messageOrStatus?: string | HttpStatus, statusOrDetail?: HttpStatus | string, detail?: string);
 }
@@ -2167,4 +2317,4 @@ declare function generateCorrelationId(): string;
  */
 declare function addCorrelationIdToResponse(reply: FastifyReply, correlationId: string, headerName?: string): void;
 
-export { type ApiErrorResponse, AuthConfigModule, BadGatewayException, BadRequestException, BaseFieldException, ConflictException, type CorrelationContext, CorrelationIdMiddleware, CsrfGuard, DEFAULT_CORRELATION_HEADER, DatabaseModule, type DatabaseModuleOptions, type FieldError, ForbiddenException, GoneException, HttpExceptionFilter, HttpLoggerInterceptor, type HttpLoggerOptions, HttpModule, InternalServerErrorException, LOGGER_MODULE_OPTIONS, type LogFormat, type LogLevel, type LogMetadata, LoggerModule, type LoggerModuleAsyncOptions, type LoggerModuleOptions, type LoggerOptionsFactory, LoggerService, MethodNotAllowedException, NotAcceptableException, NotFoundException, NotImplementedException, Onboarding, PayloadTooLargeException, PrimaryBaseRepository, PrimaryDatabaseService, type PrimaryDbConfig, type ProblemDetails, Public, RequestTimeoutException, ServiceUnavailableException, Tenant, TenantBaseRepository, TenantContextService, TenantDatabaseService, type TenantInfo, TooManyRequestsException, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, ValidationException, VrittiAuthGuard, addCorrelationIdToResponse, correlationStorage, generateCorrelationId, getCorrelationContext, getHttpStatusTitle, runWithCorrelationContext, updateCorrelationContext };
+export { type ApiErrorResponse, AuthConfigModule, BadGatewayException, BadRequestException, BaseFieldException, ConflictException, type CorrelationContext, CorrelationIdMiddleware, CsrfGuard, DEFAULT_CORRELATION_HEADER, DatabaseModule, type DatabaseModuleOptions, type FieldError, ForbiddenException, GoneException, HttpExceptionFilter, HttpLoggerInterceptor, type HttpLoggerOptions, HttpModule, InternalServerErrorException, LOGGER_MODULE_OPTIONS, type LogFormat, type LogLevel, type LogMetadata, LoggerModule, type LoggerModuleAsyncOptions, type LoggerModuleOptions, type LoggerOptionsFactory, LoggerService, MethodNotAllowedException, NotAcceptableException, NotFoundException, NotImplementedException, Onboarding, PayloadTooLargeException, PrimaryBaseRepository, PrimaryDatabaseService, type PrimaryDbConfig, type ProblemDetails, Public, type RegisteredSchema, RequestTimeoutException, type SchemaRegistry, ServiceUnavailableException, Tenant, TenantBaseRepository, TenantContextService, TenantDatabaseService, type TenantInfo, TooManyRequestsException, type TypedDrizzleClient, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, ValidationException, VrittiAuthGuard, addCorrelationIdToResponse, correlationStorage, generateCorrelationId, getCorrelationContext, getHttpStatusTitle, runWithCorrelationContext, updateCorrelationContext };