@vritti/api-sdk 0.0.8 → 0.1.0

package/dist/index.d.cts

@@ -1,9 +1,14 @@
 import * as _nestjs_common from '@nestjs/common';
-import { DynamicModule, OnModuleDestroy, OnModuleInit, Logger, CanActivate, ExecutionContext, ExceptionFilter, ArgumentsHost, HttpException, HttpStatus } 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';
-import { FastifyRequest } from 'fastify';
+import { FastifyRequest, FastifyReply } from 'fastify';
+import { Observable } from 'rxjs';
+import { AsyncLocalStorage } from 'node:async_hooks';
 
 /**
  * Global authentication configuration module
@@ -79,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
  */
@@ -95,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
@@ -118,11 +151,11 @@ 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 and relations
+     * Import your schema from db/schema/index.ts and pass it here
+     * @example import * as schema from '@/db/schema'
      */
-    prismaClientConstructor: any;
+    drizzleSchema: RegisteredSchema;
     /**
      * Connection cache TTL in milliseconds
      * Idle connections will be closed after this period
@@ -354,7 +387,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
@@ -362,14 +395,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;
@@ -377,14 +410,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
      *
@@ -393,21 +430,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;
     /**
@@ -453,8 +486,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 */
@@ -462,9 +497,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
      */
@@ -474,9 +509,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>;
@@ -489,7 +524,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;
     /**
@@ -497,13 +532,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
      *
@@ -517,90 +556,123 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
 }
 
 /**
- * Abstract base repository for primary database operations.
+ * Type-safe wrapper for Drizzle's RelationalQueryBuilder.
+ * 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.
+ */
+interface TypedRelationalQueryBuilder<TSelect> {
+    findFirst(config?: {
+        where?: SQL;
+        with?: Record<string, unknown>;
+        columns?: Record<string, boolean>;
+    }): Promise<TSelect | undefined>;
+    findMany(config?: {
+        where?: SQL;
+        orderBy?: SQL;
+        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 Prisma-like relational query syntax (recommended)
+ *   async findByEmail(email: string): Promise<User | undefined> {
+ *     return this.model.findFirst({
+ *       where: eq(users.email, email),
+ *     });
+ *   }
+ *
+ *   // Use Prisma-like with relations
+ *   async findWithRelations(id: string): Promise<User | undefined> {
+ *     return this.model.findFirst({
+ *       where: eq(users.id, 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 (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 }
+     * });
+     * ```
      */
-    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
      *
@@ -611,63 +683,64 @@ 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
      *
-     * @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'));
      * ```
      */
-    findOne(where: any): Promise<TModel | null>;
+    findOne(where: SQL): Promise<TSelect | undefined>;
     /**
      * 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
      * });
      * ```
      */
-    findMany(args?: any): Promise<TModel[]>;
+    findMany(options?: {
+        where?: SQL;
+        orderBy?: SQL;
+        limit?: number;
+        offset?: number;
+    }): Promise<TSelect[]>;
     /**
      * Update a record by ID
      *
@@ -678,28 +751,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;
     }>;
     /**
@@ -713,142 +788,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);
-     * }
+     * 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: TenantDatabaseService, getModel: (prisma: any) => any);
+    constructor(database: TenantDatabaseService, table: TTable);
     /**
      * Create a new record
      *
@@ -864,7 +963,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
      *
@@ -876,47 +975,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
      *
@@ -931,24 +1031,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;
     }>;
     /**
@@ -962,55 +1064,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 {
@@ -1334,7 +1443,7 @@ declare class HttpExceptionFilter implements ExceptionFilter {
     catch(exception: unknown, host: ArgumentsHost): void;
 }
 
-interface FieldError$1 {
+interface FieldError {
     field?: string;
     message: string;
 }
@@ -1344,13 +1453,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);
 }
@@ -1764,4 +1869,405 @@ declare class BadGatewayException extends BaseFieldException {
     constructor(messageOrField: string | FieldError[], fieldMessageOrDetail?: string, detail?: string);
 }
 
-export { type ApiErrorResponse, AuthConfigModule, BadGatewayException, BadRequestException, BaseFieldException, ConflictException, CsrfGuard, DatabaseModule, type DatabaseModuleOptions, type FieldError, ForbiddenException, GoneException, HttpExceptionFilter, HttpModule, InternalServerErrorException, 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, getHttpStatusTitle };
+/**
+ * Supported log levels for the logging system.
+ */
+type LogLevel = 'error' | 'warn' | 'log' | 'debug' | 'verbose';
+/**
+ * Supported log output formats.
+ */
+type LogFormat = 'json' | 'text';
+/**
+ * Metadata that can be attached to log entries.
+ */
+interface LogMetadata {
+    correlationId?: string;
+    method?: string;
+    url?: string;
+    statusCode?: number;
+    duration?: number;
+    ip?: string;
+    userAgent?: string;
+    [key: string]: unknown;
+}
+/**
+ * Configuration options for the logger module.
+ */
+interface LoggerModuleOptions {
+    provider?: 'default' | 'winston';
+    level?: LogLevel;
+    format?: LogFormat;
+    enableFileLogger?: boolean;
+    filePath?: string;
+    maxFiles?: string;
+    enableCorrelationId?: boolean;
+    enableHttpLogger?: boolean;
+    httpLogger?: HttpLoggerOptions;
+    appName?: string;
+    environment?: string;
+    defaultMeta?: Record<string, unknown>;
+}
+/**
+ * Factory function for creating logger options asynchronously.
+ */
+interface LoggerOptionsFactory {
+    createLoggerOptions(): Promise<LoggerModuleOptions> | LoggerModuleOptions;
+}
+/**
+ * Async configuration options for the logger module.
+ */
+interface LoggerModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<LoggerOptionsFactory>;
+    useClass?: Type<LoggerOptionsFactory>;
+    useFactory?: (...args: unknown[]) => Promise<LoggerModuleOptions> | LoggerModuleOptions;
+    inject?: unknown[];
+}
+/**
+ * Context object for correlation tracking across async operations.
+ */
+interface CorrelationContext {
+    correlationId: string;
+    [key: string]: unknown;
+}
+/**
+ * Configuration options for HTTP request/response logger interceptor.
+ */
+interface HttpLoggerOptions {
+    enableRequestLog?: boolean;
+    enableResponseLog?: boolean;
+    enableRequestBodyLog?: boolean;
+    enableResponseBodyLog?: boolean;
+    slowRequestThreshold?: number;
+    excludedRoutes?: string[];
+    maskedHeaders?: string[];
+    maxBodySize?: number;
+}
+
+/**
+ * Logger Module
+ *
+ * Dynamic NestJS module providing unified logging infrastructure with:
+ * - Environment presets (development, staging, production, test)
+ * - Transparent switching between default NestJS Logger and Winston
+ * - Correlation ID tracking via middleware
+ * - HTTP request/response logging via interceptor
+ * - PII masking and file logging support
+ *
+ * @module logger/logger.module
+ */
+
+/**
+ * Dependency injection token for logger module options
+ */
+declare const LOGGER_MODULE_OPTIONS: unique symbol;
+/**
+ * Global logger module providing unified logging infrastructure.
+ *
+ * Features:
+ * - Environment presets (development, staging, production, test)
+ * - Single `LoggerService` interface for all logging needs
+ * - Transparent provider switching (default ↔ Winston)
+ * - Correlation ID tracking across async operations
+ * - HTTP request/response logging
+ * - PII masking for GDPR compliance
+ * - File-based logging with rotation
+ *
+ * @example
+ * ```typescript
+ * // Production environment with explicit config
+ * @Module({
+ *   imports: [
+ *     LoggerModule.forRoot({
+ *       environment: 'production',
+ *       appName: 'my-service'
+ *     })
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * // Development environment with custom override
+ * @Module({
+ *   imports: [
+ *     LoggerModule.forRoot({
+ *       environment: 'development',
+ *       level: 'verbose'  // Override preset's debug
+ *     })
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * // Use default NestJS logger
+ * @Module({
+ *   imports: [
+ *     LoggerModule.forRoot({
+ *       provider: 'default',
+ *       environment: 'development'
+ *     })
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * // Dynamic configuration with ConfigService
+ * @Module({
+ *   imports: [
+ *     LoggerModule.forRootAsync({
+ *       imports: [ConfigModule],
+ *       useFactory: (config: ConfigService) => ({
+ *         environment: config.get('NODE_ENV', 'development'),
+ *         provider: config.get('LOG_PROVIDER', 'winston'),
+ *         appName: config.get('APP_NAME')
+ *       }),
+ *       inject: [ConfigService]
+ *     })
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class LoggerModule implements NestModule {
+    /**
+     * Configures the logger module with static options.
+     *
+     * Users must explicitly pass `environment` to select a preset.
+     * All preset values can be overridden by passing explicit options.
+     *
+     * @param options - Logger configuration options
+     * @returns Dynamic module configuration
+     *
+     * @example
+     * ```typescript
+     * // Production preset with app name
+     * LoggerModule.forRoot({
+     *   environment: 'production',
+     *   appName: 'my-service'
+     * })
+     *
+     * // Development preset with custom level
+     * LoggerModule.forRoot({
+     *   environment: 'development',
+     *   level: 'verbose',
+     *   enableFileLogger: true
+     * })
+     *
+     * // Use default NestJS logger
+     * LoggerModule.forRoot({
+     *   provider: 'default',
+     *   environment: 'development'
+     * })
+     * ```
+     */
+    static forRoot(options?: LoggerModuleOptions): DynamicModule;
+    /**
+     * Configures the logger module with async options.
+     *
+     * Supports dynamic configuration using:
+     * - `useFactory`: Factory function with dependency injection
+     * - `useClass`: Class implementing `LoggerOptionsFactory`
+     * - `useExisting`: Existing provider implementing `LoggerOptionsFactory`
+     *
+     * Options from the factory/class are merged with environment preset defaults.
+     *
+     * @param options - Async configuration options
+     * @returns Dynamic module configuration
+     *
+     * @example
+     * ```typescript
+     * // Factory with ConfigService
+     * LoggerModule.forRootAsync({
+     *   imports: [ConfigModule],
+     *   useFactory: (config: ConfigService) => ({
+     *     environment: config.get('NODE_ENV', 'development'),
+     *     provider: config.get('LOG_PROVIDER', 'winston'),
+     *     level: config.get('LOG_LEVEL'),
+     *     appName: config.get('APP_NAME'),
+     *   }),
+     *   inject: [ConfigService]
+     * })
+     *
+     * // Factory class
+     * @Injectable()
+     * class LoggerConfigService implements LoggerOptionsFactory {
+     *   createLoggerOptions(): LoggerModuleOptions {
+     *     return {
+     *       environment: 'production',
+     *       appName: 'my-service'
+     *     };
+     *   }
+     * }
+     *
+     * LoggerModule.forRootAsync({
+     *   useClass: LoggerConfigService
+     * })
+     * ```
+     */
+    static forRootAsync(options: LoggerModuleAsyncOptions): DynamicModule;
+    /**
+     * Configures middleware for the module.
+     * Middleware is registered globally in main.ts using Fastify hooks.
+     */
+    configure(consumer: MiddlewareConsumer): void;
+    /**
+     * Creates async providers for dynamic module configuration.
+     */
+    private static createAsyncProviders;
+    /**
+     * Creates the async options provider.
+     */
+    private static createAsyncOptionsProvider;
+}
+
+/**
+ * Unified Logger Service
+ *
+ * Single service that provides both default NestJS Logger and Winston logger implementations.
+ * Automatically delegates to the configured provider (default or winston).
+ * @module logger/logger.service
+ */
+
+/**
+ * Unified logger service implementing NestJS LoggerService interface.
+ * Supports both default NestJS Logger and Winston implementations via facade pattern.
+ */
+declare class LoggerService implements LoggerService$1 {
+    private readonly defaultLogger?;
+    private readonly activeLogger;
+    private readonly options;
+    private context?;
+    constructor(options?: LoggerModuleOptions, defaultLogger?: Logger | undefined);
+    /**
+     * Creates a Winston logger instance with inline configuration.
+     * Consolidates winston-config.factory.ts logic.
+     */
+    private createWinstonLogger;
+    log(message: any, context?: string): void;
+    error(message: any, trace?: string, context?: string): void;
+    warn(message: any, context?: string): void;
+    debug(message: any, context?: string): void;
+    verbose(message: any, context?: string): void;
+    setContext(context: string): void;
+    /**
+     * Unified internal logging method that handles both Winston and NestJS Logger.
+     */
+    private _log;
+    /**
+     * Logs with custom metadata (Winston only).
+     */
+    logWithMetadata(level: LogLevel, message: any, metadata?: LogMetadata, context?: string): void;
+    private formatMessage;
+    /**
+     * Enriches metadata with correlation context from AsyncLocalStorage.
+     * Inline from winston-logger.service.ts
+     */
+    private enrichMetadata;
+    child(context: string): LoggerService;
+}
+
+/**
+ * Correlation ID Middleware
+ *
+ * Generates unique correlation IDs for request tracking across async operations.
+ * Stores correlation ID in AsyncLocalStorage for access throughout the request lifecycle.
+ * @module logger/correlation-id.middleware
+ */
+
+/**
+ * Configuration options for the Correlation ID middleware.
+ */
+interface CorrelationIdMiddlewareOptions {
+    /**
+     * If true, adds the correlation ID to response headers.
+     * @default true
+     */
+    includeInResponse?: boolean;
+    /**
+     * The header name to use when adding correlation ID to response.
+     * @default 'x-correlation-id'
+     */
+    responseHeader?: string;
+}
+/**
+ * Correlation ID Middleware for Fastify/NestJS applications.
+ *
+ * Generates a unique correlation ID for each request,
+ * stores it in AsyncLocalStorage for access throughout the request lifecycle,
+ * and optionally adds it to response headers.
+ */
+declare class CorrelationIdMiddleware implements NestMiddleware {
+    private readonly includeInResponse;
+    private readonly responseHeader;
+    constructor(options?: CorrelationIdMiddlewareOptions);
+    /**
+     * Middleware handler for processing requests.
+     */
+    use(req: FastifyRequest, reply: FastifyReply, next: () => void): void;
+    /**
+     * Fastify hook handler for onRequest.
+     * This is an async function that returns a Promise, ensuring the AsyncLocalStorage
+     * context persists throughout the entire request lifecycle.
+     */
+    onRequest(req: FastifyRequest, reply: FastifyReply): Promise<void>;
+}
+
+/**
+ * HTTP Logger Interceptor
+ *
+ * Automatically logs HTTP requests and responses with correlation tracking.
+ * @module logger/http-logger.interceptor
+ */
+
+/**
+ * HTTP Logger Interceptor for NestJS applications.
+ *
+ * Logs all HTTP requests and responses with metadata including
+ * correlation IDs, performance metrics, and error details.
+ */
+declare class HttpLoggerInterceptor implements NestInterceptor {
+    private readonly logger;
+    private readonly enableRequestLog;
+    private readonly enableResponseLog;
+    private readonly slowRequestThreshold;
+    constructor(logger: LoggerService, options?: HttpLoggerOptions);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    private logRequest;
+    private logResponse;
+    private logError;
+}
+
+/**
+ * Logging Utilities
+ *
+ * Consolidated utilities for correlation tracking, PII masking, and async context management.
+ * @module logging/utils
+ */
+
+/**
+ * Async local storage for correlation context tracking across async operations.
+ */
+declare const correlationStorage: AsyncLocalStorage<CorrelationContext>;
+/**
+ * Gets the current correlation context from async local storage.
+ */
+declare function getCorrelationContext(): CorrelationContext | undefined;
+/**
+ * Runs a callback within a correlation context.
+ */
+declare function runWithCorrelationContext<T>(context: CorrelationContext, callback: () => T): T;
+/**
+ * Updates the current correlation context with new values.
+ */
+declare function updateCorrelationContext(updates: Partial<CorrelationContext>): void;
+/**
+ * Default header name for setting correlation ID in responses.
+ */
+declare const DEFAULT_CORRELATION_HEADER = "x-correlation-id";
+/**
+ * Generates a new correlation ID using UUID v4.
+ * Always creates a fresh ID for each request.
+ */
+declare function generateCorrelationId(): string;
+/**
+ * Adds correlation ID to Fastify response headers.
+ */
+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, 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 };