@ductape/sdk 0.0.4-v51 → 0.0.4-v53

package/dist/database/actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/database/actions/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,mDAA8E;AAArE,+GAAA,aAAa,OAAA;AAAE,+GAAA,aAAa,OAAA;AAAE,8GAAA,YAAY,OAAA"}

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

@@ -0,0 +1,62 @@
+/**
+ * Adapter Factory - Creates database-specific adapters
+ *
+ * This factory is responsible for instantiating the correct adapter
+ * based on the database type.
+ */
+import { DatabaseType } from '../types/enums';
+import { BaseAdapter } from './base.adapter';
+/**
+ * Factory class for creating database adapters
+ */
+export declare class AdapterFactory {
+    /** Cache of adapter constructors for each database type */
+    private adapterConstructors;
+    /**
+     * Create a new adapter for the specified database type
+     *
+     * @param type Database type
+     * @returns New adapter instance
+     * @throws DatabaseError if database type is not supported
+     *
+     * @example
+     * const factory = new AdapterFactory();
+     * const adapter = factory.create(DatabaseType.POSTGRESQL);
+     */
+    create(type: DatabaseType): BaseAdapter;
+    /**
+     * Check if a database type is supported
+     *
+     * @param type Database type to check
+     * @returns Whether the type is supported
+     */
+    isSupported(type: DatabaseType | string): boolean;
+    /**
+     * Get list of supported database types
+     *
+     * @returns Array of supported database type strings
+     */
+    getSupportedTypes(): DatabaseType[];
+    /**
+     * Register a custom adapter for a database type
+     * Allows extending the factory with custom adapters
+     *
+     * @param type Database type
+     * @param AdapterConstructor Adapter class constructor
+     *
+     * @example
+     * class CustomPostgresAdapter extends PostgreSQLAdapter {
+     *   // Custom implementation
+     * }
+     *
+     * factory.registerAdapter(DatabaseType.POSTGRESQL, CustomPostgresAdapter);
+     */
+    registerAdapter(type: DatabaseType, AdapterConstructor: new () => BaseAdapter): void;
+    /**
+     * Unregister an adapter for a database type
+     *
+     * @param type Database type to unregister
+     * @returns Whether the adapter was unregistered
+     */
+    unregisterAdapter(type: DatabaseType): boolean;
+}

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

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Adapter Factory - Creates database-specific adapters
+ *
+ * This factory is responsible for instantiating the correct adapter
+ * based on the database type.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterFactory = void 0;
+const enums_1 = require("../types/enums");
+const postgresql_adapter_1 = require("./postgresql.adapter");
+const mysql_adapter_1 = require("./mysql.adapter");
+const mongodb_adapter_1 = require("./mongodb.adapter");
+const dynamodb_adapter_1 = require("./dynamodb.adapter");
+const mariadb_adapter_1 = require("./mariadb.adapter");
+const cassandra_adapter_1 = require("./cassandra.adapter");
+const database_error_1 = require("../utils/database-error");
+const enums_2 = require("../types/enums");
+/**
+ * Factory class for creating database adapters
+ */
+class AdapterFactory {
+    constructor() {
+        /** Cache of adapter constructors for each database type */
+        this.adapterConstructors = new Map([
+            [enums_1.DatabaseType.POSTGRESQL, postgresql_adapter_1.PostgreSQLAdapter],
+            [enums_1.DatabaseType.MYSQL, mysql_adapter_1.MySQLAdapter],
+            [enums_1.DatabaseType.MONGODB, mongodb_adapter_1.MongoDBAdapter],
+            [enums_1.DatabaseType.DYNAMODB, dynamodb_adapter_1.DynamoDBAdapter],
+            [enums_1.DatabaseType.MARIADB, mariadb_adapter_1.MariaDBAdapter],
+            [enums_1.DatabaseType.CASSANDRA, cassandra_adapter_1.CassandraAdapter],
+        ]);
+    }
+    /**
+     * Create a new adapter for the specified database type
+     *
+     * @param type Database type
+     * @returns New adapter instance
+     * @throws DatabaseError if database type is not supported
+     *
+     * @example
+     * const factory = new AdapterFactory();
+     * const adapter = factory.create(DatabaseType.POSTGRESQL);
+     */
+    create(type) {
+        const AdapterConstructor = this.adapterConstructors.get(type);
+        if (!AdapterConstructor) {
+            throw new database_error_1.DatabaseError(`Unsupported database type: ${type}. Supported types: ${this.getSupportedTypes().join(', ')}`, enums_2.DatabaseErrorType.VALIDATION_ERROR);
+        }
+        return new AdapterConstructor();
+    }
+    /**
+     * Check if a database type is supported
+     *
+     * @param type Database type to check
+     * @returns Whether the type is supported
+     */
+    isSupported(type) {
+        return this.adapterConstructors.has(type);
+    }
+    /**
+     * Get list of supported database types
+     *
+     * @returns Array of supported database type strings
+     */
+    getSupportedTypes() {
+        return Array.from(this.adapterConstructors.keys());
+    }
+    /**
+     * Register a custom adapter for a database type
+     * Allows extending the factory with custom adapters
+     *
+     * @param type Database type
+     * @param AdapterConstructor Adapter class constructor
+     *
+     * @example
+     * class CustomPostgresAdapter extends PostgreSQLAdapter {
+     *   // Custom implementation
+     * }
+     *
+     * factory.registerAdapter(DatabaseType.POSTGRESQL, CustomPostgresAdapter);
+     */
+    registerAdapter(type, AdapterConstructor) {
+        this.adapterConstructors.set(type, AdapterConstructor);
+    }
+    /**
+     * Unregister an adapter for a database type
+     *
+     * @param type Database type to unregister
+     * @returns Whether the adapter was unregistered
+     */
+    unregisterAdapter(type) {
+        return this.adapterConstructors.delete(type);
+    }
+}
+exports.AdapterFactory = AdapterFactory;
+//# sourceMappingURL=adapter.factory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.factory.js","sourceRoot":"","sources":["../../../src/database/adapters/adapter.factory.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,0CAA8C;AAE9C,6DAAyD;AACzD,mDAA+C;AAC/C,uDAAmD;AACnD,yDAAqD;AACrD,uDAAmD;AACnD,2DAAuD;AACvD,4DAAwD;AACxD,0CAAmD;AAEnD;;GAEG;AACH,MAAa,cAAc;IAA3B;QACE,2DAA2D;QACnD,wBAAmB,GAA6C,IAAI,GAAG,CAAsC;YACnH,CAAC,oBAAY,CAAC,UAAU,EAAE,sCAAiB,CAAC;YAC5C,CAAC,oBAAY,CAAC,KAAK,EAAE,4BAAY,CAAC;YAClC,CAAC,oBAAY,CAAC,OAAO,EAAE,gCAAc,CAAC;YACtC,CAAC,oBAAY,CAAC,QAAQ,EAAE,kCAAe,CAAC;YACxC,CAAC,oBAAY,CAAC,OAAO,EAAE,gCAAc,CAAC;YACtC,CAAC,oBAAY,CAAC,SAAS,EAAE,oCAAgB,CAAC;SAC3C,CAAC,CAAC;IAwEL,CAAC;IAtEC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,IAAkB;QACvB,MAAM,kBAAkB,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAE9D,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACxB,MAAM,IAAI,8BAAa,CACrB,8BAA8B,IAAI,sBAAsB,IAAI,CAAC,iBAAiB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAC7F,yBAAiB,CAAC,gBAAgB,CACnC,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,kBAAkB,EAAE,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,IAA2B;QACrC,OAAO,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAoB,CAAC,CAAC;IAC5D,CAAC;IAED;;;;OAIG;IACH,iBAAiB;QACf,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,CAAC,CAAC;IACrD,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,IAAkB,EAAE,kBAAyC;QAC3E,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;IACzD,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,IAAkB;QAClC,OAAO,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;CACF;AAjFD,wCAiFC"}

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

@@ -1,176 +1,393 @@
 /**
- * Base database adapter interface
- * All database-specific adapters must implement this interface
+ * 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, IConnection, IDatabaseConfig, ITransaction, ISavepoint, ITransactionOptions } from '../types/database.types';
-import { IQueryOptions, IInsertOptions, IUpdateOptions, IDeleteOptions, IUpsertOptions, IRawQueryOptions } from '../types/query.types';
-import { ICountOptions, ISumOptions, IAvgOptions, IMinOptions, IMaxOptions, IGroupByOptions, IAggregateOptions, IGroupByResult } from '../types/aggregation.types';
-import { ITableSchema, IColumnAlteration, ICreateTableOptions, IAlterTableOptions } from '../types/schema.types';
-import { ICreateIndexOptions, IDropIndexOptions, IListIndexesOptions, IIndexInfo, IIndexStatistics } from '../types/index.types';
-import { IMigrationDefinition, IMigrationExecutionOptions, IMigrationHistory, IMigrationResult } from '../types/migration.types';
-import { IQueryResult, IInsertResult, IUpdateResult, IDeleteResult, IUpsertResult, ISchemaOperationResult, IIndexOperationResult, IRawQueryResult, IConnectionTestResult } from '../types/result.types';
+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, IIndexDefinition, IIndexInfo, IIndexStatistics, ICreateTableOptions } from '../types/schema.interface';
+import { IsolationLevel } from '../types/enums';
 /**
- * Base database adapter abstract class
- * Provides common functionality and defines required methods
+ * 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 BaseDatabaseAdapter {
+export declare abstract class BaseAdapter {
     /** Database type this adapter handles */
-    abstract readonly type: DatabaseType;
+    protected abstract readonly databaseType: DatabaseType;
+    /** Native client instance (database-specific) */
+    protected client: any;
+    /** Connection state */
+    protected connected: boolean;
+    /** Connection URL */
+    protected connectionUrl: string;
     /**
-     * Create and establish a database connection
+     * Get the database type this adapter handles
      */
-    abstract connect(config: IDatabaseConfig): Promise<IConnection>;
+    getDatabaseType(): DatabaseType;
     /**
-     * Close a database connection
+     * Check if adapter is currently connected
      */
-    abstract disconnect(connection: IConnection): Promise<void>;
+    isConnected(): boolean;
     /**
-     * Test database connection
+     * Get the native client instance
      */
-    abstract testConnection(connection: IConnection): Promise<IConnectionTestResult>;
+    getClient(): any;
     /**
-     * Begin a new transaction
+     * Connect to the database
+     * @param options Connection options including URL
+     * @returns Connection result with version and other info
      */
-    abstract beginTransaction(connection: IConnection, options?: ITransactionOptions): Promise<ITransaction>;
+    abstract connect(options: IAdapterConnectionOptions): Promise<IAdapterConnectionResult>;
     /**
-     * Commit a transaction
+     * Test connection without establishing persistent connection
+     * @param options Connection options
+     * @returns Connection test result
      */
-    abstract commitTransaction(connection: IConnection, transaction: ITransaction): Promise<void>;
+    abstract testConnection(options: IAdapterConnectionOptions): Promise<IAdapterConnectionResult>;
     /**
-     * Rollback a transaction
+     * Disconnect from the database
      */
-    abstract rollbackTransaction(connection: IConnection, transaction: ITransaction): Promise<void>;
+    abstract disconnect(): Promise<void>;
     /**
-     * Create a savepoint within a transaction
+     * Execute a built query
+     * @param query Built query from QueryBuilder
+     * @returns Query result with data and count
      */
-    abstract createSavepoint(connection: IConnection, transaction: ITransaction, savepointName: string): Promise<ISavepoint>;
+    abstract query<T = any>(query: IBuiltQuery): Promise<IQueryResult<T>>;
     /**
-     * Rollback to a savepoint
+     * Execute a raw query/command
+     * @param options Raw query options
+     * @returns Raw query result
      */
-    abstract rollbackToSavepoint(connection: IConnection, transaction: ITransaction, savepoint: ISavepoint): Promise<void>;
+    abstract raw<T = any>(options: IRawQueryOptions): Promise<IRawQueryResult<T>>;
     /**
-     * Release a savepoint
+     * Insert one or more records
+     * @param options Insert options
+     * @returns Insert result with IDs and count
      */
-    abstract releaseSavepoint(connection: IConnection, transaction: ITransaction, savepoint: ISavepoint): Promise<void>;
+    abstract insert<T = any>(options: IInsertOptions): Promise<IInsertResult<T>>;
     /**
-     * Execute a callback within a transaction
-     * Automatically commits on success or rolls back on error
+     * Update records matching conditions
+     * @param options Update options with where clause
+     * @returns Update result with affected count
      */
-    executeTransaction<T>(connection: IConnection, callback: (transaction: ITransaction) => Promise<T>, options?: ITransactionOptions): Promise<T>;
+    abstract update<T = any>(options: IUpdateOptions): Promise<IUpdateResult<T>>;
     /**
-     * Execute a select query
+     * Delete records matching conditions
+     * @param options Delete options with where clause
+     * @returns Delete result with affected count
      */
-    abstract query<T = any>(connection: IConnection, options: IQueryOptions): Promise<IQueryResult<T>>;
+    abstract delete(options: IDeleteOptions): Promise<IDeleteResult>;
     /**
-     * Insert records
+     * Insert or update based on conflict keys
+     * @param options Upsert options
+     * @returns Upsert result with operation type
      */
-    abstract insert<T = any>(connection: IConnection, options: IInsertOptions): Promise<IInsertResult<T>>;
+    abstract upsert<T = any>(options: IUpsertOptions): Promise<IUpsertResult<T>>;
     /**
-     * Update records
+     * Count records matching conditions
+     * @param options Count options
+     * @returns Number of matching records
      */
-    abstract update<T = any>(connection: IConnection, options: IUpdateOptions): Promise<IUpdateResult<T>>;
+    abstract count(options: ICountOptions): Promise<number>;
     /**
-     * Delete records
+     * Sum values of a column
+     * @param options Sum options
+     * @returns Sum of column values
      */
-    abstract delete<T = any>(connection: IConnection, options: IDeleteOptions): Promise<IDeleteResult<T>>;
+    abstract sum(options: ISumOptions): Promise<number>;
     /**
-     * Upsert records (insert or update)
+     * Calculate average of a column
+     * @param options Average options
+     * @returns Average of column values
      */
-    abstract upsert<T = any>(connection: IConnection, options: IUpsertOptions): Promise<IUpsertResult<T>>;
+    abstract avg(options: IAvgOptions): Promise<number>;
     /**
-     * Execute raw SQL/query
+     * Get minimum value of a column
+     * @param options Min options
+     * @returns Minimum value
      */
-    abstract executeRaw<T = any>(connection: IConnection, options: IRawQueryOptions): Promise<IRawQueryResult<T>>;
+    abstract min(options: IMinMaxOptions): Promise<any>;
     /**
-     * Count records
+     * Get maximum value of a column
+     * @param options Max options
+     * @returns Maximum value
      */
-    abstract count(connection: IConnection, options: ICountOptions): Promise<number>;
+    abstract max(options: IMinMaxOptions): Promise<any>;
     /**
-     * Sum column values
+     * Execute multiple aggregations
+     * @param builtAggregation Built aggregation from AggregationBuilder
+     * @returns Aggregation results
      */
-    abstract sum(connection: IConnection, options: ISumOptions): Promise<number>;
+    abstract aggregate(builtAggregation: IBuiltAggregation): Promise<IAggregateResult>;
     /**
-     * Get average of column values
+     * Group records and aggregate
+     * @param builtGroupBy Built group by from AggregationBuilder
+     * @returns Grouped results
      */
-    abstract avg(connection: IConnection, options: IAvgOptions): Promise<number>;
+    abstract groupBy<T = any>(builtGroupBy: IBuiltAggregation): Promise<IGroupByResult<T>[]>;
     /**
-     * Get minimum value
+     * 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 min(connection: IConnection, options: IMinOptions): Promise<number | string>;
+    abstract beginTransaction(isolationLevel?: IsolationLevel, readOnly?: boolean, timeout?: number): Promise<ITransactionContext>;
     /**
-     * Get maximum value
+     * Commit a transaction
+     * @param context Transaction context to commit
      */
-    abstract max(connection: IConnection, options: IMaxOptions): Promise<number | string>;
+    abstract commitTransaction(context: ITransactionContext): Promise<void>;
     /**
-     * Group by and aggregate
+     * Rollback a transaction
+     * @param context Transaction context to rollback
      */
-    abstract groupBy(connection: IConnection, options: IGroupByOptions): Promise<IGroupByResult[]>;
+    abstract rollbackTransaction(context: ITransactionContext): Promise<void>;
     /**
-     * Multiple aggregations in one query
+     * Create a savepoint within a transaction
+     * @param context Transaction context
+     * @param name Savepoint name
+     * @returns Savepoint instance
      */
-    abstract aggregate(connection: IConnection, options: IAggregateOptions): Promise<Record<string, any>>;
+    abstract createSavepoint(context: ITransactionContext, name: string): Promise<ISavepoint>;
     /**
-     * Create a table/collection
+     * Release a savepoint
+     * @param context Transaction context
+     * @param savepoint Savepoint to release
      */
-    abstract createTable(connection: IConnection, schema: ITableSchema, options?: ICreateTableOptions): Promise<ISchemaOperationResult>;
+    abstract releaseSavepoint(context: ITransactionContext, savepoint: ISavepoint): Promise<void>;
     /**
-     * Drop a table/collection
+     * Rollback to a savepoint
+     * @param context Transaction context
+     * @param savepoint Savepoint to rollback to
      */
-    abstract dropTable(connection: IConnection, tableName: string): Promise<ISchemaOperationResult>;
+    abstract rollbackToSavepoint(context: ITransactionContext, savepoint: ISavepoint): Promise<void>;
     /**
-     * Alter table (add/modify/drop columns)
+     * Check if the database supports savepoints
+     * @returns Whether savepoints are supported
      */
-    abstract alterTable(connection: IConnection, tableName: string, alterations: IColumnAlteration[], options?: IAlterTableOptions): Promise<ISchemaOperationResult>;
+    abstract supportsSavepoints(): boolean;
     /**
-     * Get table schema
+     * Create a new table
+     * @param definition Table definition
+     * @param options Create options
      */
-    abstract getTableSchema(connection: IConnection, tableName: string): Promise<ITableSchema>;
+    abstract createTable(definition: ITableDefinition, options?: ICreateTableOptions): Promise<void>;
     /**
-     * List all tables/collections
+     * Alter an existing table
+     * @param tableName Table to alter
+     * @param operations Alterations to perform
      */
-    abstract listTables(connection: IConnection): Promise<string[]>;
+    abstract alterTable(tableName: string, operations: IAlterTableOperation[]): Promise<void>;
     /**
-     * Check if table exists
+     * Drop a table
+     * @param tableName Table to drop
+     * @param ifExists Only drop if exists
+     * @param cascade Cascade to dependent objects
      */
-    abstract tableExists(connection: IConnection, tableName: string): Promise<boolean>;
+    abstract dropTable(tableName: string, ifExists?: boolean, cascade?: boolean): Promise<void>;
     /**
-     * Create an index
+     * List all tables in the database
+     * @returns Array of table names
      */
-    abstract createIndex(connection: IConnection, options: ICreateIndexOptions): Promise<IIndexOperationResult>;
+    abstract listTables(): Promise<string[]>;
     /**
-     * Drop an index
+     * Check if a table exists
+     * @param tableName Table name to check
+     * @returns Whether table exists
      */
-    abstract dropIndex(connection: IConnection, options: IDropIndexOptions): Promise<IIndexOperationResult>;
+    abstract tableExists(tableName: string): Promise<boolean>;
     /**
-     * List indexes for a table
+     * Get schema information for a table
+     * @param tableName Table to inspect
+     * @returns Table schema information
      */
-    abstract listIndexes(connection: IConnection, options: IListIndexesOptions): Promise<IIndexInfo[]>;
+    abstract getTableSchema(tableName: string): Promise<ITableSchema>;
     /**
-     * Get index statistics
+     * Create an index
+     * @param index Index definition
+     * @param ifNotExists Only create if not exists
+     * @param concurrent Create concurrently (PostgreSQL)
      */
-    abstract getIndexStatistics(connection: IConnection, tableName: string, indexName?: string): Promise<IIndexStatistics[]>;
+    abstract createIndex(index: IIndexDefinition, ifNotExists?: boolean, concurrent?: boolean): Promise<void>;
     /**
-     * Run a migration
+     * 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 runMigration(connection: IConnection, migration: IMigrationDefinition, options: IMigrationExecutionOptions): Promise<IMigrationResult>;
+    abstract dropIndex(tableName: string, indexName: string, ifExists?: boolean, concurrent?: boolean, cascade?: boolean): Promise<void>;
     /**
-     * Rollback a migration
+     * List all indexes on a table
+     * @param tableName Table to list indexes for
+     * @param includeSystem Include system indexes
+     * @returns Array of index information
      */
-    abstract rollbackMigration(connection: IConnection, migration: IMigrationDefinition, options: IMigrationExecutionOptions): Promise<IMigrationResult>;
+    abstract listIndexes(tableName: string, includeSystem?: boolean): Promise<IIndexInfo[]>;
     /**
-     * Get migration history
+     * Get statistics for indexes
+     * @param tableName Table name
+     * @param indexName Optional specific index
+     * @returns Array of index statistics
      */
-    abstract getMigrationHistory(connection: IConnection, options: IMigrationExecutionOptions): Promise<IMigrationHistory[]>;
+    abstract getIndexStatistics(tableName: string, indexName?: string): Promise<IIndexStatistics[]>;
     /**
-     * Escape identifier (table/column name)
+     * Escape an identifier (table name, column name) for SQL
+     * @param identifier Identifier to escape
+     * @returns Escaped identifier
      */
     abstract escapeIdentifier(identifier: string): string;
     /**
-     * Escape value
+     * Escape a value for use in SQL
+     * @param value Value to escape
+     * @returns Escaped value
      */
     abstract escapeValue(value: any): string;
     /**
-     * Get database version
+     * 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 getDatabaseVersion(connection: IConnection): Promise<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"
 }