@plyaz/db 0.0.0

package/dist/advanced/read-replica/ReadReplicaAdapter.d.ts

@@ -0,0 +1,516 @@
+import type { DatabaseAdapterType, DatabaseResult, DrizzleAdapterConfig, Filter, DatabaseHealthStatus, PaginatedResult, QueryOptions, Transaction } from "@plyaz/types/db";
+/**
+ * Database adapter that provides read replica support with automatic read/write splitting.
+ * Routes SELECT queries to read replicas and write operations to the primary database.
+ * Implements load balancing across replicas and automatic failover to primary.
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   connectionString: 'postgres://primary:5432/db',
+ *   replicas: [
+ *     { connectionString: 'postgres://replica1:5432/db' },
+ *     { connectionString: 'postgres://replica2:5432/db' }
+ *   ]
+ * };
+ *
+ * const adapter = new ReadReplicaAdapter(config);
+ * await adapter.initialize();
+ *
+ * // This will be routed to a replica
+ * const users = await adapter.findMany('users');
+ *
+ * // This will be routed to primary
+ * await adapter.create('users', { name: 'John' });
+ * ```
+ */
+export declare class ReadReplicaAdapter implements DatabaseAdapterType {
+    private primaryAdapter;
+    private replicaManager;
+    private replicas;
+    private currentReplicaIndex;
+    /**
+     * Creates a new ReadReplicaAdapter instance.
+     *
+     * **RESPONSIBILITY:** Sets up primary adapter and replica manager for read/write splitting
+     *
+     * @param config Configuration for primary and replica databases
+     *
+     * @example
+     * ```typescript
+     * const adapter = new ReadReplicaAdapter({
+     *   connectionString: 'postgres://primary:5432/db',
+     *   replicas: [
+     *     { connectionString: 'postgres://replica1:5432/db' },
+     *     { connectionString: 'postgres://replica2:5432/db' }
+     *   ]
+     * });
+     * ```
+     */
+    constructor(config: DrizzleAdapterConfig & {
+        replicas: DrizzleAdapterConfig[];
+    });
+    /**
+     * Initializes the adapter and all replicas.
+     *
+     * **RESPONSIBILITY:** Establishes connections to primary and all replica databases
+     * **BEHAVIOR:** Fails if primary initialization fails, continues if replicas fail
+     *
+     * @returns Promise resolving to initialization result
+     *
+     * @example
+     * ```typescript
+     * const adapter = new ReadReplicaAdapter(config);
+     * const result = await adapter.initialize();
+     *
+     * if (result.success) {
+     *   console.log('All databases initialized successfully');
+     * } else {
+     *   console.error('Initialization failed:', result.error);
+     * }
+     * ```
+     */
+    initialize(): Promise<DatabaseResult<void>>;
+    /**
+     * Establishes connections to primary and all replicas.
+     *
+     * **RESPONSIBILITY:** Opens database connections for all configured databases
+     * **BEHAVIOR:** Throws error if any connection fails
+     *
+     * @throws {BaseError} When connection to any database fails
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await adapter.connect();
+     *   console.log('All connections established');
+     * } catch (error) {
+     *   console.error('Connection failed:', error.message);
+     * }
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Closes connections to primary and all replicas.
+     *
+     * **RESPONSIBILITY:** Gracefully closes all database connections
+     * **BEHAVIOR:** Attempts to close all connections even if some fail
+     *
+     * @throws {BaseError} When disconnection from any database fails
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await adapter.disconnect();
+     *   console.log('All connections closed');
+     * } catch (error) {
+     *   console.error('Disconnection failed:', error.message);
+     * }
+     * ```
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Gets the underlying primary database client.
+     *
+     * **RESPONSIBILITY:** Provides access to the primary database client for advanced operations
+     * **USE CASE:** When you need direct access to database-specific features
+     *
+     * @returns Primary database client
+     *
+     * @example
+     * ```typescript
+     * // Get PostgreSQL client for advanced operations
+     * const pgClient = adapter.getClient<pg.Client>();
+     *
+     * // Use client for database-specific operations
+     * const result = await pgClient.query('SELECT version()');
+     * ```
+     */
+    getClient<TClient extends object>(): TClient;
+    /**
+     * Executes a raw SQL query with automatic read/write routing.
+     *
+     * **ROUTING LOGIC:**
+     * - SELECT queries → Read replicas (with failover to primary)
+     * - INSERT/UPDATE/DELETE → Primary database only
+     *
+     * **LOAD BALANCING:** Round-robin across healthy replicas
+     * **FAILOVER:** Automatic fallback to primary if all replicas fail
+     *
+     * @param sql SQL query string
+     * @param params Query parameters
+     * @returns Query result rows
+     *
+     * @throws {BaseError} When SQL is invalid or execution fails
+     *
+     * @example
+     * ```typescript
+     * // Read query - routed to replica
+     * const users = await adapter.query(
+     *   'SELECT * FROM users WHERE status = $1',
+     *   ['active']
+     * );
+     *
+     * // Write query - routed to primary
+     * await adapter.query(
+     *   'INSERT INTO users (name, email) VALUES ($1, $2)',
+     *   ['John Doe', 'john@example.com']
+     * );
+     * ```
+     */
+    /**
+     * Validates SQL query string.
+     * @private
+     * @param sql SQL query to validate
+     * @throws {BaseError} When SQL is not a valid string
+     */
+    private validateSql;
+    /**
+     * Executes query on a read replica with load balancing.
+     * @private
+     * @param sql SQL query string
+     * @param params Query parameters
+     * @returns Query result
+     */
+    private executeOnReplica;
+    /**
+     * Tries other replicas or falls back to primary on failure.
+     * @private
+     * @param sql SQL query string
+     * @param params Query parameters
+     * @returns Query result
+     */
+    private tryOtherReplicasOrPrimary;
+    query<T>(sql: string, params?: T[]): Promise<T[]>;
+    /**
+     * Registers a table with primary and all replicas.
+     *
+     * **RESPONSIBILITY:** Ensures table schema is available on all database connections
+     * **BEHAVIOR:** Registers with primary and all replica adapters
+     *
+     * @param name Logical table name
+     * @param table Table schema
+     * @param idColumn Optional ID column name
+     *
+     * @example
+     * ```typescript
+     * // Register user table with all adapters
+     * adapter.registerTable('users', userTableSchema, 'id');
+     *
+     * // Now all operations on 'users' table will work
+     * const user = await adapter.findById('users', '123');
+     * ```
+     */
+    registerTable<TTable, TIdColumn>(name: string, table: TTable, idColumn?: TIdColumn): void;
+    /**
+     * Finds a record by ID, routing to a replica.
+     *
+     * **ROUTING:** Always uses read replica (with failover to primary)
+     * **PERFORMANCE:** Reduces load on primary database
+     *
+     * @param table Table name
+     * @param id Record ID
+     * @returns Found record or null
+     *
+     * @example
+     * ```typescript
+     * // This query goes to a replica
+     * const result = await adapter.findById('users', 'user-123');
+     *
+     * if (result.success && result.value) {
+     *   console.log('User found:', result.value.name);
+     * } else {
+     *   console.log('User not found');
+     * }
+     * ```
+     */
+    findById<T>(table: string, id: string): Promise<DatabaseResult<T | null>>;
+    /**
+     * Finds multiple records with filtering and pagination, routing to a replica.
+     *
+     * **ROUTING:** Always uses read replica (with failover to primary)
+     * **PERFORMANCE:** Ideal for heavy read workloads
+     *
+     * @param table Table name
+     * @param options Query options
+     * @returns Paginated result
+     *
+     * @example
+     * ```typescript
+     * // This query goes to a replica
+     * const result = await adapter.findMany('users', {
+     *   filter: { field: 'status', operator: 'eq', value: 'active' },
+     *   pagination: { page: 1, limit: 10 },
+     *   sort: { field: 'name', direction: 'asc' }
+     * });
+     *
+     * console.log('Found users:', result.value?.data.length);
+     * ```
+     */
+    findMany<T>(table: string, options?: QueryOptions): Promise<DatabaseResult<PaginatedResult<T>>>;
+    /**
+     * Creates a new record, routing to primary.
+     *
+     * **ROUTING:** Always uses primary database
+     * **CONSISTENCY:** Ensures immediate consistency for writes
+     *
+     * @param table Table name
+     * @param data Record data
+     * @returns Created record
+     *
+     * @example
+     * ```typescript
+     * // This operation goes to primary
+     * const result = await adapter.create('users', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com',
+     *   status: 'active'
+     * });
+     *
+     * if (result.success) {
+     *   console.log('User created:', result.value.id);
+     * }
+     * ```
+     */
+    create<T>(table: string, data: T): Promise<DatabaseResult<T>>;
+    /**
+     * Updates an existing record, routing to primary.
+     *
+     * **ROUTING:** Always uses primary database
+     * **CONSISTENCY:** Ensures immediate consistency for updates
+     *
+     * @param table Table name
+     * @param id Record ID
+     * @param data Partial record data
+     * @returns Updated record
+     *
+     * @example
+     * ```typescript
+     * // This operation goes to primary
+     * const result = await adapter.update('users', 'user-123', {
+     *   name: 'Jane Doe',
+     *   status: 'inactive'
+     * });
+     *
+     * if (result.success) {
+     *   console.log('User updated:', result.value.name);
+     * }
+     * ```
+     */
+    update<T>(table: string, id: string, data: Partial<T>): Promise<DatabaseResult<T>>;
+    /**
+     * Deletes a record, routing to primary.
+     *
+     * **ROUTING:** Always uses primary database
+     * **CONSISTENCY:** Ensures immediate consistency for deletions
+     *
+     * @param table Table name
+     * @param id Record ID
+     * @returns Deletion result
+     *
+     * @example
+     * ```typescript
+     * // This operation goes to primary
+     * const result = await adapter.delete('users', 'user-123');
+     *
+     * if (result.success) {
+     *   console.log('User deleted successfully');
+     * } else {
+     *   console.error('Delete failed:', result.error?.message);
+     * }
+     * ```
+     */
+    delete(table: string, id: string): Promise<DatabaseResult<void>>;
+    /**
+     * Executes a transaction on the primary database.
+     *
+     * **ROUTING:** Always uses primary database (transactions require consistency)
+     * **ACID:** Provides full ACID transaction guarantees
+     *
+     * @param callback Transaction callback
+     * @returns Transaction result
+     *
+     * @example
+     * ```typescript
+     * // Transaction always goes to primary
+     * const result = await adapter.transaction(async (trx) => {
+     *   const user = await trx.create('users', { name: 'John' });
+     *   await trx.create('profiles', { userId: user.id, bio: 'Hello' });
+     *   return user;
+     * });
+     *
+     * if (result.success) {
+     *   console.log('Transaction completed:', result.value.id);
+     * }
+     * ```
+     */
+    transaction<T>(callback: (trx: Transaction) => Promise<T>): Promise<DatabaseResult<T>>;
+    /**
+     * Checks if a record exists, routing to a replica.
+     *
+     * **ROUTING:** Uses read replica (with failover to primary)
+     * **PERFORMANCE:** Efficient existence check without full record retrieval
+     *
+     * @param table Table name
+     * @param id Record ID
+     * @returns Existence result
+     *
+     * @example
+     * ```typescript
+     * // This check goes to a replica
+     * const result = await adapter.exists('users', 'user-123');
+     *
+     * if (result.success && result.value) {
+     *   console.log('User exists');
+     * } else {
+     *   console.log('User does not exist');
+     * }
+     * ```
+     */
+    exists(table: string, id: string): Promise<DatabaseResult<boolean>>;
+    /**
+     * Counts records matching a filter, routing to a replica.
+     *
+     * **ROUTING:** Uses read replica (with failover to primary)
+     * **PERFORMANCE:** Efficient counting without data transfer
+     *
+     * @param table Table name
+     * @param filter Filter conditions
+     * @returns Count result
+     *
+     * @example
+     * ```typescript
+     * // This count goes to a replica
+     * const result = await adapter.count('users', {
+     *   field: 'status',
+     *   operator: 'eq',
+     *   value: 'active'
+     * });
+     *
+     * if (result.success) {
+     *   console.log('Active users:', result.value);
+     * }
+     * ```
+     */
+    count(table: string, filter?: Filter): Promise<DatabaseResult<number>>;
+    /**
+     * Performs health checks on primary and all replicas.
+     *
+     * **RESPONSIBILITY:** Monitors health of entire database cluster
+     * **BEHAVIOR:** Returns healthy only if primary and at least one replica are healthy
+     *
+     * @returns Combined health status
+     *
+     * @example
+     * ```typescript
+     * const result = await adapter.healthCheck();
+     *
+     * if (result.success && result.value?.isHealthy) {
+     *   console.log('Cluster is healthy');
+     *   console.log('Response time:', result.value.responseTime, 'ms');
+     * } else {
+     *   console.error('Cluster health issues detected');
+     * }
+     * ```
+     */
+    healthCheck(): Promise<DatabaseResult<DatabaseHealthStatus>>;
+    /**
+     * Determines if a SQL operation is a write operation.
+     *
+     * **LOGIC:** Checks for INSERT, UPDATE, DELETE, CREATE, DROP, ALTER keywords
+     * **ROUTING:** Write operations go to primary, reads go to replicas
+     *
+     * @private
+     * @param sql SQL query string
+     * @returns True if operation is a write operation
+     *
+     * @example
+     * ```typescript
+     * // These return true (write operations)
+     * this.isWriteOperation('INSERT INTO users...')  // true
+     * this.isWriteOperation('UPDATE users SET...')   // true
+     * this.isWriteOperation('DELETE FROM users...')  // true
+     *
+     * // These return false (read operations)
+     * this.isWriteOperation('SELECT * FROM users')   // false
+     * this.isWriteOperation('SELECT COUNT(*) FROM users') // false
+     * ```
+     */
+    private isWriteOperation;
+    /**
+     * Routes a read operation to a healthy replica with load balancing.
+     *
+     * **RESPONSIBILITY:** Executes operation on replica with automatic failover
+     * **LOAD BALANCING:** Uses round-robin selection across healthy replicas
+     * **FAILOVER:** Automatically tries handleReplicaError on failure
+     *
+     * @private
+     * @param operation Function to execute on replica adapter
+     * @returns Operation result
+     *
+     * @example
+     * ```typescript
+     * // Internal usage for read operations
+     * const result = await this.routeToReplica(adapter =>
+     *   adapter.findById('users', 'user-123')
+     * );
+     *
+     * // Automatically handles:
+     * // 1. Selects healthy replica using round-robin
+     * // 2. Executes operation on selected replica
+     * // 3. Falls back to handleReplicaError on failure
+     * ```
+     */
+    private routeToReplica;
+    /**
+     * Handles replica errors by trying other replicas or falling back to primary.
+     *
+     * **RESPONSIBILITY:** Implements failover strategy when replica operations fail
+     * **STRATEGY:** Try all remaining replicas, then fallback to primary
+     * **RESILIENCE:** Ensures operation completes even if all replicas fail
+     *
+     * @private
+     * @param operation Function to execute on adapter
+     * @returns Operation result
+     *
+     * @example
+     * ```typescript
+     * // Internal usage when replica fails
+     * const result = await this.handleReplicaError(adapter =>
+     *   adapter.findMany('users', options)
+     * );
+     *
+     * // Failover sequence:
+     * // 1. Try each remaining healthy replica
+     * // 2. If all replicas fail, use primary adapter
+     * // 3. Return result from successful operation
+     * ```
+     */
+    private handleReplicaError;
+    /**
+     * Gets healthy replicas by checking their status.
+     *
+     * **RESPONSIBILITY:** Filters replicas based on health status
+     * **CURRENT:** Returns all replicas (health checking not implemented)
+     * **FUTURE:** Should implement actual health status checking
+     *
+     * @private
+     * @returns Array of healthy replica adapters
+     *
+     * @example
+     * ```typescript
+     * // Internal usage
+     * const healthyReplicas = this.getHealthyReplicas();
+     *
+     * if (healthyReplicas.length > 0) {
+     *   // Use replica for read operation
+     *   const replica = healthyReplicas[index % healthyReplicas.length];
+     * } else {
+     *   // No healthy replicas, fallback to primary
+     *   return this.primaryAdapter.operation();
+     * }
+     * ```
+     */
+    private getHealthyReplicas;
+}
+//# sourceMappingURL=ReadReplicaAdapter.d.ts.map

package/dist/advanced/read-replica/ReadReplicaAdapter.d.ts.map

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

package/dist/advanced/read-replica/ReadReplicaManager.d.ts

@@ -0,0 +1,68 @@
+import { DrizzleAdapter } from "@adapters/drizzle/DrizzleAdapter";
+import type { DatabaseResult, DrizzleAdapterConfig, DatabaseHealthStatus } from "@plyaz/types/db";
+/**
+ * Manages read replica connections and health monitoring.
+ * Provides load balancing and failover capabilities across multiple replicas.
+ *
+ * @example
+ * ```typescript
+ * const configs = [
+ *   { connectionString: 'postgres://replica1:5432/db' },
+ *   { connectionString: 'postgres://replica2:5432/db' }
+ * ];
+ *
+ * const manager = new ReadReplicaManager(configs);
+ * await manager.initialize();
+ *
+ * const healthyReplicas = manager.getHealthyReplicas();
+ * const health = await manager.healthCheck();
+ * ```
+ */
+export declare class ReadReplicaManager {
+    private replicaConfigs;
+    private replicas;
+    private replicaHealth;
+    /**
+     * Creates a new ReadReplicaManager instance.
+     * @param replicaConfigs Array of replica configurations
+     */
+    constructor(replicaConfigs: DrizzleAdapterConfig[]);
+    /**
+     * Initializes all replicas and checks their health.
+     * @returns Initialization result
+     */
+    initialize(): Promise<DatabaseResult<void>>;
+    /**
+     * Establishes connections to all replicas.
+     */
+    connect(): Promise<void>;
+    /**
+     * Closes connections to all replicas.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Registers a table with all replicas.
+     * @param name Logical table name
+     * @param table Table schema
+     * @param idColumn Optional ID column name
+     */
+    registerTable<TTable, TIdColumn>(name: string, table: TTable, idColumn?: TIdColumn): void;
+    /**
+     * Performs health checks on all replicas.
+     * @returns Combined health status
+     */
+    healthCheck(): Promise<DatabaseResult<DatabaseHealthStatus>>;
+    /**
+     * Gets all currently healthy replicas.
+     * @returns Array of healthy replica adapters
+     */
+    getHealthyReplicas(): DrizzleAdapter[];
+    /**
+     * Checks the health of a specific replica.
+     * @param replica Replica adapter to check
+     * @param index Replica index
+     * @returns Health check result
+     */
+    private checkReplicaHealth;
+}
+//# sourceMappingURL=ReadReplicaManager.d.ts.map

package/dist/advanced/read-replica/ReadReplicaManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadReplicaManager.d.ts","sourceRoot":"","sources":["../../../src/advanced/read-replica/ReadReplicaManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAGlE,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,iBAAiB,CAAC;AACzB;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,kBAAkB;IAQjB,OAAO,CAAC,cAAc;IAPlC,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,aAAa,CAAmC;IAExD;;;OAGG;gBACiB,cAAc,EAAE,oBAAoB,EAAE;IAE1D;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IA0CjD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,SAAS,EAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,SAAS,GACnB,IAAI;IAMP;;;OAGG;IACG,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;IAuClE;;;OAGG;IACH,kBAAkB,IAAI,cAAc,EAAE;IAItC;;;;;OAKG;YACW,kBAAkB;CAwBjC"}

package/dist/advanced/read-replica/UseReplica.decorator.d.ts

@@ -0,0 +1,24 @@
+import type { UseReplicaOptions } from "@plyaz/types";
+export declare const USE_REPLICA_KEY = "use_replica";
+/**
+ * Decorator to specify replica usage for database operations.
+ *
+ * @example
+ * ```typescript
+ * class UserService {
+ *   @UseReplica({ strategy: ReplicaStrategy.REPLICA })
+ *   async getUsers() {
+ *     // This will use a read replica
+ *     return this.db.findMany('users');
+ *   }
+ *
+ *   @UseReplica({ strategy: ReplicaStrategy.PRIMARY })
+ *   async createUser(user: User) {
+ *     // This will use primary
+ *     return this.db.create('users', user);
+ *   }
+ * }
+ * ```
+ */
+export declare function UseReplica(options?: UseReplicaOptions): MethodDecorator;
+//# sourceMappingURL=UseReplica.decorator.d.ts.map

package/dist/advanced/read-replica/UseReplica.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UseReplica.decorator.d.ts","sourceRoot":"","sources":["../../../src/advanced/read-replica/UseReplica.decorator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,eAAe,CAI3E"}

package/dist/advanced/read-replica/index.d.ts

@@ -0,0 +1,3 @@
+export { ReadReplicaAdapter } from "./ReadReplicaAdapter";
+export { UseReplica } from "./UseReplica.decorator";
+//# sourceMappingURL=index.d.ts.map

package/dist/advanced/read-replica/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/advanced/read-replica/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC"}