sqlew 5.0.8 → 5.2.0

package/dist/adapters/auth/base-auth-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-auth-provider.d.ts","sourceRoot":"","sources":["../../../src/adapters/auth/base-auth-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,GAAG,CAAC,EAAE;QACJ;;;WAGG;QACH,EAAE,CAAC,EAAE,MAAM,CAAC;QAEZ;;;WAGG;QACH,IAAI,CAAC,EAAE,MAAM,CAAC;QAEd;;;WAGG;QACH,GAAG,CAAC,EAAE,MAAM,CAAC;QAEb;;;WAGG;QACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B,CAAC;IAEF;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,8BAAsB,gBAAgB;IACpC;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAE1C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;gBACS,MAAM,EAAE,cAAc;IAIlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,QAAQ,CAAC,YAAY,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAElD;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,IAAI,MAAM;IAEhC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,QAAQ,CAAC,QAAQ,IAAI,IAAI;CAC1B"}
+{"version":3,"file":"base-auth-provider.d.ts","sourceRoot":"","sources":["../../../src/adapters/auth/base-auth-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAC/B,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IAEb,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IAEb,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IAEb,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,uDAAuD;IACvD,GAAG,CAAC,EAAE;QACJ,8CAA8C;QAC9C,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,yCAAyC;QACzC,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,yCAAyC;QACzC,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,mDAAmD;QACnD,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B,CAAC;IAEF,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACxC;AAED,4DAA4D;AAC5D,8BAAsB,gBAAgB;IACpC,iBAAiB;IACjB,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;gBAE9B,MAAM,EAAE,cAAc;IAIlC,iEAAiE;IACjE,QAAQ,CAAC,YAAY,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAElD,8EAA8E;IAC9E,QAAQ,CAAC,aAAa,IAAI,MAAM;IAEhC,oEAAoE;IACpE,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAEjC,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,IAAI,IAAI;CAC1B"}

package/dist/adapters/auth/base-auth-provider.js

@@ -1,109 +1,7 @@
-/**
- * @fileoverview Base authentication provider for sqlew's multi-RDBMS authentication system.
- *
- * This module provides the foundation for all authentication providers, enabling support for:
- * - SSH tunneling (v3.7.0)
- * - Direct connections (v3.7.0)
- * - AWS IAM authentication (v3.8.0+)
- * - GCP IAM authentication (v3.8.0+)
- *
- * @module adapters/auth/base-auth-provider
- * @since v3.7.0
- */
-/**
- * Abstract base class for all authentication providers.
- *
- * This class establishes the contract that all authentication providers must implement,
- * ensuring consistent behavior across different authentication methods.
- *
- * **Supported Authentication Methods:**
- * - `DirectAuthProvider`: Standard username/password authentication
- * - `SshAuthProvider`: SSH tunneling with key-based or password authentication
- * - `AwsIamAuthProvider`: AWS RDS IAM database authentication
- * - `GcpIamAuthProvider`: GCP Cloud SQL IAM authentication
- *
- * **Authentication Flow:**
- * 1. Provider instantiation with DatabaseConfig
- * 2. `validate()` - Verify configuration is valid
- * 3. `authenticate()` - Process credentials and return ConnectionParams
- * 4. Database connection using returned params
- * 5. `cleanup()` - Release resources when connection closes
- *
- * @abstract
- * @class BaseAuthProvider
- *
- * @example
- * // Implementing a custom authentication provider
- * class CustomAuthProvider extends BaseAuthProvider {
- *   async authenticate(): Promise<ConnectionParams> {
- *     // Implement custom authentication logic
- *     return {
- *       host: this.config.connection.host,
- *       port: this.config.connection.port,
- *       database: this.config.connection.database,
- *       user: this.config.auth.user,
- *       password: await this.getCustomPassword()
- *     };
- *   }
- *
- *   getAuthMethod(): string {
- *     return 'Custom Authentication';
- *   }
- *
- *   async cleanup(): Promise<void> {
- *     // Clean up any resources
- *   }
- *
- *   validate(): void {
- *     if (!this.config.auth.user) {
- *       throw new Error('User is required for custom authentication');
- *     }
- *   }
- * }
- *
- * @example
- * // Using an authentication provider
- * const provider = new DirectAuthProvider(config);
- * provider.validate();
- * const connParams = await provider.authenticate();
- * const connection = await createConnection(connParams);
- * // ... use connection ...
- * await connection.close();
- * await provider.cleanup();
- */
+/** Abstract base class for all authentication providers. */
 export class BaseAuthProvider {
-    /**
-     * Database configuration containing connection and authentication settings.
-     * Accessible to child classes for implementing authentication logic.
-     *
-     * @protected
-     * @readonly
-     */
+    /** @protected */
     config;
-    /**
-     * Creates a new authentication provider instance.
-     *
-     * @param {DatabaseConfig} config - Database configuration object
-     *
-     * @example
-     * const provider = new SshAuthProvider({
-     *   type: 'postgres',
-     *   connection: {
-     *     host: 'db.internal',
-     *     port: 5432,
-     *     database: 'production'
-     *   },
-     *   auth: {
-     *     type: 'ssh',
-     *     ssh: {
-     *       host: 'bastion.example.com',
-     *       port: 22,
-     *       user: 'deploy',
-     *       privateKey: '/path/to/key.pem'
-     *     }
-     *   }
-     * });
-     */
     constructor(config) {
         this.config = config;
     }

package/dist/adapters/auth/base-auth-provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"base-auth-provider.js","sourceRoot":"","sources":["../../../src/adapters/auth/base-auth-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAyHH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,OAAgB,gBAAgB;IACpC;;;;;;OAMG;IACgB,MAAM,CAAiB;IAE1C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,YAAY,MAAsB;QAChC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CAmHF"}
+{"version":3,"file":"base-auth-provider.js","sourceRoot":"","sources":["../../../src/adapters/auth/base-auth-provider.ts"],"names":[],"mappings":"AAmCA,4DAA4D;AAC5D,MAAM,OAAgB,gBAAgB;IACpC,iBAAiB;IACE,MAAM,CAAiB;IAE1C,YAAY,MAAsB;QAChC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CAaF"}

package/dist/adapters/auth/direct-auth-provider.d.ts

@@ -1,356 +1,12 @@
-/**
- * @fileoverview Direct authentication provider for sqlew's multi-RDBMS system.
- *
- * This module implements direct database connections without intermediate tunneling
- * or proxy mechanisms. It provides the simplest authentication method, suitable for:
- * - Local database instances
- * - Docker containers on the same network
- * - On-premise servers with direct network access
- * - Cloud databases with public endpoints
- *
- * **Use Cases:**
- * - Development environments with local PostgreSQL/MySQL instances
- * - Docker Compose services with service-to-service connections
- * - On-premise data centers with internal network access
- * - Cloud RDS/Cloud SQL instances with allowlisted IP addresses
- *
- * **Security Considerations:**
- * - Supports SSL/TLS encryption for secure connections
- * - Password is optional to support future IAM authentication
- * - No intermediate resources to manage (unlike SSH tunnels)
- * - Direct exposure to database port (ensure proper firewall rules)
- *
- * @module adapters/auth/direct-auth-provider
- * @since v3.7.0
- */
 import { BaseAuthProvider, type ConnectionParams } from './base-auth-provider.js';
-/**
- * Direct database authentication provider.
- *
- * Provides straightforward database connections without tunneling, proxy servers,
- * or token generation. The provider validates configuration and returns connection
- * parameters directly from the config object.
- *
- * **Authentication Flow:**
- * 1. `validate()` - Verify required configuration fields (host, port, database, user)
- * 2. `authenticate()` - Return connection parameters directly (no external calls)
- * 3. Database connection uses provided credentials
- * 4. `cleanup()` - No-op (no resources to release)
- *
- * **Configuration Requirements:**
- * - Database host address
- * - Database port number
- * - Database name
- * - Database username
- * - Database password (optional for future IAM support)
- * - Optional SSL configuration for encrypted connections
- *
- * @class DirectAuthProvider
- * @extends {BaseAuthProvider}
- *
- * @example
- * // Local PostgreSQL connection
- * const config: DatabaseConfig = {
- *   type: 'postgres',
- *   connection: {
- *     host: 'localhost',
- *     port: 5432,
- *     database: 'dev_db'
- *   },
- *   auth: {
- *     type: 'direct',
- *     user: 'postgres',
- *     password: 'postgres'
- *   }
- * };
- *
- * const provider = new DirectAuthProvider(config);
- * provider.validate();
- * const connParams = await provider.authenticate();
- * // connParams.host = 'localhost'
- * // connParams.port = 5432
- *
- * @example
- * // Docker MySQL connection with SSL
- * const config: DatabaseConfig = {
- *   type: 'mysql',
- *   connection: {
- *     host: 'mysql-container',
- *     port: 3306,
- *     database: 'app_db'
- *   },
- *   auth: {
- *     type: 'direct',
- *     user: 'root',
- *     password: 'root_password',
- *     ssl: {
- *       ca: '/path/to/ca.pem',
- *       rejectUnauthorized: true
- *     }
- *   }
- * };
- *
- * @example
- * // Cloud RDS connection with SSL (production)
- * const config: DatabaseConfig = {
- *   type: 'postgres',
- *   connection: {
- *     host: 'mydb.abc123.us-east-1.rds.amazonaws.com',
- *     port: 5432,
- *     database: 'production'
- *   },
- *   auth: {
- *     type: 'direct',
- *     user: 'admin',
- *     password: 'secure_password_123',
- *     ssl: {
- *       ca: '/etc/ssl/rds-ca-bundle.pem',
- *       rejectUnauthorized: true
- *     }
- *   }
- * };
- *
- * @example
- * // Complete usage with cleanup (cleanup is no-op for direct connections)
- * const provider = new DirectAuthProvider(config);
- * try {
- *   provider.validate();
- *   const params = await provider.authenticate();
- *   const db = await createDatabaseConnection(params);
- *   await db.query('SELECT 1');
- *   await db.close();
- * } finally {
- *   await provider.cleanup(); // No-op, but good practice
- * }
- *
- * @example
- * // Future IAM authentication (password optional)
- * const config: DatabaseConfig = {
- *   type: 'postgres',
- *   connection: {
- *     host: 'mydb.region.rds.amazonaws.com',
- *     port: 5432,
- *     database: 'production'
- *   },
- *   auth: {
- *     type: 'direct',
- *     user: 'iam_user'
- *     // password will be generated by IAM provider
- *   }
- * };
- */
+/** Direct database authentication provider (no tunneling or proxy). */
 export declare class DirectAuthProvider extends BaseAuthProvider {
-    /**
-     * Returns the authentication method name for logging and diagnostics.
-     *
-     * @returns {string} 'Direct Connection'
-     *
-     * @example
-     * const provider = new DirectAuthProvider(config);
-     * console.log(provider.getAuthMethod()); // 'Direct Connection'
-     */
     getAuthMethod(): string;
-    /**
-     * Validates direct connection configuration before authentication.
-     *
-     * **Validation Checks:**
-     * - Connection config object exists
-     * - Database host is specified
-     * - Database port is specified
-     * - Database name is specified
-     * - Database user is specified
-     * - Password is optional (for future IAM authentication support)
-     *
-     * This method should be called immediately after provider instantiation
-     * to fail fast on configuration errors before attempting database connections.
-     *
-     * @throws {Error} 'Connection configuration is required for DirectAuthProvider'
-     * @throws {Error} 'Database host, port, and database name are required'
-     * @throws {Error} 'Database user is required for direct authentication'
-     *
-     * @example
-     * const provider = new DirectAuthProvider(config);
-     * try {
-     *   provider.validate();
-     *   // Configuration is valid, proceed with authentication
-     * } catch (error) {
-     *   console.error('Invalid configuration:', error.message);
-     *   // Fix configuration before retrying
-     * }
-     *
-     * @example
-     * // Missing connection config
-     * const invalidConfig = { type: 'postgres', auth: { type: 'direct' } };
-     * const provider = new DirectAuthProvider(invalidConfig);
-     * provider.validate(); // Throws: 'Connection configuration is required for DirectAuthProvider'
-     *
-     * @example
-     * // Missing database user
-     * const config = {
-     *   connection: {
-     *     host: 'localhost',
-     *     port: 5432,
-     *     database: 'mydb'
-     *   },
-     *   auth: {
-     *     type: 'direct'
-     *     // Missing user field
-     *   }
-     * };
-     * const provider = new DirectAuthProvider(config);
-     * provider.validate(); // Throws: 'Database user is required for direct authentication'
-     *
-     * @example
-     * // Valid config (password optional)
-     * const config = {
-     *   connection: {
-     *     host: 'localhost',
-     *     port: 5432,
-     *     database: 'mydb'
-     *   },
-     *   auth: {
-     *     type: 'direct',
-     *     user: 'postgres'
-     *     // password is optional (for future IAM support)
-     *   }
-     * };
-     * const provider = new DirectAuthProvider(config);
-     * provider.validate(); // Success - password is optional
-     */
+    /** Validates direct connection configuration. */
     validate(): void;
-    /**
-     * Authenticates and returns connection parameters for direct database connection.
-     *
-     * This method:
-     * 1. Validates configuration (defensive check)
-     * 2. Extracts connection and authentication parameters
-     * 3. Constructs ConnectionParams object
-     * 4. Returns parameters immediately (no async operations)
-     *
-     * **Connection Parameters:**
-     * - `host`: Database host address from config
-     * - `port`: Database port number from config
-     * - `database`: Database name from config
-     * - `user`: Database username from config
-     * - `password`: Database password from config (optional)
-     * - `ssl`: SSL configuration from config (optional)
-     *
-     * **Important Notes:**
-     * - No external resources are created (unlike SSH tunnels)
-     * - Returns synchronously despite Promise signature (for consistency with base class)
-     * - Password is optional to support future IAM authentication methods
-     * - SSL configuration is passed through unchanged for database client to handle
-     *
-     * @returns {Promise<ConnectionParams>} Connection parameters for database client
-     *
-     * @throws {Error} If configuration is invalid (call `validate()` first)
-     *
-     * @example
-     * // Basic authentication flow
-     * const provider = new DirectAuthProvider(config);
-     * provider.validate();
-     * const params = await provider.authenticate();
-     * console.log(params);
-     * // {
-     * //   host: 'localhost',
-     * //   port: 5432,
-     * //   database: 'dev_db',
-     * //   user: 'postgres',
-     * //   password: 'postgres'
-     * // }
-     *
-     * @example
-     * // With SSL configuration preserved
-     * const config = {
-     *   connection: { host: 'db.example.com', port: 5432, database: 'app' },
-     *   auth: {
-     *     type: 'direct',
-     *     user: 'admin',
-     *     password: 'secret',
-     *     ssl: {
-     *       ca: '/path/to/ca.pem',
-     *       rejectUnauthorized: true
-     *     }
-     *   }
-     * };
-     * const provider = new DirectAuthProvider(config);
-     * const params = await provider.authenticate();
-     * // SSL config passed through to database client
-     * // params.ssl.ca = '/path/to/ca.pem'
-     *
-     * @example
-     * // Without password (future IAM authentication)
-     * const config = {
-     *   connection: { host: 'db.example.com', port: 5432, database: 'app' },
-     *   auth: {
-     *     type: 'direct',
-     *     user: 'iam_user'
-     *     // password will be generated by IAM provider
-     *   }
-     * };
-     * const provider = new DirectAuthProvider(config);
-     * const params = await provider.authenticate();
-     * // params.password will be undefined
-     *
-     * @example
-     * // Error handling (validation errors)
-     * const provider = new DirectAuthProvider(invalidConfig);
-     * try {
-     *   const params = await provider.authenticate();
-     * } catch (error) {
-     *   if (error.message.includes('host')) {
-     *     console.error('Missing database host');
-     *   } else if (error.message.includes('user')) {
-     *     console.error('Missing database user');
-     *   }
-     * }
-     */
+    /** Authenticates and returns connection parameters. */
     authenticate(): Promise<ConnectionParams>;
-    /**
-     * Cleanup method for direct connections (no-op).
-     *
-     * Since direct connections do not create any intermediate resources
-     * (no SSH tunnels, proxy servers, or temporary tokens), this method
-     * has nothing to clean up. It is implemented as a no-op for consistency
-     * with the BaseAuthProvider interface.
-     *
-     * **Cleanup Behavior:**
-     * - No-op (does nothing)
-     * - Idempotent (safe to call multiple times)
-     * - Returns immediately
-     * - Never throws errors
-     *
-     * This method exists to maintain API consistency with other auth providers
-     * that DO require cleanup (e.g., SSHAuthProvider closes tunnels).
-     *
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Basic cleanup (no-op)
-     * const provider = new DirectAuthProvider(config);
-     * const params = await provider.authenticate();
-     * // ... use database connection ...
-     * await provider.cleanup(); // Does nothing, but good practice
-     *
-     * @example
-     * // Cleanup in finally block (recommended pattern)
-     * const provider = new DirectAuthProvider(config);
-     * try {
-     *   const params = await provider.authenticate();
-     *   const db = await connect(params);
-     *   await db.query('SELECT 1');
-     * } finally {
-     *   // Always cleanup, even though it's a no-op for direct connections
-     *   // This ensures consistency when switching between auth providers
-     *   await provider.cleanup();
-     * }
-     *
-     * @example
-     * // Multiple cleanup calls (idempotent, no-op)
-     * await provider.cleanup(); // No-op
-     * await provider.cleanup(); // Still no-op
-     * await provider.cleanup(); // Always no-op
-     */
+    /** No-op: direct connections have no resources to clean up. */
     cleanup(): Promise<void>;
 }
 //# sourceMappingURL=direct-auth-provider.d.ts.map

package/dist/adapters/auth/direct-auth-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"direct-auth-provider.d.ts","sourceRoot":"","sources":["../../../src/adapters/auth/direct-auth-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AACH,qBAAa,kBAAmB,SAAQ,gBAAgB;IACtD;;;;;;;;OAQG;IACH,aAAa,IAAI,MAAM;IAIvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkEG;IACH,QAAQ,IAAI,IAAI;IAyBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsFG;IACG,YAAY,IAAI,OAAO,CAAC,gBAAgB,CAAC;IA2B/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ/B"}
+{"version":3,"file":"direct-auth-provider.d.ts","sourceRoot":"","sources":["../../../src/adapters/auth/direct-auth-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,uEAAuE;AACvE,qBAAa,kBAAmB,SAAQ,gBAAgB;IACtD,aAAa,IAAI,MAAM;IAIvB,iDAAiD;IACjD,QAAQ,IAAI,IAAI;IAwBhB,uDAAuD;IACjD,YAAY,IAAI,OAAO,CAAC,gBAAgB,CAAC;IA2B/C,+DAA+D;IACzD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}