@plyaz/db 0.0.0

package/dist/extensions/CachingAdapter.d.ts

@@ -0,0 +1,451 @@
+import type { DatabaseAdapterType, DatabaseResult, DBCacheConfig, Filter, DatabaseHealthStatus, PaginatedResult, QueryOptions, Transaction } from "@plyaz/types/db";
+/**
+ * CACHING ADAPTER - Query Result Caching Layer
+ *
+ * Caching extension that stores query results in memory for improved performance.
+ * Third layer in the adapter chain.
+ *
+ * **Adapter Chain Position:**
+ * ReadReplica → Audit → **Cache** → SoftDelete → Encryption → Base Adapter
+ *
+ * **What this adapter does:**
+ * 1. Intercepts findById() operations → checks cache first, stores results
+ * 2. Intercepts write operations → invalidates related cache entries
+ * 3. Manages TTL-based cache expiration
+ * 4. Honors cache configuration (enabled, ttl, invalidation strategy)
+ *
+ * **Called by:** AuditAdapter (or ReadReplicaAdapter if no audit)
+ * **Calls:** SoftDeleteAdapter (or next adapter in chain)
+ * **Cache Strategy:** In-memory Map with TTL expiration
+ *
+ * **Cache Flow:**
+ * - **READ:** Check cache → Return if hit → Query DB → Cache result
+ * - **WRITE:** Execute operation → Invalidate related cache entries
+ *
+ * @example
+ * ### Configuration
+ * ```typescript
+ * cache: {
+ *   enabled: true,
+ *   ttl: 300,                    // 5 minutes
+ *   invalidation: 'write',       // Invalidate on writes
+ *   maxSize: 1000               // Max cache entries
+ * }
+ * ```
+ *
+ * @example
+ * ### Cache Behavior
+ * ```typescript
+ * // First call - cache miss, queries database
+ * const user1 = await db.findById('users', 'user-123'); // DB query
+ *
+ * // Second call - cache hit, returns from memory
+ * const user2 = await db.findById('users', 'user-123'); // Cache hit
+ *
+ * // Write operation invalidates cache
+ * await db.update('users', 'user-123', { name: 'New Name' });
+ *
+ * // Next read - cache miss again, queries database
+ * const user3 = await db.findById('users', 'user-123'); // DB query
+ * ```
+ */
+export declare class CachingAdapter implements DatabaseAdapterType {
+    private baseAdapter;
+    private config;
+    private cache;
+    /**
+     * Creates a new CachingAdapter instance.
+     *
+     * **RESPONSIBILITY:** Wraps base adapter with caching functionality
+     * **CONFIGURATION:** Sets up cache TTL, invalidation strategy, and size limits
+     *
+     * @param baseAdapter - The underlying database adapter to wrap
+     * @param config - Cache configuration options
+     *
+     * @example
+     * ```typescript
+     * const cachingAdapter = new CachingAdapter(baseAdapter, {
+     *   enabled: true,
+     *   ttl: 300,                    // 5 minutes
+     *   invalidation: 'write',       // Invalidate on writes
+     *   maxSize: 1000               // Max entries
+     * });
+     * ```
+     */
+    constructor(baseAdapter: DatabaseAdapterType, config: DBCacheConfig);
+    /**
+     * Initializes the caching adapter and underlying adapter.
+     *
+     * **RESPONSIBILITY:** Passes initialization to base adapter
+     * **BEHAVIOR:** No additional initialization needed for caching
+     *
+     * @returns Promise resolving to initialization result
+     *
+     * @example
+     * ```typescript
+     * const result = await cachingAdapter.initialize();
+     * if (result.success) {
+     *   console.log('Caching adapter initialized');
+     * }
+     * ```
+     */
+    initialize(): Promise<DatabaseResult<void>>;
+    /**
+     * Establishes database connection through base adapter.
+     *
+     * **RESPONSIBILITY:** Delegates connection to underlying adapter
+     * **BEHAVIOR:** No additional connection logic needed
+     *
+     * @example
+     * ```typescript
+     * await cachingAdapter.connect();
+     * console.log('Connected with caching support');
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Closes database connection through base adapter.
+     *
+     * **RESPONSIBILITY:** Delegates disconnection to underlying adapter
+     * **BEHAVIOR:** Cache is cleared on disconnect
+     *
+     * @example
+     * ```typescript
+     * await cachingAdapter.disconnect();
+     * console.log('Disconnected and cache cleared');
+     * ```
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Gets the underlying database client.
+     *
+     * **RESPONSIBILITY:** Provides access to raw database client
+     * **USE CASE:** For operations that bypass caching
+     *
+     * @returns Database client object
+     *
+     * @example
+     * ```typescript
+     * const client = cachingAdapter.getClient();
+     * // Use for direct database operations if needed
+     * ```
+     */
+    getClient(): object;
+    /**
+     * Executes raw SQL query through base adapter.
+     *
+     * **RESPONSIBILITY:** Passes raw SQL to base adapter without caching
+     * **BEHAVIOR:** Does not cache raw SQL results
+     * **NOTE:** Use findById/findMany for automatic caching
+     *
+     * @param sql - SQL query string
+     * @param params - Query parameters
+     * @returns Query results
+     *
+     * @example
+     * ```typescript
+     * // Raw SQL bypasses caching
+     * const results = await adapter.query(
+     *   'SELECT * FROM users WHERE status = $1',
+     *   ['active']
+     * );
+     *
+     * // Use findMany for automatic caching
+     * const users = await adapter.findMany('users', { filter: ... });
+     * ```
+     */
+    query<T>(sql: string, params?: T[]): Promise<T[]>;
+    /**
+     * Registers a table schema with the base adapter.
+     *
+     * **RESPONSIBILITY:** Passes table registration to base adapter
+     * **BEHAVIOR:** No additional registration logic needed
+     *
+     * @param name - Table name
+     * @param table - Table schema
+     * @param idColumn - Primary key column
+     *
+     * @example
+     * ```typescript
+     * cachingAdapter.registerTable('users', userSchema, 'id');
+     * // Table now supports cached operations
+     * ```
+     */
+    registerTable<T, U>(name: string, table: T, idColumn?: U): void;
+    findById<T>(table: string, id: string): Promise<DatabaseResult<T | null>>;
+    /**
+     * Finds multiple records without caching.
+     *
+     * **RESPONSIBILITY:** Retrieves multiple records, bypassing cache
+     * **BEHAVIOR:** Complex queries are not cached currently
+     * **FUTURE:** Could implement query result caching with cache keys
+     *
+     * @param table - Table name
+     * @param options - Query options
+     * @returns Paginated results
+     *
+     * @example
+     * ```typescript
+     * // Complex queries bypass cache (for now)
+     * const users = await adapter.findMany('users', {
+     *   filter: { field: 'status', operator: 'eq', value: 'active' },
+     *   pagination: { page: 1, limit: 10 },
+     *   sort: { field: 'name', direction: 'asc' }
+     * });
+     *
+     * // Always queries database directly
+     * ```
+     */
+    findMany<T>(table: string, options?: QueryOptions): Promise<DatabaseResult<PaginatedResult<T>>>;
+    /**
+     * Creates a new record with cache invalidation.
+     *
+     * **RESPONSIBILITY:** Creates record and invalidates related cache entries
+     * **INVALIDATION:** Clears table cache on successful write
+     * **STRATEGY:** Based on config.invalidation setting
+     *
+     * @param table - Table name
+     * @param data - Record data
+     * @returns Created record
+     *
+     * @example
+     * ```typescript
+     * // Create user - invalidates users table cache
+     * const result = await adapter.create('users', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com'
+     * });
+     *
+     * if (result.success) {
+     *   console.log('User created:', result.value.id);
+     *   // All cached users:* entries are now invalid
+     * }
+     * ```
+     */
+    create<T>(table: string, data: T): Promise<DatabaseResult<T>>;
+    /**
+     * Updates an existing record with cache invalidation.
+     *
+     * **RESPONSIBILITY:** Updates record and invalidates related cache entries
+     * **INVALIDATION:** Clears specific record and table cache
+     * **STRATEGY:** Invalidates both table:id and table:* patterns
+     *
+     * @param table - Table name
+     * @param id - Record ID
+     * @param data - Partial record data
+     * @returns Updated record
+     *
+     * @example
+     * ```typescript
+     * // Update user - invalidates specific cache entry
+     * const result = await adapter.update('users', 'user-123', {
+     *   name: 'Jane Doe'
+     * });
+     *
+     * if (result.success) {
+     *   console.log('User updated:', result.value.name);
+     *   // Cache entries users:user-123 and users:* are invalidated
+     * }
+     * ```
+     */
+    update<T>(table: string, id: string, data: Partial<T>): Promise<DatabaseResult<T>>;
+    /**
+     * Deletes a record with cache invalidation.
+     *
+     * **RESPONSIBILITY:** Deletes record and invalidates related cache entries
+     * **INVALIDATION:** Clears specific record and table cache
+     * **STRATEGY:** Removes both table:id and table:* patterns
+     *
+     * @param table - Table name
+     * @param id - Record ID
+     * @returns Deletion result
+     *
+     * @example
+     * ```typescript
+     * // Delete user - invalidates cache entries
+     * const result = await adapter.delete('users', 'user-123');
+     *
+     * if (result.success) {
+     *   console.log('User deleted successfully');
+     *   // Cache entries users:user-123 and users:* are invalidated
+     * }
+     * ```
+     */
+    delete(table: string, id: string): Promise<DatabaseResult<void>>;
+    /**
+     * Executes operations within a transaction.
+     *
+     * **RESPONSIBILITY:** Passes transaction to base adapter
+     * **BEHAVIOR:** Cache invalidation happens per operation within transaction
+     * **ATOMICITY:** Cache invalidation is not rolled back if transaction fails
+     *
+     * @param callback - Transaction callback function
+     * @returns Transaction result
+     *
+     * @example
+     * ```typescript
+     * const result = await adapter.transaction(async (trx) => {
+     *   // Each operation invalidates cache independently
+     *   const user = await trx.create('users', { name: 'John' });
+     *   await trx.update('profiles', 'profile-1', { userId: user.id });
+     *   return user;
+     * });
+     *
+     * // Cache invalidation happens even if transaction fails
+     * ```
+     */
+    transaction<T>(callback: (trx: Transaction) => Promise<T>): Promise<DatabaseResult<T>>;
+    /**
+     * Checks if a record exists without caching.
+     *
+     * **RESPONSIBILITY:** Verifies record existence, bypassing cache
+     * **BEHAVIOR:** Existence checks are not cached currently
+     * **PERFORMANCE:** Always queries database for existence
+     *
+     * @param table - Table name
+     * @param id - Record ID
+     * @returns True if record exists
+     *
+     * @example
+     * ```typescript
+     * // Existence checks bypass cache
+     * const userExists = await adapter.exists('users', 'user-123');
+     * if (userExists.value) {
+     *   console.log('User exists');
+     * }
+     *
+     * // Always queries database directly
+     * ```
+     */
+    exists(table: string, id: string): Promise<DatabaseResult<boolean>>;
+    /**
+     * Counts records without caching.
+     *
+     * **RESPONSIBILITY:** Counts records, bypassing cache
+     * **BEHAVIOR:** Count operations are not cached currently
+     * **PERFORMANCE:** Always queries database for counts
+     *
+     * @param table - Table name
+     * @param filter - Optional filter conditions
+     * @returns Count of records
+     *
+     * @example
+     * ```typescript
+     * // Count operations bypass cache
+     * const activeUsers = await adapter.count('users', {
+     *   field: 'status',
+     *   operator: 'eq',
+     *   value: 'active'
+     * });
+     *
+     * console.log('Active users:', activeUsers.value);
+     * // Always queries database directly
+     * ```
+     */
+    count(table: string, filter?: Filter): Promise<DatabaseResult<number>>;
+    /**
+     * Performs health check through base adapter.
+     *
+     * **RESPONSIBILITY:** Delegates health check to underlying adapter
+     * **BEHAVIOR:** No additional health metrics for cache
+     *
+     * @returns Health status from base adapter
+     *
+     * @example
+     * ```typescript
+     * const health = await adapter.healthCheck();
+     * if (health.success && health.value?.isHealthy) {
+     *   console.log('Database healthy with caching support');
+     * }
+     * ```
+     */
+    healthCheck(): Promise<DatabaseResult<DatabaseHealthStatus>>;
+    /**
+     * Retrieves value from cache with TTL validation.
+     *
+     * **RESPONSIBILITY:** Gets cached value and validates expiration
+     * **TTL HANDLING:** Removes expired entries automatically
+     * **RETURN:** Cached value or null if not found/expired
+     *
+     * @private
+     * @param key - Cache key to retrieve
+     * @returns Cached value or null
+     *
+     * @example
+     * ```typescript
+     * // Internal usage
+     * const user = this.getFromCache<User>('users:user-123');
+     * if (user) {
+     *   console.log('Cache hit:', user.name);
+     * } else {
+     *   console.log('Cache miss or expired');
+     * }
+     * ```
+     */
+    private getFromCache;
+    /**
+     * Stores value in cache with TTL expiration.
+     *
+     * **RESPONSIBILITY:** Caches value with calculated expiration time
+     * **TTL:** Uses config.ttl or default 5 minutes (300 seconds)
+     * **EXPIRY:** Calculates absolute expiration timestamp
+     *
+     * @private
+     * @param key - Cache key to store
+     * @param value - Value to cache
+     *
+     * @example
+     * ```typescript
+     * // Internal usage after database query
+     * this.setCache('users:user-123', userData);
+     *
+     * // Value will expire after TTL seconds
+     * // Default: 5 minutes from now
+     * ```
+     */
+    private setCache;
+    /**
+     * Removes specific key from cache.
+     *
+     * **RESPONSIBILITY:** Invalidates single cache entry
+     * **USE CASE:** Called after record updates/deletes
+     * **PATTERN:** Removes exact key match
+     *
+     * @private
+     * @param key - Cache key to invalidate
+     *
+     * @example
+     * ```typescript
+     * // Internal usage after record update
+     * this.invalidateKey('users:user-123');
+     *
+     * // Only users:user-123 is removed from cache
+     * // Other users:* entries remain cached
+     * ```
+     */
+    private invalidateKey;
+    /**
+     * Removes all cache entries for a table.
+     *
+     * **RESPONSIBILITY:** Invalidates all entries matching table pattern
+     * **USE CASE:** Called after any write operation to table
+     * **PATTERN:** Removes all keys starting with 'table:'
+     *
+     * @private
+     * @param table - Table name to invalidate
+     *
+     * @example
+     * ```typescript
+     * // Internal usage after any write to users table
+     * this.invalidateTable('users');
+     *
+     * // Removes all cache entries:
+     * // - users:user-123
+     * // - users:user-456
+     * // - users:admin-789
+     * // But keeps: profiles:profile-1, posts:post-1, etc.
+     * ```
+     */
+    private invalidateTable;
+}
+//# sourceMappingURL=CachingAdapter.d.ts.map

package/dist/extensions/CachingAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CachingAdapter.d.ts","sourceRoot":"","sources":["../../src/extensions/CachingAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,aAAa,EACb,MAAM,EACN,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,WAAW,EACZ,MAAM,iBAAiB,CAAC;AACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,cAAe,YAAW,mBAAmB;IA+BtD,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IA/BhB,OAAO,CAAC,KAAK,CAQT;IAEJ;;;;;;;;;;;;;;;;;;OAkBG;gBAEO,WAAW,EAAE,mBAAmB,EAChC,MAAM,EAAE,aAAa;IAG/B;;;;;;;;;;;;;;;OAeG;IACG,UAAU,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAIjD;;;;;;;;;;;OAWG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;;;;;;;;;;OAWG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;;;;;;;;;;;;OAaG;IACH,SAAS,IAAI,MAAM;IAInB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAIvD;;;;;;;;;;;;;;;OAeG;IACH,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI;IAIzD,QAAQ,CAAC,CAAC,EACd,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAuBpC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,QAAQ,CAAC,CAAC,EACd,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAK9C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAUnE;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,MAAM,CAAC,CAAC,EACZ,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GACf,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAW7B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAWtE;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,WAAW,CAAC,CAAC,EACjB,QAAQ,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GACzC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAI7B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAIzE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAI5E;;;;;;;;;;;;;;;OAeG;IACG,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;IAIlE;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,YAAY;IAYpB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,QAAQ;IAWhB;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,eAAe;CAOxB"}

package/dist/extensions/EncryptionExtension.d.ts

@@ -0,0 +1,95 @@
+import { type DatabaseAdapterType, type DatabaseResult, type QueryOptions, type PaginatedResult, type Transaction, type Filter, type DatabaseHealthStatus } from "@plyaz/types/db";
+/**
+ * ENCRYPTION ADAPTER — Field-Level Encryption Layer
+ *
+ * Encryption extension that automatically encrypts/decrypts specified fields.
+ * Second layer in the adapter chain (after the base adapter).
+ *
+ * **Adapter Chain Position:**
+ * ReadReplica → Audit → Cache → SoftDelete → **Encryption** → Base Adapter
+ *
+ * **What this adapter does:**
+ * 1. Receives operations from SoftDeleteAdapter (or the next layer)
+ * 2. Encrypts sensitive fields before write operations (create, update)
+ * 3. Delegates to the base adapter with encrypted data
+ * 4. Decrypts fields in response data after read operations
+ * 5. Passes results back up the chain
+ *
+ * **Called by:** SoftDeleteAdapter (or CachingAdapter if no soft delete)
+ * **Calls:** Base adapter methods (DrizzleAdapter, SupabaseAdapter, etc.)
+ * **Wraps:** Base database adapter with transparent encryption
+ *
+ * **Encryption Flow:**
+ * - **Writes:** Plain data → Encrypt fields → Store encrypted → Return decrypted
+ * - **Reads:** Retrieve encrypted → Decrypt fields → Return plain data
+ *
+ * @example
+ * ### Configuration
+ * ```typescript
+ * encryption: {
+ *   enabled: true,
+ *   key: process.env.ENCRYPTION_KEY,
+ *   fields: {
+ *     [Tables.USERS]: ['ssn', 'taxId'],
+ *     [Tables.PAYMENTS]: ['cardNumber', 'cvv']
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Transparent Usage
+ * ```typescript
+ * // Application code — encryption is transparent
+ * await db.create(Tables.USERS, {
+ *   name: 'John Doe',
+ *   ssn: '123-45-6789'  // Automatically encrypted before storage
+ * });
+ *
+ * // Retrieved data is automatically decrypted
+ * const user = await db.get(Tables.USERS, userId);
+ * console.log(user.value.ssn); // '123-45-6789' (decrypted)
+ * ```
+ */
+export declare class EncryptionAdapter implements DatabaseAdapterType {
+    private baseAdapter;
+    private config;
+    constructor(baseAdapter: DatabaseAdapterType, config: {
+        enabled: boolean;
+        key: string;
+        fields: Record<string, string[]>;
+        algorithm?: string;
+    });
+    initialize(): Promise<DatabaseResult<void>>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getClient(): object;
+    query<T>(sql: string, params?: T[]): Promise<T[]>;
+    registerTable<T, U>(name: string, table: T, idColumn?: U): void;
+    findById<T>(table: string, id: string): Promise<DatabaseResult<T | null>>;
+    findMany<T>(table: string, options?: QueryOptions): Promise<DatabaseResult<PaginatedResult<T>>>;
+    create<T>(table: string, data: T): Promise<DatabaseResult<T>>;
+    update<T>(table: string, id: string, data: Partial<T>): Promise<DatabaseResult<T>>;
+    delete(table: string, id: string): Promise<DatabaseResult<void>>;
+    transaction<T>(callback: (trx: Transaction) => Promise<T>): Promise<DatabaseResult<T>>;
+    exists(table: string, id: string): Promise<DatabaseResult<boolean>>;
+    count(table: string, filter?: Filter): Promise<DatabaseResult<number>>;
+    healthCheck(): Promise<DatabaseResult<DatabaseHealthStatus>>;
+    private encryptFields;
+    private shouldProcessFields;
+    private encryptSingleField;
+    private decryptFields;
+    private decryptSingleField;
+    private encrypt;
+    private validateEncryptionInput;
+    private createCipher;
+    private performEncryption;
+    private decrypt;
+    private validateDecryptionInput;
+    private parseEncryptedText;
+    private extractDecryptionParts;
+    private createDecipher;
+    private performDecryption;
+    private isEncryptedValue;
+    private getKeyBuffer;
+}
+//# sourceMappingURL=EncryptionExtension.d.ts.map

package/dist/extensions/EncryptionExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EncryptionExtension.d.ts","sourceRoot":"","sources":["../../src/extensions/EncryptionExtension.ts"],"names":[],"mappings":"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"}

package/dist/extensions/ReadReplicaAdapter.d.ts

@@ -0,0 +1,32 @@
+import type { DatabaseAdapterType, DatabaseResult, QueryOptions, PaginatedResult, Transaction, Filter, DatabaseHealthStatus, ReadReplicaConfig } from "@plyaz/types/db";
+/**
+ * Read replica extension that routes read operations to replicas
+ * This is the outermost wrapper in the adapter chain
+ */
+export declare class ReadReplicaAdapter implements DatabaseAdapterType {
+    private primaryAdapter;
+    private config;
+    private currentReplicaIndex;
+    constructor(primaryAdapter: DatabaseAdapterType, config: ReadReplicaConfig);
+    initialize(): Promise<DatabaseResult<void>>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getClient(): object;
+    query<T>(sql: string, params?: T[]): Promise<T[]>;
+    registerTable<T, U>(name: string, table: T, idColumn?: U): void;
+    findById<T>(table: string, id: string): Promise<DatabaseResult<T | null>>;
+    findMany<T>(table: string, options?: QueryOptions): Promise<DatabaseResult<PaginatedResult<T>>>;
+    create<T>(table: string, data: T): Promise<DatabaseResult<T>>;
+    update<T>(table: string, id: string, data: Partial<T>): Promise<DatabaseResult<T>>;
+    delete(table: string, id: string): Promise<DatabaseResult<void>>;
+    transaction<T>(callback: (trx: Transaction) => Promise<T>): Promise<DatabaseResult<T>>;
+    exists(table: string, id: string): Promise<DatabaseResult<boolean>>;
+    count(table: string, filter?: Filter): Promise<DatabaseResult<number>>;
+    healthCheck(): Promise<DatabaseResult<DatabaseHealthStatus>>;
+    /**
+     * Get the appropriate adapter for read operations
+     * Routes to replicas using the configured strategy
+     */
+    private getReadAdapter;
+}
+//# sourceMappingURL=ReadReplicaAdapter.d.ts.map

package/dist/extensions/ReadReplicaAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadReplicaAdapter.d.ts","sourceRoot":"","sources":["../../src/extensions/ReadReplicaAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,WAAW,EACX,MAAM,EACN,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAEzB;;;GAGG;AACH,qBAAa,kBAAmB,YAAW,mBAAmB;IAI1D,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,MAAM;IAJhB,OAAO,CAAC,mBAAmB,CAAK;gBAGtB,cAAc,EAAE,mBAAmB,EACnC,MAAM,EAAE,iBAAiB;IAG7B,UAAU,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAI3C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,SAAS,IAAI,MAAM;IAIb,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAIvD,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI;IAIzD,QAAQ,CAAC,CAAC,EACd,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAM9B,QAAQ,CAAC,CAAC,EACd,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;IAMxC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAK7D,MAAM,CAAC,CAAC,EACZ,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GACf,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAKvB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAKhE,WAAW,CAAC,CAAC,EACjB,QAAQ,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GACzC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAKvB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAMnE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAMtE,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;IAIlE;;;OAGG;IACH,OAAO,CAAC,cAAc;CAyBvB"}