@ductape/sdk 0.0.4 → 0.0.6

package/dist/database/adapters/base.adapter.d.ts

@@ -0,0 +1,423 @@
+/**
+ * Base Adapter - Abstract interface for database adapters
+ *
+ * All database-specific adapters (PostgreSQL, MySQL, MongoDB, DynamoDB, MariaDB, Cassandra)
+ * must extend this base class and implement all abstract methods.
+ */
+import { DatabaseType } from '../types/enums';
+import { IAdapterConnectionOptions, IAdapterConnectionResult } from '../types/connection.interface';
+import { IQueryResult, IRawQueryOptions, IRawQueryResult, IBuiltQuery } from '../types/query.interface';
+import { IInsertOptions, IInsertResult, IUpdateOptions, IUpdateResult, IDeleteOptions, IDeleteResult, IUpsertOptions, IUpsertResult } from '../types/write.interface';
+import { ITransactionContext, ISavepoint } from '../types/transaction.interface';
+import { ICountOptions, ISumOptions, IAvgOptions, IMinMaxOptions, IAggregateResult, IGroupByResult, IBuiltAggregation } from '../types/aggregation.interface';
+import { ITableDefinition, IAlterTableOperation, ITableSchema, ITableInfo, IIndexDefinition, IIndexInfo, IIndexStatistics, ICreateTableOptions } from '../types/schema.interface';
+import { IsolationLevel } from '../types/enums';
+/**
+ * Abstract base class for all database adapters
+ *
+ * Each database type (PostgreSQL, MySQL, MongoDB, DynamoDB, MariaDB, Cassandra)
+ * must implement all abstract methods to provide consistent behavior across
+ * the ORM layer.
+ */
+export declare abstract class BaseAdapter {
+    /** Database type this adapter handles */
+    protected abstract readonly databaseType: DatabaseType;
+    /** Native client instance (database-specific) */
+    protected client: any;
+    /** Connection state */
+    protected connected: boolean;
+    /** Connection URL */
+    protected connectionUrl: string;
+    /** Connection options (stored for reconnection) */
+    protected connectionOptions: IAdapterConnectionOptions | null;
+    /** Maximum retry attempts for auto-reconnection */
+    protected maxRetries: number;
+    /** Flag to indicate if a reconnection is in progress */
+    private reconnecting;
+    /**
+     * Execute an operation with automatic retry on connection errors.
+     * This handles transient connection timeouts and disconnects silently.
+     * @param operation The async operation to execute
+     * @param retries Maximum number of retries (default: 2)
+     * @returns The result of the operation
+     */
+    protected executeWithRetry<T>(operation: () => Promise<T>, retries?: number): Promise<T>;
+    /**
+     * Check if an error is a connection-related error that might benefit from reconnection
+     * @param error The error to check
+     * @returns True if the error is connection-related
+     */
+    protected isConnectionError(error: any): boolean;
+    /**
+     * Attempt to reconnect to the database.
+     * Subclasses should override this to implement database-specific reconnection.
+     */
+    protected attemptReconnect(): Promise<void>;
+    /**
+     * Get the database type this adapter handles
+     */
+    getDatabaseType(): DatabaseType;
+    /**
+     * Check if adapter is currently connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get the native client instance
+     */
+    getClient(): any;
+    /**
+     * Connect to the database
+     * @param options Connection options including URL
+     * @returns Connection result with version and other info
+     */
+    abstract connect(options: IAdapterConnectionOptions): Promise<IAdapterConnectionResult>;
+    /**
+     * Test connection without establishing persistent connection
+     * @param options Connection options
+     * @returns Connection test result
+     */
+    abstract testConnection(options: IAdapterConnectionOptions): Promise<IAdapterConnectionResult>;
+    /**
+     * Disconnect from the database
+     */
+    abstract disconnect(): Promise<void>;
+    /**
+     * Execute a built query
+     * @param query Built query from QueryBuilder
+     * @returns Query result with data and count
+     */
+    abstract query<T = any>(query: IBuiltQuery): Promise<IQueryResult<T>>;
+    /**
+     * Execute a raw query/command
+     * @param options Raw query options
+     * @returns Raw query result
+     */
+    abstract raw<T = any>(options: IRawQueryOptions): Promise<IRawQueryResult<T>>;
+    /**
+     * Insert one or more records
+     * @param options Insert options
+     * @returns Insert result with IDs and count
+     */
+    abstract insert<T = any>(options: IInsertOptions): Promise<IInsertResult<T>>;
+    /**
+     * Update records matching conditions
+     * @param options Update options with where clause
+     * @returns Update result with affected count
+     */
+    abstract update<T = any>(options: IUpdateOptions): Promise<IUpdateResult<T>>;
+    /**
+     * Delete records matching conditions
+     * @param options Delete options with where clause
+     * @returns Delete result with affected count
+     */
+    abstract delete(options: IDeleteOptions): Promise<IDeleteResult>;
+    /**
+     * Insert or update based on conflict keys
+     * @param options Upsert options
+     * @returns Upsert result with operation type
+     */
+    abstract upsert<T = any>(options: IUpsertOptions): Promise<IUpsertResult<T>>;
+    /**
+     * Count records matching conditions
+     * @param options Count options
+     * @returns Number of matching records
+     */
+    abstract count(options: ICountOptions): Promise<number>;
+    /**
+     * Sum values of a column
+     * @param options Sum options
+     * @returns Sum of column values
+     */
+    abstract sum(options: ISumOptions): Promise<number>;
+    /**
+     * Calculate average of a column
+     * @param options Average options
+     * @returns Average of column values
+     */
+    abstract avg(options: IAvgOptions): Promise<number>;
+    /**
+     * Get minimum value of a column
+     * @param options Min options
+     * @returns Minimum value
+     */
+    abstract min(options: IMinMaxOptions): Promise<any>;
+    /**
+     * Get maximum value of a column
+     * @param options Max options
+     * @returns Maximum value
+     */
+    abstract max(options: IMinMaxOptions): Promise<any>;
+    /**
+     * Execute multiple aggregations
+     * @param builtAggregation Built aggregation from AggregationBuilder
+     * @returns Aggregation results
+     */
+    abstract aggregate(builtAggregation: IBuiltAggregation): Promise<IAggregateResult>;
+    /**
+     * Group records and aggregate
+     * @param builtGroupBy Built group by from AggregationBuilder
+     * @returns Grouped results
+     */
+    abstract groupBy<T = any>(builtGroupBy: IBuiltAggregation): Promise<IGroupByResult<T>[]>;
+    /**
+     * Begin a new transaction
+     * @param isolationLevel Transaction isolation level
+     * @param readOnly Whether transaction is read-only
+     * @param timeout Transaction timeout in milliseconds
+     * @returns Transaction context
+     */
+    abstract beginTransaction(isolationLevel?: IsolationLevel, readOnly?: boolean, timeout?: number): Promise<ITransactionContext>;
+    /**
+     * Commit a transaction
+     * @param context Transaction context to commit
+     */
+    abstract commitTransaction(context: ITransactionContext): Promise<void>;
+    /**
+     * Rollback a transaction
+     * @param context Transaction context to rollback
+     */
+    abstract rollbackTransaction(context: ITransactionContext): Promise<void>;
+    /**
+     * Create a savepoint within a transaction
+     * @param context Transaction context
+     * @param name Savepoint name
+     * @returns Savepoint instance
+     */
+    abstract createSavepoint(context: ITransactionContext, name: string): Promise<ISavepoint>;
+    /**
+     * Release a savepoint
+     * @param context Transaction context
+     * @param savepoint Savepoint to release
+     */
+    abstract releaseSavepoint(context: ITransactionContext, savepoint: ISavepoint): Promise<void>;
+    /**
+     * Rollback to a savepoint
+     * @param context Transaction context
+     * @param savepoint Savepoint to rollback to
+     */
+    abstract rollbackToSavepoint(context: ITransactionContext, savepoint: ISavepoint): Promise<void>;
+    /**
+     * Check if the database supports savepoints
+     * @returns Whether savepoints are supported
+     */
+    abstract supportsSavepoints(): boolean;
+    /**
+     * Create a new table
+     * @param definition Table definition
+     * @param options Create options
+     */
+    abstract createTable(definition: ITableDefinition, options?: ICreateTableOptions): Promise<void>;
+    /**
+     * Alter an existing table
+     * @param tableName Table to alter
+     * @param operations Alterations to perform
+     */
+    abstract alterTable(tableName: string, operations: IAlterTableOperation[]): Promise<void>;
+    /**
+     * Drop a table
+     * @param tableName Table to drop
+     * @param ifExists Only drop if exists
+     * @param cascade Cascade to dependent objects
+     */
+    abstract dropTable(tableName: string, ifExists?: boolean, cascade?: boolean): Promise<void>;
+    /**
+     * List all tables in the database
+     * @returns Array of table names
+     */
+    abstract listTables(): Promise<string[]>;
+    /**
+     * List all tables with basic information including row counts
+     * @returns Array of table information
+     */
+    abstract listTablesWithInfo(): Promise<ITableInfo[]>;
+    /**
+     * Check if a table exists
+     * @param tableName Table name to check
+     * @returns Whether table exists
+     */
+    abstract tableExists(tableName: string): Promise<boolean>;
+    /**
+     * Get schema information for a table
+     * @param tableName Table to inspect
+     * @returns Table schema information
+     */
+    abstract getTableSchema(tableName: string): Promise<ITableSchema>;
+    /**
+     * Create an index
+     * @param index Index definition
+     * @param ifNotExists Only create if not exists
+     * @param concurrent Create concurrently (PostgreSQL)
+     */
+    abstract createIndex(index: IIndexDefinition, ifNotExists?: boolean, concurrent?: boolean): Promise<void>;
+    /**
+     * Drop an index
+     * @param tableName Table containing the index
+     * @param indexName Index name to drop
+     * @param ifExists Only drop if exists
+     * @param concurrent Drop concurrently (PostgreSQL)
+     * @param cascade Cascade to dependent objects
+     */
+    abstract dropIndex(tableName: string, indexName: string, ifExists?: boolean, concurrent?: boolean, cascade?: boolean): Promise<void>;
+    /**
+     * List all indexes on a table
+     * @param tableName Table to list indexes for
+     * @param includeSystem Include system indexes
+     * @returns Array of index information
+     */
+    abstract listIndexes(tableName: string, includeSystem?: boolean): Promise<IIndexInfo[]>;
+    /**
+     * Get statistics for indexes
+     * @param tableName Table name
+     * @param indexName Optional specific index
+     * @returns Array of index statistics
+     */
+    abstract getIndexStatistics(tableName: string, indexName?: string): Promise<IIndexStatistics[]>;
+    /**
+     * Escape an identifier (table name, column name) for SQL
+     * @param identifier Identifier to escape
+     * @returns Escaped identifier
+     */
+    abstract escapeIdentifier(identifier: string): string;
+    /**
+     * Escape a value for use in SQL
+     * @param value Value to escape
+     * @returns Escaped value
+     */
+    abstract escapeValue(value: any): string;
+    /**
+     * Get the parameter placeholder for prepared statements
+     * @param index Parameter index (1-based for PostgreSQL, 0-based for MySQL)
+     * @returns Parameter placeholder string
+     */
+    abstract getParameterPlaceholder(index: number): string;
+    /**
+     * Get the database-specific column type string
+     * @param columnType Abstract column type
+     * @param options Type options (minLength, maxLength, precision, scale, etc.)
+     * @returns Database-specific type string
+     */
+    abstract getColumnTypeString(columnType: string, options?: {
+        minLength?: number;
+        maxLength?: number;
+        precision?: number;
+        scale?: number;
+        enumValues?: string[];
+        arrayType?: string;
+    }): string;
+    /**
+     * Check if the database supports a specific feature
+     * @param feature Feature name
+     * @returns Whether the feature is supported
+     */
+    supportsFeature(feature: DatabaseFeature): boolean;
+    /**
+     * Get list of supported features for this database
+     * @returns Array of supported feature names
+     */
+    abstract getSupportedFeatures(): DatabaseFeature[];
+    /**
+     * Parse error from native database error
+     * Maps database-specific error codes to DatabaseErrorType
+     * @param error Native error
+     * @returns Parsed error information
+     */
+    abstract parseError(error: any): {
+        type: string;
+        message: string;
+        code?: string;
+        details?: Record<string, any>;
+    };
+}
+/**
+ * Database features that may or may not be supported by each adapter
+ */
+export declare enum DatabaseFeature {
+    /** Transaction support */
+    TRANSACTIONS = "TRANSACTIONS",
+    /** Savepoint support within transactions */
+    SAVEPOINTS = "SAVEPOINTS",
+    /** JSONB data type (PostgreSQL) */
+    JSONB = "JSONB",
+    /** JSON data type */
+    JSON = "JSON",
+    /** Array data type */
+    ARRAYS = "ARRAYS",
+    /** UUID data type */
+    UUID = "UUID",
+    /** Full-text search */
+    FULLTEXT_SEARCH = "FULLTEXT_SEARCH",
+    /** GIN index type */
+    GIN_INDEX = "GIN_INDEX",
+    /** GIST index type */
+    GIST_INDEX = "GIST_INDEX",
+    /** Hash index type */
+    HASH_INDEX = "HASH_INDEX",
+    /** Partial/conditional indexes */
+    PARTIAL_INDEX = "PARTIAL_INDEX",
+    /** Covering indexes (INCLUDE clause) */
+    COVERING_INDEX = "COVERING_INDEX",
+    /** Concurrent index creation */
+    CONCURRENT_INDEX = "CONCURRENT_INDEX",
+    /** Common Table Expressions (WITH clause) */
+    CTE = "CTE",
+    /** Window functions */
+    WINDOW_FUNCTIONS = "WINDOW_FUNCTIONS",
+    /** RETURNING clause for insert/update/delete */
+    RETURNING = "RETURNING",
+    /** UPSERT / ON CONFLICT */
+    UPSERT = "UPSERT",
+    /** Foreign keys */
+    FOREIGN_KEYS = "FOREIGN_KEYS",
+    /** Check constraints */
+    CHECK_CONSTRAINTS = "CHECK_CONSTRAINTS",
+    /** Stored procedures */
+    STORED_PROCEDURES = "STORED_PROCEDURES",
+    /** Views */
+    VIEWS = "VIEWS",
+    /** Materialized views */
+    MATERIALIZED_VIEWS = "MATERIALIZED_VIEWS",
+    /** Triggers */
+    TRIGGERS = "TRIGGERS",
+    /** Schema/namespace support */
+    SCHEMAS = "SCHEMAS",
+    /** Table inheritance */
+    TABLE_INHERITANCE = "TABLE_INHERITANCE",
+    /** Read replicas */
+    READ_REPLICAS = "READ_REPLICAS",
+    /** Streaming replication */
+    STREAMING_REPLICATION = "STREAMING_REPLICATION",
+    /** Point in time recovery */
+    PITR = "PITR",
+    /** LIKE/ILIKE pattern matching */
+    LIKE = "LIKE",
+    /** Case-insensitive LIKE */
+    ILIKE = "ILIKE",
+    /** Regular expression matching */
+    REGEX = "REGEX",
+    /** BETWEEN operator */
+    BETWEEN = "BETWEEN",
+    /** Array contains operator */
+    ARRAY_CONTAINS = "ARRAY_CONTAINS",
+    /** LIMIT/OFFSET pagination */
+    LIMIT_OFFSET = "LIMIT_OFFSET",
+    /** Cursor-based pagination */
+    CURSOR_PAGINATION = "CURSOR_PAGINATION",
+    /** Aggregation framework (MongoDB) */
+    AGGREGATION_PIPELINE = "AGGREGATION_PIPELINE",
+    /** Secondary indexes */
+    SECONDARY_INDEXES = "SECONDARY_INDEXES",
+    /** Global secondary indexes (DynamoDB) */
+    GLOBAL_SECONDARY_INDEXES = "GLOBAL_SECONDARY_INDEXES",
+    /** Local secondary indexes (DynamoDB) */
+    LOCAL_SECONDARY_INDEXES = "LOCAL_SECONDARY_INDEXES",
+    /** TTL (Time to Live) for records */
+    TTL = "TTL",
+    /** Change streams / CDC */
+    CHANGE_STREAMS = "CHANGE_STREAMS",
+    /** Batch operations */
+    BATCH_OPERATIONS = "BATCH_OPERATIONS",
+    /** Atomic counters */
+    ATOMIC_COUNTERS = "ATOMIC_COUNTERS",
+    /** Deferrable transactions (PostgreSQL) */
+    DEFERRABLE_TRANSACTIONS = "DEFERRABLE_TRANSACTIONS"
+}

package/dist/database/adapters/base.adapter.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * Base Adapter - Abstract interface for database adapters
+ *
+ * All database-specific adapters (PostgreSQL, MySQL, MongoDB, DynamoDB, MariaDB, Cassandra)
+ * must extend this base class and implement all abstract methods.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseFeature = exports.BaseAdapter = void 0;
+/**
+ * Abstract base class for all database adapters
+ *
+ * Each database type (PostgreSQL, MySQL, MongoDB, DynamoDB, MariaDB, Cassandra)
+ * must implement all abstract methods to provide consistent behavior across
+ * the ORM layer.
+ */
+class BaseAdapter {
+    constructor() {
+        /** Native client instance (database-specific) */
+        this.client = null;
+        /** Connection state */
+        this.connected = false;
+        /** Connection URL */
+        this.connectionUrl = '';
+        /** Connection options (stored for reconnection) */
+        this.connectionOptions = null;
+        /** Maximum retry attempts for auto-reconnection */
+        this.maxRetries = 2;
+        /** Flag to indicate if a reconnection is in progress */
+        this.reconnecting = false;
+    }
+    // ==================== AUTO-RECONNECTION ====================
+    /**
+     * Execute an operation with automatic retry on connection errors.
+     * This handles transient connection timeouts and disconnects silently.
+     * @param operation The async operation to execute
+     * @param retries Maximum number of retries (default: 2)
+     * @returns The result of the operation
+     */
+    async executeWithRetry(operation, retries = this.maxRetries) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                // Check if it's a connection-related error that might benefit from retry
+                if (!this.isConnectionError(error) || attempt === retries) {
+                    throw error;
+                }
+                // Try to reconnect silently
+                try {
+                    await this.attemptReconnect();
+                }
+                catch (_a) {
+                    // If reconnect fails, throw the original error
+                    throw lastError;
+                }
+                // Small delay before retry (exponential backoff)
+                await new Promise(resolve => setTimeout(resolve, 500 * (attempt + 1)));
+            }
+        }
+        throw lastError || new Error('Operation failed after retries');
+    }
+    /**
+     * Check if an error is a connection-related error that might benefit from reconnection
+     * @param error The error to check
+     * @returns True if the error is connection-related
+     */
+    isConnectionError(error) {
+        var _a, _b;
+        const errorCode = ((_a = error.code) === null || _a === void 0 ? void 0 : _a.toString()) || '';
+        const errorMessage = ((_b = error.message) === null || _b === void 0 ? void 0 : _b.toLowerCase()) || '';
+        return (
+        // Common connection error codes
+        errorCode === 'ECONNRESET' ||
+            errorCode === 'ETIMEDOUT' ||
+            errorCode === 'ENOTFOUND' ||
+            errorCode === 'ECONNREFUSED' ||
+            errorCode === 'EPIPE' ||
+            errorCode === 'EHOSTUNREACH' ||
+            // PostgreSQL specific
+            errorCode === '08000' || // connection_exception
+            errorCode === '08003' || // connection_does_not_exist
+            errorCode === '08006' || // connection_failure
+            errorCode === '57P01' || // admin_shutdown
+            // MySQL specific
+            errorCode === 'PROTOCOL_CONNECTION_LOST' ||
+            errorCode === 'ER_CON_COUNT_ERROR' ||
+            // Common message patterns
+            errorMessage.includes('connection terminated') ||
+            errorMessage.includes('connection timeout') ||
+            errorMessage.includes('connection refused') ||
+            errorMessage.includes('connection lost') ||
+            errorMessage.includes('connection reset') ||
+            errorMessage.includes('socket hang up') ||
+            errorMessage.includes('econnreset') ||
+            errorMessage.includes('etimedout') ||
+            errorMessage.includes('read econnreset') ||
+            errorMessage.includes('cannot connect') ||
+            errorMessage.includes('server closed the connection') ||
+            errorMessage.includes('connection unexpectedly closed'));
+    }
+    /**
+     * Attempt to reconnect to the database.
+     * Subclasses should override this to implement database-specific reconnection.
+     */
+    async attemptReconnect() {
+        if (this.reconnecting) {
+            // Wait for existing reconnection attempt
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            if (this.connected)
+                return;
+            throw new Error('Reconnection already in progress');
+        }
+        if (!this.connectionOptions) {
+            throw new Error('Cannot reconnect: no connection options available');
+        }
+        this.reconnecting = true;
+        try {
+            // Disconnect first (ignore errors)
+            try {
+                await this.disconnect();
+            }
+            catch (_a) {
+                // Ignore disconnect errors during reconnection
+            }
+            // Reconnect
+            await this.connect(this.connectionOptions);
+        }
+        finally {
+            this.reconnecting = false;
+        }
+    }
+    // ==================== CONNECTION METHODS ====================
+    /**
+     * Get the database type this adapter handles
+     */
+    getDatabaseType() {
+        return this.databaseType;
+    }
+    /**
+     * Check if adapter is currently connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get the native client instance
+     */
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Check if the database supports a specific feature
+     * @param feature Feature name
+     * @returns Whether the feature is supported
+     */
+    supportsFeature(feature) {
+        const supportedFeatures = this.getSupportedFeatures();
+        return supportedFeatures.includes(feature);
+    }
+}
+exports.BaseAdapter = BaseAdapter;
+/**
+ * Database features that may or may not be supported by each adapter
+ */
+var DatabaseFeature;
+(function (DatabaseFeature) {
+    /** Transaction support */
+    DatabaseFeature["TRANSACTIONS"] = "TRANSACTIONS";
+    /** Savepoint support within transactions */
+    DatabaseFeature["SAVEPOINTS"] = "SAVEPOINTS";
+    /** JSONB data type (PostgreSQL) */
+    DatabaseFeature["JSONB"] = "JSONB";
+    /** JSON data type */
+    DatabaseFeature["JSON"] = "JSON";
+    /** Array data type */
+    DatabaseFeature["ARRAYS"] = "ARRAYS";
+    /** UUID data type */
+    DatabaseFeature["UUID"] = "UUID";
+    /** Full-text search */
+    DatabaseFeature["FULLTEXT_SEARCH"] = "FULLTEXT_SEARCH";
+    /** GIN index type */
+    DatabaseFeature["GIN_INDEX"] = "GIN_INDEX";
+    /** GIST index type */
+    DatabaseFeature["GIST_INDEX"] = "GIST_INDEX";
+    /** Hash index type */
+    DatabaseFeature["HASH_INDEX"] = "HASH_INDEX";
+    /** Partial/conditional indexes */
+    DatabaseFeature["PARTIAL_INDEX"] = "PARTIAL_INDEX";
+    /** Covering indexes (INCLUDE clause) */
+    DatabaseFeature["COVERING_INDEX"] = "COVERING_INDEX";
+    /** Concurrent index creation */
+    DatabaseFeature["CONCURRENT_INDEX"] = "CONCURRENT_INDEX";
+    /** Common Table Expressions (WITH clause) */
+    DatabaseFeature["CTE"] = "CTE";
+    /** Window functions */
+    DatabaseFeature["WINDOW_FUNCTIONS"] = "WINDOW_FUNCTIONS";
+    /** RETURNING clause for insert/update/delete */
+    DatabaseFeature["RETURNING"] = "RETURNING";
+    /** UPSERT / ON CONFLICT */
+    DatabaseFeature["UPSERT"] = "UPSERT";
+    /** Foreign keys */
+    DatabaseFeature["FOREIGN_KEYS"] = "FOREIGN_KEYS";
+    /** Check constraints */
+    DatabaseFeature["CHECK_CONSTRAINTS"] = "CHECK_CONSTRAINTS";
+    /** Stored procedures */
+    DatabaseFeature["STORED_PROCEDURES"] = "STORED_PROCEDURES";
+    /** Views */
+    DatabaseFeature["VIEWS"] = "VIEWS";
+    /** Materialized views */
+    DatabaseFeature["MATERIALIZED_VIEWS"] = "MATERIALIZED_VIEWS";
+    /** Triggers */
+    DatabaseFeature["TRIGGERS"] = "TRIGGERS";
+    /** Schema/namespace support */
+    DatabaseFeature["SCHEMAS"] = "SCHEMAS";
+    /** Table inheritance */
+    DatabaseFeature["TABLE_INHERITANCE"] = "TABLE_INHERITANCE";
+    /** Read replicas */
+    DatabaseFeature["READ_REPLICAS"] = "READ_REPLICAS";
+    /** Streaming replication */
+    DatabaseFeature["STREAMING_REPLICATION"] = "STREAMING_REPLICATION";
+    /** Point in time recovery */
+    DatabaseFeature["PITR"] = "PITR";
+    /** LIKE/ILIKE pattern matching */
+    DatabaseFeature["LIKE"] = "LIKE";
+    /** Case-insensitive LIKE */
+    DatabaseFeature["ILIKE"] = "ILIKE";
+    /** Regular expression matching */
+    DatabaseFeature["REGEX"] = "REGEX";
+    /** BETWEEN operator */
+    DatabaseFeature["BETWEEN"] = "BETWEEN";
+    /** Array contains operator */
+    DatabaseFeature["ARRAY_CONTAINS"] = "ARRAY_CONTAINS";
+    /** LIMIT/OFFSET pagination */
+    DatabaseFeature["LIMIT_OFFSET"] = "LIMIT_OFFSET";
+    /** Cursor-based pagination */
+    DatabaseFeature["CURSOR_PAGINATION"] = "CURSOR_PAGINATION";
+    /** Aggregation framework (MongoDB) */
+    DatabaseFeature["AGGREGATION_PIPELINE"] = "AGGREGATION_PIPELINE";
+    /** Secondary indexes */
+    DatabaseFeature["SECONDARY_INDEXES"] = "SECONDARY_INDEXES";
+    /** Global secondary indexes (DynamoDB) */
+    DatabaseFeature["GLOBAL_SECONDARY_INDEXES"] = "GLOBAL_SECONDARY_INDEXES";
+    /** Local secondary indexes (DynamoDB) */
+    DatabaseFeature["LOCAL_SECONDARY_INDEXES"] = "LOCAL_SECONDARY_INDEXES";
+    /** TTL (Time to Live) for records */
+    DatabaseFeature["TTL"] = "TTL";
+    /** Change streams / CDC */
+    DatabaseFeature["CHANGE_STREAMS"] = "CHANGE_STREAMS";
+    /** Batch operations */
+    DatabaseFeature["BATCH_OPERATIONS"] = "BATCH_OPERATIONS";
+    /** Atomic counters */
+    DatabaseFeature["ATOMIC_COUNTERS"] = "ATOMIC_COUNTERS";
+    /** Deferrable transactions (PostgreSQL) */
+    DatabaseFeature["DEFERRABLE_TRANSACTIONS"] = "DEFERRABLE_TRANSACTIONS";
+})(DatabaseFeature || (exports.DatabaseFeature = DatabaseFeature = {}));
+//# sourceMappingURL=base.adapter.js.map

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

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