@plyaz/db 0.0.0

package/dist/extensions/SoftDeleteExtension.d.ts

@@ -0,0 +1,430 @@
+/**
+ * @fileoverview Soft Delete Extension for @plyaz/db package
+ *
+ * This module provides the SoftDeleteAdapter extension that implements logical deletion
+ * instead of physical record removal. It automatically intercepts delete operations
+ * and converts them to timestamp updates, while filtering queries to exclude soft-deleted records.
+ *
+ * Part of the @plyaz/db package - a TypeScript database abstraction layer with
+ * support for multiple adapters (Drizzle, Supabase, SQL), extensions (audit, encryption,
+ * soft delete), and advanced features (caching, read replicas, multi-tenancy).
+ *
+ */
+import type { DatabaseAdapterType, DatabaseResult, PaginatedResult, QueryOptions, Filter, DatabaseHealthStatus, Transaction } from "@plyaz/types/db";
+/**
+ * SOFT DELETE ADAPTER - Logical Deletion Layer
+ *
+ * Soft delete extension that implements logical deletion instead of physical removal.
+ * Third layer in the adapter chain.
+ *
+ * **Adapter Chain Position:**
+ * ReadReplica -> Audit -> Cache -> **SoftDelete** -> Encryption -> Base Adapter
+ *
+ * **What this adapter does:**
+ * 1. Intercepts delete() operations  sets deletedAt timestamp instead of removing
+ * 2. Intercepts query/list operations  adds "WHERE deletedAt IS NULL" filter
+ * 3. Provides restore() method to undelete records
+ * 4. Honors includeSoftDeleted flag from operation config
+ *
+ * **Called by:** CachingAdapter (or AuditAdapter if no caching)
+ * **Calls:** EncryptionAdapter (or base adapter if no encryption)
+ * **Provides:** restore(), permanentDelete() methods
+ *
+ * **Soft Delete Flow:**
+ * - **Delete:** Sets deletedAt = NOW() instead of removing record
+ * - **Queries:** Automatically filters WHERE deletedAt IS NULL
+ * - **Restore:** Sets deletedAt = NULL to undelete
+ *
+ * @example
+ * ### Configuration
+ * ```typescript
+ * softDelete: {
+ *   enabled: true,
+ *   field: 'deletedAt',           // Custom field name
+ *   excludeTables: ['audit_logs']  // Tables that use hard delete
+ * }
+ * ```
+ *
+ * @example
+ * ### Usage Flow
+ * ```typescript
+ * // Normal delete - sets deletedAt timestamp
+ * await db.delete(Tables.USERS, 'user-123');
+ *
+ * // Query automatically excludes soft-deleted records
+ * const activeUsers = await db.query(Tables.USERS, {});
+ *
+ * // Include soft-deleted records with operation config
+ * const allUsers = await db.query(Tables.USERS, {}, {
+ *   includeSoftDeleted: true
+ * });
+ *
+ * // Restore soft-deleted record
+ * await db.restore(Tables.USERS, 'user-123');
+ * ```
+ */
+export declare class SoftDeleteAdapter implements DatabaseAdapterType {
+    private baseAdapter;
+    private config;
+    /**
+     * Creates a new SoftDeleteAdapter instance.
+     *
+     * **RESPONSIBILITY:** Wraps base adapter with soft delete functionality
+     * **CONFIGURATION:** Sets up deletion field name and excluded tables
+     *
+     * @param baseAdapter - The underlying database adapter to wrap
+     * @param config - Soft delete configuration options
+     *
+     * @example
+     * ```typescript
+     * const softDeleteAdapter = new SoftDeleteAdapter(baseAdapter, {
+     *   enabled: true,
+     *   field: 'deletedAt',
+     *   excludeTables: ['audit_logs', 'system_events']
+     * });
+     * ```
+     */
+    constructor(baseAdapter: DatabaseAdapterType, config: {
+        enabled: boolean;
+        field?: string;
+        excludeTables?: string[];
+    });
+    /**
+     * Initializes the soft delete adapter and underlying adapter.
+     *
+     * **RESPONSIBILITY:** Passes initialization to base adapter
+     * **BEHAVIOR:** No additional initialization needed for soft delete
+     *
+     * @returns Promise resolving to initialization result
+     *
+     * @example
+     * ```typescript
+     * const result = await softDeleteAdapter.initialize();
+     * if (result.success) {
+     *   console.log('Soft delete 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 softDeleteAdapter.connect();
+     * console.log('Connected with soft delete support');
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Closes database connection through base adapter.
+     *
+     * **RESPONSIBILITY:** Delegates disconnection to underlying adapter
+     * **BEHAVIOR:** No additional cleanup needed for soft delete
+     *
+     * @example
+     * ```typescript
+     * await softDeleteAdapter.disconnect();
+     * console.log('Disconnected gracefully');
+     * ```
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Gets the underlying database client.
+     *
+     * **RESPONSIBILITY:** Provides access to raw database client
+     * **USE CASE:** For operations that bypass soft delete logic
+     *
+     * @returns Database client object
+     *
+     * @example
+     * ```typescript
+     * const client = softDeleteAdapter.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 modification
+     * **BEHAVIOR:** Does not apply soft delete filtering to raw SQL
+     * **NOTE:** Use findMany() for automatic soft delete filtering
+     *
+     * @param sql - SQL query string
+     * @param params - Query parameters
+     * @returns Query results
+     *
+     * @example
+     * ```typescript
+     * // Raw SQL bypasses soft delete filtering
+     * const allUsers = await adapter.query(
+     *   'SELECT * FROM users', // Includes soft-deleted records
+     *   []
+     * );
+     *
+     * // Use findMany for automatic filtering
+     * const activeUsers = await adapter.findMany('users'); // Excludes soft-deleted
+     * ```
+     */
+    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
+     * softDeleteAdapter.registerTable('users', userSchema, 'id');
+     * // Table now supports soft delete operations
+     * ```
+     */
+    registerTable<T, U>(name: string, table: T, idColumn?: U): void;
+    /**
+     * Finds a record by ID with automatic soft delete filtering.
+     *
+     * **RESPONSIBILITY:** Retrieves single record, excluding soft-deleted by default
+     * **FILTERING:** Automatically excludes records where deletedAt IS NOT NULL
+     * **OVERRIDE:** Can include soft-deleted records with operation config
+     *
+     * @param table - Table name
+     * @param id - Record ID
+     * @returns Found record or null
+     *
+     * @example
+     * ```typescript
+     * // Excludes soft-deleted records by default
+     * const user = await adapter.findById('users', 'user-123');
+     * if (!user.value) {
+     *   console.log('User not found or soft-deleted');
+     * }
+     *
+     * // Include soft-deleted records with config
+     * const userIncludingDeleted = await adapter.findById('users', 'user-123', {
+     *   includeSoftDeleted: true
+     * });
+     * ```
+     */
+    findById<T>(table: string, id: string): Promise<DatabaseResult<T | null>>;
+    findMany<T>(table: string, options?: QueryOptions): Promise<DatabaseResult<PaginatedResult<T>>>;
+    /**
+     * Creates a new record through base adapter.
+     *
+     * **RESPONSIBILITY:** Passes creation to base adapter without modification
+     * **BEHAVIOR:** New records have deletedAt = NULL by default
+     *
+     * @param table - Table name
+     * @param data - Record data
+     * @returns Created record
+     *
+     * @example
+     * ```typescript
+     * const result = await adapter.create('users', {
+     *   name: 'John Doe',
+     *   email: 'john@example.com'
+     *   // deletedAt will be NULL (not soft-deleted)
+     * });
+     *
+     * if (result.success) {
+     *   console.log('User created:', result.value.id);
+     * }
+     * ```
+     */
+    create<T>(table: string, data: T): Promise<DatabaseResult<T>>;
+    /**
+     * Updates an existing record through base adapter.
+     *
+     * **RESPONSIBILITY:** Passes update to base adapter without modification
+     * **BEHAVIOR:** Can update soft-deleted records (they remain soft-deleted)
+     * **NOTE:** Use restore() to undelete records
+     *
+     * @param table - Table name
+     * @param id - Record ID
+     * @param data - Partial record data
+     * @returns Updated record
+     *
+     * @example
+     * ```typescript
+     * // Update active record
+     * const result = await adapter.update('users', 'user-123', {
+     *   name: 'Jane Doe'
+     * });
+     *
+     * // Can also update soft-deleted records
+     * const softDeletedUpdate = await adapter.update('users', 'deleted-user', {
+     *   email: 'newemail@example.com'
+     *   // Record remains soft-deleted after update
+     * });
+     * ```
+     */
+    update<T>(table: string, id: string, data: Partial<T>): Promise<DatabaseResult<T>>;
+    delete(table: string, id: string): Promise<DatabaseResult<void>>;
+    /**
+     * Executes operations within a transaction.
+     *
+     * **RESPONSIBILITY:** Passes transaction to base adapter
+     * **BEHAVIOR:** Soft delete operations within transaction are atomic
+     * **ROLLBACK:** Failed transactions rollback soft delete operations
+     *
+     * @param callback - Transaction callback function
+     * @returns Transaction result
+     *
+     * @example
+     * ```typescript
+     * const result = await adapter.transaction(async (trx) => {
+     *   // Create user
+     *   const user = await trx.create('users', { name: 'John' });
+     *
+     *   // Soft delete old user (sets deletedAt)
+     *   await trx.delete('users', 'old-user-id');
+     *
+     *   return user;
+     * });
+     *
+     * // If transaction fails, both operations are rolled back
+     * ```
+     */
+    transaction<T>(callback: (trx: Transaction) => Promise<T>): Promise<DatabaseResult<T>>;
+    /**
+     * Checks if a record exists, excluding soft-deleted records.
+     *
+     * **RESPONSIBILITY:** Verifies record existence with soft delete filtering
+     * **BEHAVIOR:** Returns false for soft-deleted records by default
+     * **FILTERING:** Automatically excludes records where deletedAt IS NOT NULL
+     *
+     * @param table - Table name
+     * @param id - Record ID
+     * @returns True if record exists and is not soft-deleted
+     *
+     * @example
+     * ```typescript
+     * // Check if active user exists
+     * const userExists = await adapter.exists('users', 'user-123');
+     * if (userExists.value) {
+     *   console.log('User exists and is active');
+     * } else {
+     *   console.log('User not found or soft-deleted');
+     * }
+     *
+     * // Soft-deleted records return false
+     * await adapter.delete('users', 'user-123'); // Soft delete
+     * const stillExists = await adapter.exists('users', 'user-123'); // false
+     * ```
+     */
+    exists(table: string, id: string): Promise<DatabaseResult<boolean>>;
+    /**
+     * Counts records in a table, excluding soft-deleted records.
+     *
+     * **RESPONSIBILITY:** Counts records with automatic soft delete filtering
+     * **BEHAVIOR:** Excludes soft-deleted records from count by default
+     * **FILTERING:** Automatically adds deletedAt IS NULL filter
+     *
+     * @param table - Table name
+     * @param filter - Optional filter conditions
+     * @returns Count of non-soft-deleted records
+     *
+     * @example
+     * ```typescript
+     * // Count active users only
+     * const activeCount = await adapter.count('users');
+     * console.log('Active users:', activeCount.value);
+     *
+     * // Count with additional filter
+     * const premiumActiveUsers = await adapter.count('users', {
+     *   field: 'plan',
+     *   operator: 'eq',
+     *   value: 'premium'
+     * });
+     * // Returns count of premium users that are NOT soft-deleted
+     * ```
+     */
+    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 soft delete
+     *
+     * @returns Health status from base adapter
+     *
+     * @example
+     * ```typescript
+     * const health = await adapter.healthCheck();
+     * if (health.success && health.value?.isHealthy) {
+     *   console.log('Database healthy with soft delete support');
+     * }
+     * ```
+     */
+    healthCheck(): Promise<DatabaseResult<DatabaseHealthStatus>>;
+    /**
+     * Restores a previously soft-deleted record by clearing the deletion timestamp
+     *
+     * Undeletes a record by setting the soft delete field (typically 'deletedAt') to null,
+     * making it visible in queries again. This operation is only available when soft delete
+     * is enabled in the configuration.
+     *
+     * **Restore Process:**
+     * 1. Validates that soft delete is enabled
+     * 2. Sets the deletion field to null via update operation
+     * 3. Logs the restoration for audit purposes
+     * 4. Returns success or failure result
+     *
+     * @param {string} table - Name of the table containing the record to restore
+     * @param {string} id - Primary key ID of the record to restore
+     * @returns {Promise<DatabaseResult<void>>} Promise resolving to success/failure result
+     *
+     * @example
+     * ```typescript
+     * // Restore a soft-deleted user
+     * const restoreResult = await softDeleteAdapter.restore('users', 'user-123');
+     * if (restoreResult.success) {
+     *   console.log('User restored successfully');
+     * } else {
+     *   console.error('Restore failed:', restoreResult.error.message);
+     * }
+     *
+     * // After restoration, the record will appear in queries again
+     * const user = await adapter.findById('users', 'user-123');
+     * // user will now be found (not null)
+     * ```
+     *
+     * @throws {DatabaseError} SOFT_DELETE_NOT_ENABLED - If soft delete is not enabled in configuration
+     * @throws {DatabaseError} SOFT_DELETE_RESTORE_FAILED - If the restore operation fails
+     *
+     */
+    restore(table: string, id: string): Promise<DatabaseResult<void>>;
+    /**
+     * Checks if a table is excluded from soft delete functionality.
+     *
+     * **RESPONSIBILITY:** Determines if table should use hard delete instead
+     * **CONFIGURATION:** Based on excludeTables array in config
+     * **USE CASE:** Some tables like audit logs need permanent deletion
+     *
+     * @private
+     * @param table - Name of the table to check
+     * @returns True if table is excluded from soft delete
+     *
+     * @example
+     * ```typescript
+     * // Configuration: { excludeTables: ['audit_logs', 'temp_data'] }
+     *
+     * this.isExcluded('users');      // false - uses soft delete
+     * this.isExcluded('audit_logs'); // true - uses hard delete
+     * this.isExcluded('t
+    private isExcluded(table: string): boolean {
+      return this.config.excludeTables?.includes(table) ?? false;
+    }emp_data');  // true - uses hard delete
+     * ```
+     *
+     */
+    private isExcluded;
+}
+//# sourceMappingURL=SoftDeleteExtension.d.ts.map

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

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

package/dist/extensions/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Database Extension Adapters — Advanced Database Functionality
+ *
+ * Provides a collection of extension adapters that enhance core database operations
+ * with advanced features such as soft deletes, encryption, audit logging, caching,
+ * and read replica support.
+ *
+ * These extensions implement the **Decorator Pattern**, wrapping base adapters
+ * to transparently add behavior while maintaining full type safety and composability.
+ *
+ * ---
+ *
+ * **Extension Chain Architecture:**
+ * ```
+ * DatabaseService → Extension Chain → Base Adapter → Database
+ *       ↓                ↓               ↓              ↓
+ *   Operations      AuditAdapter    DrizzleAdapter   PostgreSQL
+ *        ↓                ↓
+ *   SoftDeleteAdapter   SQL Execution
+ *        ↓
+ *   EncryptionAdapter
+ *        ↓
+ *   CachingAdapter
+ *        ↓
+ *   ReadReplicaAdapter
+ * ```
+ *
+ * ---
+ *
+ * **Available Extensions:**
+ * - **SoftDeleteAdapter** → Logical deletion with restore capabilities
+ * - **AuditAdapter** → Comprehensive audit logging with context tracking
+ * - **EncryptionAdapter** → Field-level encryption for sensitive data
+ * - **CachingAdapter** → Query result caching for high-performance reads
+ * - **ReadReplicaAdapter** → Read/write splitting and replica load balancing
+ *
+ * ---
+ *
+ * **Extension Benefits:**
+ * - **Composable** → Mix and match extensions as needed
+ * - **Transparent** → No changes required in business logic
+ * - **Configurable** → Fine-grained setup via unified configuration schema
+ * - **Type-Safe** → Full TypeScript support with strict type definitions
+ * - **Observable** → Integrates with monitoring and metrics systems
+ *
+ * ---
+ *
+ * @example
+ * ```typescript
+ * // Extensions are automatically configured via createDatabaseService
+ * const service = await createDatabaseService({
+ *   adapter: 'drizzle',
+ *   connectionString: process.env.DATABASE_URL,
+ *
+ *   // Extension configurations
+ *   softDelete: { enabled: true, field: 'deletedAt' },
+ *   encryption: { enabled: true, key: process.env.ENCRYPTION_KEY },
+ *   audit: { enabled: true, retentionDays: 90 },
+ *   cache: { enabled: true, ttl: 300 },
+ *   replica: { enabled: true, replicas: ['postgres://replica1', 'postgres://replica2'] }
+ * });
+ *
+ * // All operations automatically use configured extensions
+ * await service.create('users', userData); // → encrypted, audited
+ * await service.delete('users', '123');    // → soft deleted, audited
+ * const users = await service.findMany('users'); // → cached, routed to replica
+ * ```
+ */
+/** Logical deletion with restore capabilities */
+export { SoftDeleteAdapter } from "./SoftDeleteExtension";
+/** Comprehensive audit logging with context tracking */
+export { AuditAdapter } from "./AuditExtension";
+/** Field-level encryption for sensitive data protection */
+export { EncryptionAdapter } from "./EncryptionExtension";
+/** Query result caching for improved performance */
+export { CachingAdapter } from "./CachingAdapter";
+/** Read/write splitting with replica load balancing and failover */
+export { ReadReplicaAdapter } from "./ReadReplicaAdapter";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extensions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH,iDAAiD;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,wDAAwD;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,2DAA2D;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,oDAAoD;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,oEAAoE;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/factory/AdapterFactory.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview Adapter Factory for @plyaz/db package
+ *
+ * This module provides the AdapterFactory class responsible for creating database adapter instances
+ * based on configuration. Supports multiple database adapters including Drizzle ORM, Supabase,
+ * and raw SQL adapters.
+ *
+ * Part of the @plyaz/db package factory system that creates the complete adapter chain:
+ * AdapterFactory → Base Adapter → Extension Wrappers → Final Adapter Chain
+ *
+ */
+import type { DatabaseAdapterType, DatabaseConfig } from "@plyaz/types/db";
+/**
+ * ADAPTER FACTORY - Database Adapter Creation
+ *
+ * Factory class responsible for creating database adapter instances based on configuration.
+ * This is the first step in the adapter chain creation process.
+ *
+ * **Factory Pattern Implementation:**
+ * - Takes adapter type and configuration as input
+ * - Returns appropriate DatabaseAdapterType implementation
+ * - Handles type safety and error cases
+ * - Supports all available database adapters
+ *
+ * **Supported Adapters:**
+ * - DrizzleAdapter: For Drizzle ORM integration
+ * - SupabaseAdapter: For Supabase database integration
+ * - SQLAdapter: For raw SQL database operations
+ *
+ * **Usage Flow:**
+ * createDatabaseService() → **AdapterFactory.create()** → Base Adapter → Extension Wrappers
+ *
+ * @example
+ * ```typescript
+ * // Create Drizzle adapter
+ * const drizzleAdapter = AdapterFactory.create(ADAPTERS.DRIZZLE, {
+ *   adapter: ADAPTERS.DRIZZLE,
+ *   connection: { host: 'localhost', port: 5432 },
+ *   database: 'myapp'
+ * });
+ *
+ * // Create Supabase adapter
+ * const supabaseAdapter = AdapterFactory.create(ADAPTERS.SUPABASE, {
+ *   adapter: ADAPTERS.SUPABASE,
+ *   url: 'https://project.supabase.co',
+ *   key: 'your-anon-key'
+ * });
+ * ```
+ *
+ */
+export declare class AdapterFactory {
+    /**
+     * Creates a new database adapter instance based on the configuration
+     *
+     * This is the core factory method that instantiates the appropriate database adapter
+     * based on the provided type and configuration. Uses TypeScript generics to ensure
+     * type safety between adapter type and configuration.
+     *
+     * **Creation Process:**
+     * 1. Validates input parameters (type and config)
+     * 2. Uses switch statement to match adapter type
+     * 3. Instantiates appropriate adapter class with type-safe config
+     * 4. Returns DatabaseAdapterType interface implementation
+     *
+     * **Type Safety:**
+     * - Generic T extends DatabaseConfig ensures config matches adapter type
+     * - Type assertions (as DrizzleAdapterConfig) provide compile-time safety
+     * - Runtime validation prevents invalid configurations
+     *
+     * @template T - Database configuration type that extends DatabaseConfig
+     * @param {T["adapter"]} type - Adapter type from ADAPTERS enum (drizzle, supabase, sql)
+     * @param {T} config - Database configuration object matching the adapter type
+     * @returns {DatabaseAdapterType} The appropriate adapter implementation
+     *
+     * @throws {Error} If adapter type is not provided
+     * @throws {Error} If adapter configuration is not provided
+     * @throws {Error} If unsupported adapter type is specified
+     * @throws {Error} If adapter instantiation fails
+     *
+     * @example
+     * ```typescript
+     * // Create Drizzle adapter with PostgreSQL
+     * const drizzleAdapter = AdapterFactory.create(ADAPTERS.DRIZZLE, {
+     *   adapter: ADAPTERS.DRIZZLE,
+     *   connection: {
+     *     host: 'localhost',
+     *     port: 5432,
+     *     database: 'myapp',
+     *     user: 'postgres',
+     *     password: 'password'
+     *   }
+     * });
+     *
+     * // Create Supabase adapter
+     * const supabaseAdapter = AdapterFactory.create(ADAPTERS.SUPABASE, {
+     *   adapter: ADAPTERS.SUPABASE,
+     *   url: 'https://xyzcompany.supabase.co',
+     *   key: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+     * });
+     *
+     * // Create SQL adapter for custom database
+     * const sqlAdapter = AdapterFactory.create(ADAPTERS.SQL, {
+     *   adapter: ADAPTERS.SQL,
+     *   connectionString: 'postgresql://user:pass@localhost:5432/db'
+     * });
+     * ```
+     *
+     */
+    static create<T extends DatabaseConfig>(type: T["adapter"], config: T): DatabaseAdapterType;
+}
+//# sourceMappingURL=AdapterFactory.d.ts.map

package/dist/factory/AdapterFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdapterFactory.d.ts","sourceRoot":"","sources":["../../src/factory/AdapterFactory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EAIf,MAAM,iBAAiB,CAAC;AAKzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,cAAc;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,cAAc,EACpC,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,EAClB,MAAM,EAAE,CAAC,GACR,mBAAmB;CAiEvB"}