sqlew 3.6.9 → 3.7.0

package/dist/adapters/base-adapter.js

@@ -0,0 +1,557 @@
+/**
+ * @fileoverview Base adapter for database connections with authentication integration.
+ *
+ * This module provides the foundation for all database adapters in the multi-RDBMS system.
+ * It integrates authentication providers (SSH tunneling, direct connections, cloud IAM) with
+ * Knex.js-based database connections, managing the complete connection lifecycle.
+ *
+ * **Key Responsibilities:**
+ * - Authentication provider integration via factory
+ * - Connection lifecycle management (connect → authenticate → establish → cleanup)
+ * - Knex.js instance management and access control
+ * - Transaction support delegation
+ * - Abstract methods for adapter-specific initialization
+ *
+ * **Connection Flow:**
+ * 1. Constructor: Initialize with DatabaseConfig
+ * 2. connect(): Authenticate via provider, establish Knex connection
+ * 3. initialize(): Adapter-specific setup (pragmas, schemas, etc.)
+ * 4. getKnex(): Access Knex instance for queries
+ * 5. disconnect(): Close Knex connection
+ * 6. cleanup(): Release authentication resources (tunnels, tokens)
+ *
+ * **Architecture:**
+ * ```
+ * BaseAdapter (abstract)
+ *   ├── Authentication Layer: BaseAuthProvider integration
+ *   ├── Connection Layer: Knex.js management
+ *   └── Adapter-Specific: Abstract methods for subclasses
+ *
+ * Concrete Adapters:
+ *   ├── SQLiteAdapter (no auth required)
+ *   ├── PostgreSQLAdapter (with auth integration)
+ *   └── MySQLAdapter (with auth integration)
+ * ```
+ *
+ * @module adapters/base-adapter
+ * @since v3.7.0
+ */
+import knexLib from 'knex';
+import { createAuthProvider } from './auth/auth-factory.js';
+const { knex } = knexLib;
+/**
+ * Abstract base class for database adapters with authentication integration.
+ *
+ * This class provides common functionality for all database adapters, integrating
+ * authentication providers with Knex.js connections. Subclasses implement
+ * database-specific features (SQLite pragmas, PostgreSQL settings, MySQL config).
+ *
+ * **Design Principles:**
+ * - Separation of concerns: Auth provider handles authentication, adapter handles DB operations
+ * - Lazy initialization: Knex instance created only after successful authentication
+ * - Resource safety: Explicit cleanup for both auth providers and DB connections
+ * - Fail-fast validation: Auth provider validates config before connection attempt
+ * - Backward compatibility: Maintains DatabaseAdapter interface contract
+ *
+ * **Authentication Integration:**
+ * - SQLite: No authentication provider (null), direct file connection
+ * - PostgreSQL/MySQL: Auth provider handles tunneling/IAM/direct auth
+ * - SSH tunneling: Provider establishes tunnel, returns localhost connection params
+ * - Cloud IAM: Provider generates temporary tokens, returns params with SSL config
+ *
+ * **Error Handling:**
+ * - Constructor: Config validation (throws if invalid)
+ * - connect(): Authentication failures, connection failures
+ * - getKnex(): Throws if called before connect()
+ * - cleanup(): Swallows errors to prevent cascading failures
+ *
+ * @abstract
+ * @implements {DatabaseAdapter}
+ *
+ * @example
+ * // Implementing a PostgreSQL adapter
+ * class PostgreSQLAdapter extends BaseAdapter {
+ *   readonly supportsReturning = true;
+ *   readonly supportsJSON = true;
+ *   readonly databaseName = 'postgresql' as const;
+ *
+ *   async initialize(): Promise<void> {
+ *     const knex = this.getKnex();
+ *     // PostgreSQL-specific initialization
+ *     await knex.raw('SET statement_timeout = 30000');
+ *     await knex.raw('SET timezone = "UTC"');
+ *   }
+ *
+ *   getDialect(): string {
+ *     return 'pg';
+ *   }
+ *
+ *   // Implement other DatabaseAdapter methods...
+ * }
+ *
+ * @example
+ * // Using the adapter with authentication
+ * const config: DatabaseConfig = {
+ *   type: 'postgres',
+ *   connection: {
+ *     host: 'db.internal',
+ *     port: 5432,
+ *     database: 'production'
+ *   },
+ *   auth: {
+ *     type: 'ssh',
+ *     user: 'postgres',
+ *     password: 'secret',
+ *     ssh: {
+ *       host: 'bastion.example.com',
+ *       username: 'deploy',
+ *       privateKeyPath: '/path/to/key.pem'
+ *     }
+ *   }
+ * };
+ *
+ * const adapter = new PostgreSQLAdapter(config);
+ * try {
+ *   await adapter.connect();
+ *   const knex = adapter.getKnex();
+ *   const users = await knex('users').select('*');
+ *   console.log(users);
+ * } finally {
+ *   await adapter.disconnect();
+ *   await adapter.cleanup();
+ * }
+ *
+ * @example
+ * // Transaction support
+ * const adapter = new PostgreSQLAdapter(config);
+ * await adapter.connect();
+ *
+ * try {
+ *   await adapter.transaction(async (trx) => {
+ *     await trx('accounts').where({ id: 1 }).update({ balance: 100 });
+ *     await trx('accounts').where({ id: 2 }).update({ balance: 200 });
+ *   });
+ * } finally {
+ *   await adapter.disconnect();
+ *   await adapter.cleanup();
+ * }
+ *
+ * @example
+ * // SQLite adapter (no authentication)
+ * class SQLiteAdapter extends BaseAdapter {
+ *   async connect(): Promise<Knex> {
+ *     // SQLite doesn't need authentication provider
+ *     // Override connect to bypass auth flow
+ *     const config: Knex.Config = {
+ *       client: 'better-sqlite3',
+ *       connection: {
+ *         filename: this.config.connection.database
+ *       },
+ *       useNullAsDefault: true
+ *     };
+ *
+ *     this.knex = knex(config);
+ *     await this.initialize();
+ *     return this.knex;
+ *   }
+ *
+ *   getDialect(): string {
+ *     return 'sqlite3';
+ *   }
+ * }
+ */
+export class BaseAdapter {
+    /**
+     * Database configuration containing connection and authentication settings.
+     * @protected
+     * @readonly
+     */
+    config;
+    /**
+     * Authentication provider instance for handling credentials, tunnels, and tokens.
+     * Null for databases that don't require authentication (e.g., SQLite).
+     * @protected
+     */
+    authProvider = null;
+    /**
+     * Knex.js instance for database operations.
+     * Null until connect() is called successfully.
+     * @protected
+     */
+    knexInstance = null;
+    /**
+     * Creates a new database adapter instance.
+     *
+     * @param {DatabaseConfig} config - Database configuration object
+     *
+     * @throws {Error} If database type is unsupported
+     *
+     * @example
+     * const adapter = new PostgreSQLAdapter({
+     *   type: 'postgres',
+     *   connection: { host: 'localhost', port: 5432, database: 'mydb' },
+     *   auth: { type: 'direct', user: 'postgres', password: 'postgres' }
+     * });
+     */
+    constructor(config) {
+        this.config = config;
+    }
+    // ============================================================================
+    // Connection Management
+    // ============================================================================
+    /**
+     * Establishes database connection with authentication.
+     *
+     * This method orchestrates the complete connection flow:
+     * 1. Create authentication provider (if required)
+     * 2. Validate authentication configuration
+     * 3. Authenticate and obtain connection parameters
+     * 4. Create Knex instance with authenticated params
+     * 5. Call initialize() for adapter-specific setup
+     *
+     * **Authentication Flow:**
+     * - Direct: Use credentials as-is
+     * - SSH: Establish tunnel, connect to localhost
+     * - AWS/GCP IAM: Generate token, connect with SSL
+     *
+     * **Important Notes:**
+     * - This method is idempotent: calling twice reuses existing connection
+     * - Auth provider resources remain allocated until cleanup() is called
+     * - Knex instance is accessible via getKnex() after successful connection
+     * - Subclasses can override for special handling (e.g., SQLite)
+     *
+     * @returns {Promise<Knex>} Knex instance for database operations
+     *
+     * @throws {Error} 'Database already connected' - if connection exists
+     * @throws {Error} Auth provider validation errors
+     * @throws {Error} Authentication failures (invalid credentials, network issues)
+     * @throws {Error} Knex connection failures (database unreachable, invalid database name)
+     * @throws {Error} Initialization failures (adapter-specific setup errors)
+     *
+     * @example
+     * // Standard usage
+     * const adapter = new PostgreSQLAdapter(config);
+     * try {
+     *   const knex = await adapter.connect();
+     *   console.log('Connected successfully');
+     * } catch (error) {
+     *   console.error('Connection failed:', error.message);
+     *   await adapter.cleanup();
+     *   throw error;
+     * }
+     *
+     * @example
+     * // Idempotent connection
+     * const adapter = new PostgreSQLAdapter(config);
+     * const knex1 = await adapter.connect(); // Establishes connection
+     * const knex2 = await adapter.connect(); // Returns same instance
+     * console.log(knex1 === knex2); // true
+     */
+    async connect() {
+        // Idempotent: return existing connection if already established
+        if (this.knexInstance) {
+            return this.knexInstance;
+        }
+        // Create authentication provider (null for SQLite)
+        this.authProvider = createAuthProvider(this.config);
+        // Authenticate and get connection parameters
+        let connParams = null;
+        if (this.authProvider !== null) {
+            // Validate authentication configuration
+            this.authProvider.validate();
+            // Authenticate to get connection parameters
+            connParams = await this.authProvider.authenticate();
+        }
+        // Build Knex configuration
+        const knexConfig = this.buildKnexConfig(connParams);
+        // Create Knex instance
+        this.knexInstance = knex(knexConfig);
+        // Perform adapter-specific initialization
+        await this.initialize();
+        return this.knexInstance;
+    }
+    /**
+     * Closes the database connection.
+     *
+     * This method closes the Knex connection pool, releasing all database connections.
+     * It does NOT release authentication provider resources (SSH tunnels, tokens) -
+     * call cleanup() to release those.
+     *
+     * **Resource Lifecycle:**
+     * - disconnect() → Closes Knex connection pool
+     * - cleanup() → Releases auth provider resources (tunnels, tokens)
+     * - Both must be called for complete cleanup
+     *
+     * **Important Notes:**
+     * - This method is idempotent: safe to call multiple times
+     * - Pending queries are allowed to complete before closing
+     * - After disconnect(), getKnex() will throw an error
+     * - Auth provider resources remain allocated until cleanup()
+     *
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Complete cleanup flow
+     * const adapter = new PostgreSQLAdapter(config);
+     * try {
+     *   await adapter.connect();
+     *   // ... use database ...
+     * } finally {
+     *   await adapter.disconnect(); // Close DB connection
+     *   await adapter.cleanup();    // Release auth resources
+     * }
+     *
+     * @example
+     * // Idempotent disconnect
+     * await adapter.disconnect(); // Closes connection
+     * await adapter.disconnect(); // Safe - no-op
+     */
+    async disconnect() {
+        if (this.knexInstance) {
+            await this.knexInstance.destroy();
+            this.knexInstance = null;
+        }
+    }
+    /**
+     * Releases authentication provider resources.
+     *
+     * This method releases resources allocated during authentication:
+     * - SSH tunnels: Closes SSH connection and releases local port
+     * - Cloud IAM: Invalidates cached tokens
+     * - Direct connections: No-op (no resources to release)
+     *
+     * **Important Notes:**
+     * - This method MUST be called after disconnect() to prevent resource leaks
+     * - Errors during cleanup are caught and logged, not thrown
+     * - This method is idempotent: safe to call multiple times
+     * - Auth provider is set to null after cleanup
+     *
+     * **Resource Leak Prevention:**
+     * Always call cleanup() in a finally block to ensure resources are released
+     * even if database operations fail.
+     *
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Proper cleanup flow
+     * const adapter = new PostgreSQLAdapter(config);
+     * try {
+     *   await adapter.connect();
+     *   // ... database operations ...
+     * } finally {
+     *   await adapter.disconnect();
+     *   await adapter.cleanup();
+     * }
+     *
+     * @example
+     * // Error handling during cleanup
+     * try {
+     *   await adapter.cleanup();
+     * } catch (error) {
+     *   // Cleanup errors are logged but not thrown to prevent cascading failures
+     *   console.error('Cleanup failed:', error);
+     * }
+     */
+    async cleanup() {
+        if (this.authProvider) {
+            try {
+                await this.authProvider.cleanup();
+            }
+            catch (error) {
+                // Log cleanup errors but don't throw - connection is already closed
+                console.error('Auth provider cleanup failed:', error);
+            }
+            this.authProvider = null;
+        }
+    }
+    /**
+     * Returns the Knex.js instance for database operations.
+     *
+     * This method provides access to the underlying Knex instance for executing
+     * queries, building query chains, and accessing raw connections.
+     *
+     * **Important Notes:**
+     * - Must call connect() before calling this method
+     * - Throws error if connection not established
+     * - Returns same instance across multiple calls
+     *
+     * @returns {Knex} Knex instance for database operations
+     *
+     * @throws {Error} 'Database not connected. Call connect() first.' - if not connected
+     *
+     * @example
+     * // Standard usage
+     * const adapter = new PostgreSQLAdapter(config);
+     * await adapter.connect();
+     * const knex = adapter.getKnex();
+     * const users = await knex('users').select('*');
+     *
+     * @example
+     * // Query builder
+     * const knex = adapter.getKnex();
+     * const query = knex('orders')
+     *   .where('status', 'pending')
+     *   .andWhere('created_at', '>', '2024-01-01')
+     *   .orderBy('created_at', 'desc');
+     *
+     * @example
+     * // Raw queries
+     * const knex = adapter.getKnex();
+     * const result = await knex.raw('SELECT * FROM users WHERE id = ?', [userId]);
+     */
+    getKnex() {
+        if (!this.knexInstance) {
+            throw new Error('Database not connected. Call connect() first.');
+        }
+        return this.knexInstance;
+    }
+    // ============================================================================
+    // Transaction Support
+    // ============================================================================
+    /**
+     * Executes a callback within a database transaction.
+     *
+     * This method delegates to Knex's transaction management, providing:
+     * - Automatic commit on success
+     * - Automatic rollback on error
+     * - Optional isolation level configuration
+     *
+     * **Transaction Isolation Levels:**
+     * - 'serializable': Strongest isolation, prevents all anomalies
+     * - 'repeatable read': Prevents non-repeatable reads and phantom reads
+     * - 'read committed': Prevents dirty reads (default for most databases)
+     *
+     * **Important Notes:**
+     * - All database operations within callback must use the trx parameter
+     * - Do not mix transaction queries with non-transaction queries
+     * - Nested transactions use savepoints (if supported by database)
+     *
+     * @param {Function} callback - Async function receiving transaction object
+     * @param {Object} [options] - Transaction options
+     * @param {string} [options.isolationLevel] - Transaction isolation level
+     * @returns {Promise<T>} Result from callback function
+     *
+     * @throws {Error} If callback throws (transaction is rolled back)
+     *
+     * @example
+     * // Bank transfer transaction
+     * await adapter.transaction(async (trx) => {
+     *   await trx('accounts')
+     *     .where({ id: fromAccount })
+     *     .decrement('balance', amount);
+     *
+     *   await trx('accounts')
+     *     .where({ id: toAccount })
+     *     .increment('balance', amount);
+     *
+     *   await trx('transfers').insert({
+     *     from_account: fromAccount,
+     *     to_account: toAccount,
+     *     amount
+     *   });
+     * });
+     *
+     * @example
+     * // Transaction with isolation level
+     * await adapter.transaction(async (trx) => {
+     *   const balance = await trx('accounts')
+     *     .where({ id: accountId })
+     *     .first('balance');
+     *
+     *   if (balance.balance >= amount) {
+     *     await trx('accounts')
+     *       .where({ id: accountId })
+     *       .decrement('balance', amount);
+     *   }
+     * }, { isolationLevel: 'serializable' });
+     *
+     * @example
+     * // Error handling (automatic rollback)
+     * try {
+     *   await adapter.transaction(async (trx) => {
+     *     await trx('users').insert({ name: 'Alice' });
+     *     throw new Error('Something went wrong');
+     *     await trx('logs').insert({ message: 'Never executed' });
+     *   });
+     * } catch (error) {
+     *   console.log('Transaction rolled back:', error.message);
+     * }
+     */
+    async transaction(callback, options) {
+        const knex = this.getKnex();
+        return await knex.transaction(callback, options);
+    }
+    // ============================================================================
+    // Protected Helper Methods
+    // ============================================================================
+    /**
+     * Builds Knex configuration from connection parameters.
+     *
+     * This method converts ConnectionParams (returned by auth provider) into
+     * Knex.Config format. Subclasses can override to customize configuration.
+     *
+     * **Default Behavior:**
+     * - Uses dialect from getDialect()
+     * - Passes connection params to Knex
+     * - Configures SSL if present
+     * - Merges additional params
+     *
+     * @protected
+     * @param {ConnectionParams | null} connParams - Connection parameters from auth provider
+     * @returns {Knex.Config} Knex configuration object
+     *
+     * @example
+     * // Custom configuration in subclass
+     * protected buildKnexConfig(connParams: ConnectionParams | null): Knex.Config {
+     *   const baseConfig = super.buildKnexConfig(connParams);
+     *   return {
+     *     ...baseConfig,
+     *     pool: {
+     *       min: 2,
+     *       max: 10,
+     *       afterCreate: (conn, done) => {
+     *         // Custom connection setup
+     *         done(null, conn);
+     *       }
+     *     }
+     *   };
+     * }
+     */
+    buildKnexConfig(connParams) {
+        if (!connParams) {
+            // SQLite or other file-based databases
+            return {
+                client: this.getDialect(),
+                connection: {
+                    filename: this.config.connection.database,
+                },
+                useNullAsDefault: true,
+            };
+        }
+        // Client-server databases with authentication
+        const connectionConfig = {
+            host: connParams.host,
+            port: connParams.port,
+            database: connParams.database,
+            user: connParams.user,
+        };
+        // Add password if present
+        if (connParams.password) {
+            connectionConfig.password = connParams.password;
+        }
+        // Add SSL configuration if present
+        if (connParams.ssl) {
+            connectionConfig.ssl = connParams.ssl;
+        }
+        // Merge additional parameters
+        if (connParams.additionalParams) {
+            Object.assign(connectionConfig, connParams.additionalParams);
+        }
+        return {
+            client: this.getDialect(),
+            connection: connectionConfig,
+            useNullAsDefault: this.getDialect() === 'sqlite3',
+        };
+    }
+}
+//# sourceMappingURL=base-adapter.js.map

package/dist/adapters/base-adapter.js.map

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

package/dist/adapters/index.d.ts

@@ -1,11 +1,22 @@
 export type { DatabaseAdapter } from './types.js';
+export type { DatabaseConfig, AuthConfig, SSLConfig, ConnectionConfig } from '../config/types.js';
+export { BaseAdapter } from './base-adapter.js';
 import { SQLiteAdapter } from './sqlite-adapter.js';
 import { PostgreSQLAdapter } from './postgresql-adapter.js';
 import { MySQLAdapter } from './mysql-adapter.js';
 import type { DatabaseAdapter } from './types.js';
+import type { DatabaseConfig } from '../config/types.js';
 export { SQLiteAdapter, PostgreSQLAdapter, MySQLAdapter };
 /**
- * Factory function to create database adapter
+ * Factory function to create database adapter.
+ *
+ * NOTE: This factory maintains backward compatibility with the old signature
+ * that only accepts database type. For new code with authentication, create
+ * adapters directly with DatabaseConfig.
+ *
+ * @param databaseType - Database type identifier
+ * @param config - Optional database configuration (for new auth-aware code)
+ * @returns Database adapter instance
  */
-export declare function createDatabaseAdapter(databaseType: 'sqlite' | 'postgresql' | 'mysql'): DatabaseAdapter;
+export declare function createDatabaseAdapter(databaseType: 'sqlite' | 'postgresql' | 'mysql', config?: DatabaseConfig): DatabaseAdapter;
 //# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC;AAE1D;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,QAAQ,GAAG,YAAY,GAAG,OAAO,GAC9C,eAAe,CAWjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGlG,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,QAAQ,GAAG,YAAY,GAAG,OAAO,EAC/C,MAAM,CAAC,EAAE,cAAc,GACtB,eAAe,CAwBjB"}

package/dist/adapters/index.js

@@ -1,19 +1,41 @@
+// Export base adapter
+export { BaseAdapter } from './base-adapter.js';
 // Import adapter implementations
 import { SQLiteAdapter } from './sqlite-adapter.js';
 import { PostgreSQLAdapter } from './postgresql-adapter.js';
 import { MySQLAdapter } from './mysql-adapter.js';
 export { SQLiteAdapter, PostgreSQLAdapter, MySQLAdapter };
 /**
- * Factory function to create database adapter
+ * Factory function to create database adapter.
+ *
+ * NOTE: This factory maintains backward compatibility with the old signature
+ * that only accepts database type. For new code with authentication, create
+ * adapters directly with DatabaseConfig.
+ *
+ * @param databaseType - Database type identifier
+ * @param config - Optional database configuration (for new auth-aware code)
+ * @returns Database adapter instance
  */
-export function createDatabaseAdapter(databaseType) {
+export function createDatabaseAdapter(databaseType, config) {
+    // Build default config if not provided (backward compatibility)
+    const defaultConfig = config || {
+        type: databaseType === 'postgresql' ? 'postgres' : databaseType,
+        connection: {
+            host: '',
+            port: 0,
+            database: '',
+        },
+        auth: {
+            type: 'direct',
+        },
+    };
     switch (databaseType) {
         case 'sqlite':
-            return new SQLiteAdapter();
+            return new SQLiteAdapter(defaultConfig);
         case 'postgresql':
-            return new PostgreSQLAdapter();
+            return new PostgreSQLAdapter(defaultConfig);
         case 'mysql':
-            return new MySQLAdapter();
+            return new MySQLAdapter(defaultConfig);
         default:
             throw new Error(`Unsupported database type: ${databaseType}`);
     }

package/dist/adapters/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAIA,iCAAiC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC;AAE1D;;GAEG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAA+C;IAE/C,QAAQ,YAAY,EAAE,CAAC;QACrB,KAAK,QAAQ;YACX,OAAO,IAAI,aAAa,EAAE,CAAC;QAC7B,KAAK,YAAY;YACf,OAAO,IAAI,iBAAiB,EAAE,CAAC;QACjC,KAAK,OAAO;YACV,OAAO,IAAI,YAAY,EAAE,CAAC;QAC5B;YACE,MAAM,IAAI,KAAK,CAAC,8BAA8B,YAAY,EAAE,CAAC,CAAC;IAClE,CAAC;AACH,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAKA,sBAAsB;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,iCAAiC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIlD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAA+C,EAC/C,MAAuB;IAEvB,gEAAgE;IAChE,MAAM,aAAa,GAAmB,MAAM,IAAI;QAC9C,IAAI,EAAE,YAAY,KAAK,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY;QAC/D,UAAU,EAAE;YACV,IAAI,EAAE,EAAE;YACR,IAAI,EAAE,CAAC;YACP,QAAQ,EAAE,EAAE;SACb;QACD,IAAI,EAAE;YACJ,IAAI,EAAE,QAAQ;SACf;KACF,CAAC;IAEF,QAAQ,YAAY,EAAE,CAAC;QACrB,KAAK,QAAQ;YACX,OAAO,IAAI,aAAa,CAAC,aAAa,CAAC,CAAC;QAC1C,KAAK,YAAY;YACf,OAAO,IAAI,iBAAiB,CAAC,aAAa,CAAC,CAAC;QAC9C,KAAK,OAAO;YACV,OAAO,IAAI,YAAY,CAAC,aAAa,CAAC,CAAC;QACzC;YACE,MAAM,IAAI,KAAK,CAAC,8BAA8B,YAAY,EAAE,CAAC,CAAC;IAClE,CAAC;AACH,CAAC"}