@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,1603 @@
+"use strict";
+/**
+ * PostgreSQL Database Adapter
+ * Implements database operations for PostgreSQL
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgreSQLAdapter = void 0;
+const base_adapter_1 = require("./base.adapter");
+const database_types_1 = require("../types/database.types");
+const uuid_1 = require("uuid");
+const schema_types_1 = require("../types/schema.types");
+const migration_types_1 = require("../types/migration.types");
+/**
+ * PostgreSQL Connection wrapper
+ */
+class PostgreSQLConnection {
+    constructor(id, pool) {
+        this.id = id;
+        this.type = database_types_1.DatabaseType.POSTGRESQL;
+        this.status = database_types_1.ConnectionStatus.CONNECTED;
+        this.pool = pool;
+    }
+    async connect() {
+        this.status = database_types_1.ConnectionStatus.CONNECTED;
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.status = database_types_1.ConnectionStatus.DISCONNECTED;
+        }
+    }
+    isConnected() {
+        return this.status === database_types_1.ConnectionStatus.CONNECTED;
+    }
+    getClient() {
+        return this.pool;
+    }
+}
+/**
+ * PostgreSQL Savepoint implementation
+ */
+class PostgreSQLSavepoint {
+    constructor(name, transaction, client) {
+        this.name = name;
+        this.transaction = transaction;
+        this.createdAt = new Date();
+        this.client = client;
+    }
+    async rollback() {
+        await this.client.query(`ROLLBACK TO SAVEPOINT ${this.name}`);
+    }
+    async release() {
+        await this.client.query(`RELEASE SAVEPOINT ${this.name}`);
+    }
+}
+/**
+ * PostgreSQL Transaction implementation
+ */
+class PostgreSQLTransaction {
+    constructor(connection, client, options) {
+        this.id = (0, uuid_1.v4)();
+        this.connection = connection;
+        this.status = database_types_1.TransactionStatus.ACTIVE;
+        this.isolationLevel = options === null || options === void 0 ? void 0 : options.isolationLevel;
+        this.createdAt = new Date();
+        this.client = client;
+        this.native = client;
+    }
+    async commit() {
+        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot commit transaction: status is ${this.status}`);
+        }
+        await this.client.query('COMMIT');
+        this.status = database_types_1.TransactionStatus.COMMITTED;
+    }
+    async rollback() {
+        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot rollback transaction: status is ${this.status}`);
+        }
+        await this.client.query('ROLLBACK');
+        this.status = database_types_1.TransactionStatus.ROLLED_BACK;
+    }
+    async savepoint(name) {
+        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot create savepoint: transaction status is ${this.status}`);
+        }
+        await this.client.query(`SAVEPOINT ${name}`);
+        return new PostgreSQLSavepoint(name, this, this.client);
+    }
+    isActive() {
+        return this.status === database_types_1.TransactionStatus.ACTIVE;
+    }
+}
+/**
+ * PostgreSQL Adapter
+ */
+class PostgreSQLAdapter extends base_adapter_1.BaseDatabaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.type = database_types_1.DatabaseType.POSTGRESQL;
+        this.connectionPool = new Map();
+    }
+    // ==================== Connection Methods ====================
+    async connect(config) {
+        try {
+            // Import pg library dynamically
+            const { Pool } = await Promise.resolve().then(() => __importStar(require('pg')));
+            // Extract connection options from config
+            const options = config.options || {};
+            // Create connection pool
+            const pool = new Pool({
+                host: options.host,
+                port: options.port || 5432,
+                database: config.database || options.database,
+                user: options.user || options.username,
+                password: options.password,
+                ssl: options.ssl,
+                max: options.poolSize || 10,
+                connectionTimeoutMillis: options.connectionTimeout || 5000,
+                idleTimeoutMillis: options.idleTimeout || 30000,
+            });
+            // Test connection
+            await pool.query('SELECT 1');
+            // Create connection wrapper
+            const connectionId = `postgresql-${config.database}-${Date.now()}`;
+            const connection = new PostgreSQLConnection(connectionId, pool);
+            // Store in pool map
+            this.connectionPool.set(connectionId, connection);
+            return connection;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Failed to connect to PostgreSQL: ${error.message}`, error);
+        }
+    }
+    async disconnect(connection) {
+        await connection.disconnect();
+        this.connectionPool.delete(connection.id);
+    }
+    async testConnection(connection) {
+        var _a;
+        const startTime = Date.now();
+        try {
+            const pool = connection.getClient();
+            const result = await pool.query('SELECT version()');
+            const responseTime = Date.now() - startTime;
+            return {
+                connected: true,
+                message: 'Successfully connected to PostgreSQL',
+                databaseType: 'PostgreSQL',
+                version: (_a = result.rows[0]) === null || _a === void 0 ? void 0 : _a.version,
+                responseTime,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                message: 'Failed to connect to PostgreSQL',
+                databaseType: 'PostgreSQL',
+                responseTime: Date.now() - startTime,
+                error: error.message,
+            };
+        }
+    }
+    // ==================== Transaction Methods ====================
+    async beginTransaction(connection, options) {
+        try {
+            const pool = connection.getClient();
+            const client = await pool.connect();
+            // Set isolation level if specified
+            let beginStatement = 'BEGIN';
+            if (options === null || options === void 0 ? void 0 : options.isolationLevel) {
+                beginStatement += ` ISOLATION LEVEL ${options.isolationLevel.replace('_', ' ')}`;
+            }
+            if (options === null || options === void 0 ? void 0 : options.readOnly) {
+                beginStatement += ' READ ONLY';
+            }
+            if (options === null || options === void 0 ? void 0 : options.deferrable) {
+                beginStatement += ' DEFERRABLE';
+            }
+            await client.query(beginStatement);
+            return new PostgreSQLTransaction(connection, client, options);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Failed to begin transaction: ${error.message}`, error);
+        }
+    }
+    async commitTransaction(connection, transaction) {
+        await transaction.commit();
+    }
+    async rollbackTransaction(connection, transaction) {
+        await transaction.rollback();
+    }
+    async createSavepoint(connection, transaction, savepointName) {
+        return transaction.savepoint(savepointName);
+    }
+    async rollbackToSavepoint(_connection, _transaction, savepoint) {
+        await savepoint.rollback();
+    }
+    async releaseSavepoint(_connection, _transaction, savepoint) {
+        await savepoint.release();
+    }
+    // ==================== Query Methods ====================
+    async query(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildSelectQuery(options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                data: result.rows,
+                count: result.rowCount,
+                executionTime,
+                databaseType: 'PostgreSQL',
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL query failed: ${error.message}`, error);
+        }
+    }
+    async insert(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildInsertQuery(options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                insertedCount: result.rowCount,
+                insertedIds: result.rows.map((row) => row.id || row[Object.keys(row)[0]]),
+                data: options.returning ? result.rows : undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL insert failed: ${error.message}`, error);
+        }
+    }
+    async update(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildUpdateQuery(options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                updatedCount: result.rowCount,
+                matchedCount: result.rowCount,
+                data: options.returning ? result.rows : undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL update failed: ${error.message}`, error);
+        }
+    }
+    async delete(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildDeleteQuery(options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                deletedCount: result.rowCount,
+                data: options.returning ? result.rows : undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL delete failed: ${error.message}`, error);
+        }
+    }
+    async upsert(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildUpsertQuery(options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                insertedCount: 0, // PostgreSQL doesn't distinguish in upsert
+                updatedCount: 0,
+                affectedCount: result.rowCount,
+                data: options.returning ? result.rows : undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL upsert failed: ${error.message}`, error);
+        }
+    }
+    async executeRaw(connection, options) {
+        var _a;
+        const startTime = Date.now();
+        try {
+            const client = connection.getClient();
+            const result = await client.query(options.query, options.params || []);
+            const executionTime = Date.now() - startTime;
+            return {
+                rows: result.rows,
+                rowCount: result.rowCount,
+                fields: (_a = result.fields) === null || _a === void 0 ? void 0 : _a.map((f) => ({
+                    name: f.name,
+                    type: f.dataTypeID,
+                })),
+                executionTime,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL raw query failed: ${error.message}`, error);
+        }
+    }
+    // ==================== Aggregation Methods ====================
+    async count(connection, options) {
+        try {
+            const { query, params } = this.buildCountQuery(options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            return parseInt(result.rows[0].count, 10);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL count failed: ${error.message}`, error);
+        }
+    }
+    async sum(connection, options) {
+        try {
+            const { query, params } = this.buildAggregateQuery('SUM', options.column, options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            return parseFloat(result.rows[0].result) || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL sum failed: ${error.message}`, error);
+        }
+    }
+    async avg(connection, options) {
+        try {
+            const { query, params } = this.buildAggregateQuery('AVG', options.column, options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            return parseFloat(result.rows[0].result) || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL avg failed: ${error.message}`, error);
+        }
+    }
+    async min(connection, options) {
+        try {
+            const { query, params } = this.buildAggregateQuery('MIN', options.column, options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            return result.rows[0].result;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL min failed: ${error.message}`, error);
+        }
+    }
+    async max(connection, options) {
+        try {
+            const { query, params } = this.buildAggregateQuery('MAX', options.column, options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            return result.rows[0].result;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL max failed: ${error.message}`, error);
+        }
+    }
+    async groupBy(connection, options) {
+        try {
+            const { query, params } = this.buildGroupByQuery(options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            return result.rows;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL groupBy failed: ${error.message}`, error);
+        }
+    }
+    async aggregate(connection, options) {
+        try {
+            const { query, params } = this.buildMultiAggregateQuery(options);
+            const client = connection.getClient();
+            const result = await client.query(query, params);
+            return result.rows[0] || {};
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL aggregate failed: ${error.message}`, error);
+        }
+    }
+    // ==================== Schema Methods ====================
+    async createTable(connection, schema, options) {
+        const startTime = Date.now();
+        try {
+            const query = this.buildCreateTableQuery(schema, options);
+            const client = connection.getClient();
+            await client.query(query);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                operation: 'create',
+                table: schema.name,
+                executionTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                table: schema.name,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async dropTable(connection, tableName) {
+        const startTime = Date.now();
+        try {
+            const client = connection.getClient();
+            await client.query(`DROP TABLE IF EXISTS "${tableName}"`);
+            return {
+                success: true,
+                operation: 'drop',
+                table: tableName,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'drop',
+                table: tableName,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async alterTable(connection, tableName, alterations, options) {
+        const startTime = Date.now();
+        try {
+            const queries = this.buildAlterTableQueries(tableName, alterations);
+            const client = connection.getClient();
+            for (const query of queries) {
+                await client.query(query);
+            }
+            return {
+                success: true,
+                operation: 'alter',
+                table: tableName,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'alter',
+                table: tableName,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async getTableSchema(connection, tableName) {
+        try {
+            const client = connection.getClient();
+            const query = `
+        SELECT
+          column_name,
+          data_type,
+          is_nullable,
+          column_default,
+          character_maximum_length,
+          numeric_precision,
+          numeric_scale
+        FROM information_schema.columns
+        WHERE table_name = $1
+        ORDER BY ordinal_position
+      `;
+            const result = await client.query(query, [tableName]);
+            const columns = result.rows.map((row) => ({
+                name: row.column_name,
+                type: this.mapPostgreSQLTypeToColumnType(row.data_type),
+                nullable: row.is_nullable === 'YES',
+                defaultValue: row.column_default,
+                length: row.character_maximum_length,
+                precision: row.numeric_precision,
+                scale: row.numeric_scale,
+            }));
+            return {
+                name: tableName,
+                columns,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to get PostgreSQL table schema: ${error.message}`, error);
+        }
+    }
+    async listTables(connection) {
+        try {
+            const client = connection.getClient();
+            const query = `
+        SELECT tablename
+        FROM pg_tables
+        WHERE schemaname = 'public'
+        ORDER BY tablename
+      `;
+            const result = await client.query(query);
+            return result.rows.map((row) => row.tablename);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `Failed to list PostgreSQL tables: ${error.message}`, error);
+        }
+    }
+    async tableExists(connection, tableName) {
+        try {
+            const client = connection.getClient();
+            const query = `
+        SELECT EXISTS (
+          SELECT FROM information_schema.tables
+          WHERE table_schema = 'public'
+          AND table_name = $1
+        )
+      `;
+            const result = await client.query(query, [tableName]);
+            return result.rows[0].exists;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    // ==================== Index Methods ====================
+    async createIndex(connection, options) {
+        const startTime = Date.now();
+        try {
+            const query = this.buildCreateIndexQuery(options);
+            const client = connection.getClient();
+            await client.query(query);
+            return {
+                success: true,
+                operation: 'create',
+                indexName: options.index.name,
+                table: options.table,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                indexName: options.index.name,
+                table: options.table,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async dropIndex(connection, options) {
+        const startTime = Date.now();
+        try {
+            const client = connection.getClient();
+            await client.query(`DROP INDEX IF EXISTS "${options.indexName}"`);
+            return {
+                success: true,
+                operation: 'drop',
+                indexName: options.indexName,
+                table: options.table,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'drop',
+                indexName: options.indexName,
+                table: options.table,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async listIndexes(connection, options) {
+        try {
+            const client = connection.getClient();
+            const query = `
+        SELECT
+          i.relname as index_name,
+          a.attname as column_name,
+          ix.indisunique as is_unique,
+          am.amname as index_type
+        FROM
+          pg_class t,
+          pg_class i,
+          pg_index ix,
+          pg_attribute a,
+          pg_am am
+        WHERE
+          t.oid = ix.indrelid
+          AND i.oid = ix.indexrelid
+          AND a.attrelid = t.oid
+          AND a.attnum = ANY(ix.indkey)
+          AND t.relkind = 'r'
+          AND t.relname = $1
+          AND i.relam = am.oid
+        ORDER BY
+          i.relname,
+          a.attnum
+      `;
+            const result = await client.query(query, [options.table]);
+            // Group by index name
+            const indexMap = new Map();
+            result.rows.forEach((row) => {
+                if (!indexMap.has(row.index_name)) {
+                    indexMap.set(row.index_name, {
+                        name: row.index_name,
+                        table: options.table,
+                        columns: [],
+                        columnDetails: [],
+                        unique: row.is_unique,
+                        primaryKey: false,
+                        type: row.index_type,
+                    });
+                }
+                const indexInfo = indexMap.get(row.index_name);
+                indexInfo.columns.push(row.column_name);
+                indexInfo.columnDetails.push({
+                    name: row.column_name,
+                    order: 'ASC',
+                });
+            });
+            return Array.from(indexMap.values());
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to list PostgreSQL indexes: ${error.message}`, error);
+        }
+    }
+    async getIndexStatistics(connection, tableName, indexName) {
+        try {
+            const client = connection.getClient();
+            let query = `
+        SELECT
+          schemaname,
+          tablename,
+          indexname,
+          idx_scan as scans,
+          idx_tup_read as tuples_read,
+          idx_tup_fetch as tuples_fetched
+        FROM
+          pg_stat_user_indexes
+        WHERE
+          tablename = $1
+      `;
+            const params = [tableName];
+            if (indexName) {
+                query += ` AND indexname = $2`;
+                params.push(indexName);
+            }
+            const result = await client.query(query, params);
+            return result.rows.map((row) => ({
+                indexName: row.indexname,
+                tableName: row.tablename,
+                scans: row.scans,
+                tuplesRead: row.tuples_read,
+                tuplesFetched: row.tuples_fetched,
+            }));
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to get PostgreSQL index statistics: ${error.message}`, error);
+        }
+    }
+    // ==================== Migration Methods ====================
+    /**
+     * Build SQL for a migration operation
+     */
+    async buildMigrationOperationSQL(operation) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        switch (operation.type) {
+            case migration_types_1.MigrationOperationType.RAW_SQL:
+                return operation.sql || null;
+            case migration_types_1.MigrationOperationType.CREATE_TABLE:
+                if ((_a = operation.params) === null || _a === void 0 ? void 0 : _a.schema) {
+                    const schema = operation.params.schema;
+                    const columns = schema.columns
+                        .map((col) => {
+                        let def = `"${col.name}" ${this.mapColumnTypeToPostgreSQL(col.type)}`;
+                        if (col.primaryKey)
+                            def += ' PRIMARY KEY';
+                        if (!col.nullable)
+                            def += ' NOT NULL';
+                        if (col.unique)
+                            def += ' UNIQUE';
+                        if (col.defaultValue !== undefined) {
+                            def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
+                        }
+                        return def;
+                    })
+                        .join(', ');
+                    return `CREATE TABLE "${schema.name}" (${columns})`;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.DROP_TABLE:
+                return operation.table ? `DROP TABLE IF EXISTS "${operation.table}"` : null;
+            case migration_types_1.MigrationOperationType.ADD_COLUMN:
+                if (operation.table && ((_b = operation.params) === null || _b === void 0 ? void 0 : _b.column)) {
+                    const col = operation.params.column;
+                    let def = `ALTER TABLE "${operation.table}" ADD COLUMN "${col.name}" ${this.mapColumnTypeToPostgreSQL(col.type)}`;
+                    if (!col.nullable)
+                        def += ' NOT NULL';
+                    if (col.defaultValue !== undefined) {
+                        def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
+                    }
+                    return def;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.DROP_COLUMN:
+                return operation.table && ((_c = operation.params) === null || _c === void 0 ? void 0 : _c.columnName)
+                    ? `ALTER TABLE "${operation.table}" DROP COLUMN "${operation.params.columnName}"`
+                    : null;
+            case migration_types_1.MigrationOperationType.MODIFY_COLUMN:
+                if (operation.table && ((_d = operation.params) === null || _d === void 0 ? void 0 : _d.column)) {
+                    const col = operation.params.column;
+                    return `ALTER TABLE "${operation.table}" ALTER COLUMN "${col.name}" TYPE ${this.mapColumnTypeToPostgreSQL(col.type)}`;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.RENAME_COLUMN:
+                return operation.table && ((_e = operation.params) === null || _e === void 0 ? void 0 : _e.oldName) && ((_f = operation.params) === null || _f === void 0 ? void 0 : _f.newName)
+                    ? `ALTER TABLE "${operation.table}" RENAME COLUMN "${operation.params.oldName}" TO "${operation.params.newName}"`
+                    : null;
+            case migration_types_1.MigrationOperationType.ADD_INDEX:
+                if (operation.table && ((_g = operation.params) === null || _g === void 0 ? void 0 : _g.indexName) && ((_h = operation.params) === null || _h === void 0 ? void 0 : _h.columns)) {
+                    const unique = operation.params.unique ? 'UNIQUE ' : '';
+                    const columns = operation.params.columns.map((col) => `"${col}"`).join(', ');
+                    return `CREATE ${unique}INDEX "${operation.params.indexName}" ON "${operation.table}" (${columns})`;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.DROP_INDEX:
+                return ((_j = operation.params) === null || _j === void 0 ? void 0 : _j.indexName)
+                    ? `DROP INDEX IF EXISTS "${operation.params.indexName}"`
+                    : null;
+            case migration_types_1.MigrationOperationType.ADD_CONSTRAINT:
+                if (operation.table && ((_k = operation.params) === null || _k === void 0 ? void 0 : _k.constraintName) && ((_l = operation.params) === null || _l === void 0 ? void 0 : _l.definition)) {
+                    return `ALTER TABLE "${operation.table}" ADD CONSTRAINT "${operation.params.constraintName}" ${operation.params.definition}`;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.DROP_CONSTRAINT:
+                return operation.table && ((_m = operation.params) === null || _m === void 0 ? void 0 : _m.constraintName)
+                    ? `ALTER TABLE "${operation.table}" DROP CONSTRAINT IF EXISTS "${operation.params.constraintName}"`
+                    : null;
+            default:
+                return null;
+        }
+    }
+    async runMigration(connection, migration, options) {
+        const startTime = Date.now();
+        const statements = [];
+        try {
+            const client = connection.getClient();
+            await client.query('BEGIN');
+            try {
+                // Execute migration operations
+                for (const operation of migration.up) {
+                    const sql = await this.buildMigrationOperationSQL(operation);
+                    if (sql) {
+                        statements.push(sql);
+                        await client.query(sql);
+                    }
+                }
+                // Record migration in history table
+                await this.recordMigration(client, migration, migration_types_1.MigrationDirection.UP);
+                await client.query('COMMIT');
+                return {
+                    tag: migration.tag,
+                    status: migration_types_1.MigrationStatus.COMPLETED,
+                    direction: migration_types_1.MigrationDirection.UP,
+                    executedAt: new Date(),
+                    duration: Date.now() - startTime,
+                    statements,
+                };
+            }
+            catch (error) {
+                await client.query('ROLLBACK');
+                throw error;
+            }
+        }
+        catch (error) {
+            return {
+                tag: migration.tag,
+                status: migration_types_1.MigrationStatus.FAILED,
+                direction: migration_types_1.MigrationDirection.UP,
+                executedAt: new Date(),
+                duration: Date.now() - startTime,
+                error: error.message,
+                statements,
+            };
+        }
+    }
+    async rollbackMigration(connection, migration, options) {
+        const startTime = Date.now();
+        const statements = [];
+        try {
+            const client = connection.getClient();
+            await client.query('BEGIN');
+            try {
+                // Execute rollback operations
+                for (const operation of migration.down) {
+                    const sql = await this.buildMigrationOperationSQL(operation);
+                    if (sql) {
+                        statements.push(sql);
+                        await client.query(sql);
+                    }
+                }
+                // Remove migration from history table
+                await this.removeMigration(client, migration.tag);
+                await client.query('COMMIT');
+                return {
+                    tag: migration.tag,
+                    status: migration_types_1.MigrationStatus.ROLLED_BACK,
+                    direction: migration_types_1.MigrationDirection.DOWN,
+                    executedAt: new Date(),
+                    duration: Date.now() - startTime,
+                    statements,
+                };
+            }
+            catch (error) {
+                await client.query('ROLLBACK');
+                throw error;
+            }
+        }
+        catch (error) {
+            return {
+                tag: migration.tag,
+                status: migration_types_1.MigrationStatus.FAILED,
+                direction: migration_types_1.MigrationDirection.DOWN,
+                executedAt: new Date(),
+                duration: Date.now() - startTime,
+                error: error.message,
+                statements,
+            };
+        }
+    }
+    async getMigrationHistory(connection, options) {
+        try {
+            const client = connection.getClient();
+            // Ensure migration table exists
+            await this.ensureMigrationTable(client);
+            const query = `
+        SELECT tag, name, executed_at
+        FROM _ductape_migrations
+        ORDER BY executed_at DESC
+      `;
+            const result = await client.query(query);
+            return result.rows.map((row) => ({
+                tag: row.tag,
+                name: row.name,
+                executedAt: row.executed_at,
+            }));
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to get migration history: ${error.message}`, error);
+        }
+    }
+    // ==================== Helper Methods ====================
+    /**
+     * Build SELECT query from options
+     */
+    buildSelectQuery(options) {
+        const params = [];
+        let paramIndex = 1;
+        // Handle includes
+        const hasIncludes = options.include && (Array.isArray(options.include) ? options.include.length > 0 : true);
+        // SELECT clause
+        let selectColumns;
+        if (options.select && options.select.length > 0) {
+            // Prefix main table columns with table name
+            selectColumns = options.select.map((col) => `"${options.table}"."${col}"`).join(', ');
+        }
+        else {
+            // Select all from main table
+            selectColumns = hasIncludes ? `"${options.table}".*` : '*';
+        }
+        // Add included relation columns
+        if (hasIncludes) {
+            const includes = Array.isArray(options.include) ? options.include : [options.include];
+            includes.forEach((include) => {
+                const relationAlias = include.relation;
+                if (include.select && include.select.length > 0) {
+                    const relationCols = include.select.map((col) => `"${relationAlias}"."${col}" as "${relationAlias}_${col}"`).join(', ');
+                    selectColumns += `, ${relationCols}`;
+                }
+                else {
+                    // Use JSON aggregation for one-to-many
+                    if (include.type === 'one-to-many') {
+                        selectColumns += `, json_agg("${relationAlias}".*) as "${relationAlias}"`;
+                    }
+                    else {
+                        selectColumns += `, row_to_json("${relationAlias}".*) as "${relationAlias}"`;
+                    }
+                }
+            });
+        }
+        let query = `SELECT ${options.distinct ? 'DISTINCT ' : ''}${selectColumns} FROM "${options.table}"`;
+        // JOIN clauses for includes
+        if (hasIncludes) {
+            const includes = Array.isArray(options.include) ? options.include : [options.include];
+            includes.forEach((include) => {
+                const { joinClause } = this.buildIncludeJoin(options.table, include);
+                query += ` ${joinClause}`;
+            });
+        }
+        // WHERE clause
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+            paramIndex += values.length;
+        }
+        // GROUP BY clause
+        if (options.groupBy && options.groupBy.length > 0) {
+            query += ` GROUP BY ${options.groupBy.map((col) => `"${col}"`).join(', ')}`;
+        }
+        else if (hasIncludes) {
+            // Auto group by main table primary key for one-to-many relations
+            const includes = Array.isArray(options.include) ? options.include : [options.include];
+            const hasOneToMany = includes.some(inc => inc.type === 'one-to-many');
+            if (hasOneToMany) {
+                query += ` GROUP BY "${options.table}"."id"`;
+            }
+        }
+        // HAVING clause
+        if (options.having) {
+            const { clause, values } = this.buildWhereClause(options.having, paramIndex);
+            query += ` HAVING ${clause}`;
+            params.push(...values);
+            paramIndex += values.length;
+        }
+        // ORDER BY clause
+        if (options.orderBy) {
+            const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+            const orderClauses = orderByArray.map((order) => `"${options.table}"."${order.column}" ${order.order || 'ASC'}`);
+            query += ` ORDER BY ${orderClauses.join(', ')}`;
+        }
+        // LIMIT clause
+        if (options.limit) {
+            query += ` LIMIT $${paramIndex++}`;
+            params.push(options.limit);
+        }
+        // OFFSET clause
+        if (options.offset) {
+            query += ` OFFSET $${paramIndex++}`;
+            params.push(options.offset);
+        }
+        return { query, params };
+    }
+    /**
+     * Build JOIN clause for include relationships
+     */
+    buildIncludeJoin(mainTable, include) {
+        const relationTable = include.relation;
+        const foreignKey = include.foreignKey || `${relationTable}_id`;
+        const primaryKey = include.primaryKey || 'id';
+        const joinType = include.type === 'one-to-many' || include.type === 'one-to-one' ? 'LEFT' : 'INNER';
+        let joinClause;
+        if (include.type === 'many-to-many' && include.through) {
+            // Many-to-many with junction table
+            const throughTable = include.through;
+            const throughForeignKey = include.throughForeignKey || `${mainTable}_id`;
+            const throughRelatedKey = include.throughRelatedKey || `${relationTable}_id`;
+            joinClause = `${joinType} JOIN "${throughTable}" ON "${mainTable}"."${primaryKey}" = "${throughTable}"."${throughForeignKey}" `;
+            joinClause += `${joinType} JOIN "${relationTable}" ON "${throughTable}"."${throughRelatedKey}" = "${relationTable}"."${primaryKey}"`;
+        }
+        else if (include.type === 'one-to-many') {
+            // One-to-many: foreign key is in the related table
+            joinClause = `${joinType} JOIN "${relationTable}" ON "${mainTable}"."${primaryKey}" = "${relationTable}"."${foreignKey}"`;
+        }
+        else {
+            // Many-to-one or one-to-one: foreign key is in the main table
+            joinClause = `${joinType} JOIN "${relationTable}" ON "${mainTable}"."${foreignKey}" = "${relationTable}"."${primaryKey}"`;
+        }
+        // Add where clause for the relation if specified
+        if (include.where) {
+            const { clause } = this.buildWhereClause(include.where, 1);
+            joinClause += ` AND ${clause}`;
+        }
+        return { joinClause };
+    }
+    /**
+     * Build INSERT query from options
+     */
+    buildInsertQuery(options) {
+        const dataArray = Array.isArray(options.data) ? options.data : [options.data];
+        const columns = Object.keys(dataArray[0]);
+        const params = [];
+        let paramIndex = 1;
+        let query = `INSERT INTO "${options.table}" (${columns.map((col) => `"${col}"`).join(', ')}) VALUES `;
+        const valuesClauses = [];
+        dataArray.forEach((data) => {
+            const valuePlaceholders = columns.map(() => `$${paramIndex++}`);
+            valuesClauses.push(`(${valuePlaceholders.join(', ')})`);
+            params.push(...columns.map((col) => data[col]));
+        });
+        query += valuesClauses.join(', ');
+        if (options.returning) {
+            const returningColumns = Array.isArray(options.returning)
+                ? options.returning.map((col) => `"${col}"`).join(', ')
+                : '*';
+            query += ` RETURNING ${returningColumns}`;
+        }
+        return { query, params };
+    }
+    /**
+     * Build UPDATE query from options
+     */
+    buildUpdateQuery(options) {
+        const params = [];
+        let paramIndex = 1;
+        const setClauses = Object.keys(options.data).map((key) => {
+            params.push(options.data[key]);
+            return `"${key}" = $${paramIndex++}`;
+        });
+        let query = `UPDATE "${options.table}" SET ${setClauses.join(', ')}`;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        if (options.returning) {
+            const returningColumns = Array.isArray(options.returning)
+                ? options.returning.map((col) => `"${col}"`).join(', ')
+                : '*';
+            query += ` RETURNING ${returningColumns}`;
+        }
+        return { query, params };
+    }
+    /**
+     * Build DELETE query from options
+     */
+    buildDeleteQuery(options) {
+        const params = [];
+        let paramIndex = 1;
+        let query = `DELETE FROM "${options.table}"`;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        if (options.returning) {
+            const returningColumns = Array.isArray(options.returning)
+                ? options.returning.map((col) => `"${col}"`).join(', ')
+                : '*';
+            query += ` RETURNING ${returningColumns}`;
+        }
+        return { query, params };
+    }
+    /**
+     * Build UPSERT (INSERT ... ON CONFLICT) query from options
+     */
+    buildUpsertQuery(options) {
+        // Upsert only works with single records
+        const data = Array.isArray(options.data) ? options.data[0] : options.data;
+        const columns = Object.keys(data);
+        const params = [];
+        let paramIndex = 1;
+        let query = `INSERT INTO "${options.table}" (${columns.map((col) => `"${col}"`).join(', ')}) VALUES (`;
+        query += columns.map(() => `$${paramIndex++}`).join(', ');
+        params.push(...columns.map((col) => data[col]));
+        query += `) ON CONFLICT (${options.uniqueColumns.map((col) => `"${col}"`).join(', ')}) DO UPDATE SET `;
+        const updateClauses = columns
+            .filter((col) => !options.uniqueColumns.includes(col))
+            .map((col) => `"${col}" = EXCLUDED."${col}"`);
+        query += updateClauses.join(', ');
+        if (options.returning) {
+            const returningColumns = Array.isArray(options.returning)
+                ? options.returning.map((col) => `"${col}"`).join(', ')
+                : '*';
+            query += ` RETURNING ${returningColumns}`;
+        }
+        return { query, params };
+    }
+    /**
+     * Build COUNT query from options
+     */
+    buildCountQuery(options) {
+        const params = [];
+        let paramIndex = 1;
+        const column = options.column || '*';
+        let query = `SELECT COUNT(${column === '*' ? '*' : `"${column}"`}) as count FROM "${options.table}"`;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build aggregate query (SUM, AVG, MIN, MAX)
+     */
+    buildAggregateQuery(func, column, options) {
+        const params = [];
+        let paramIndex = 1;
+        let query = `SELECT ${func}("${column}") as result FROM "${options.table}"`;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build GROUP BY query
+     */
+    buildGroupByQuery(options) {
+        const params = [];
+        let paramIndex = 1;
+        const groupColumns = options.groupBy.map((col) => `"${col}"`);
+        const selectColumns = [...groupColumns];
+        // Build aggregations
+        if (options.aggregate) {
+            Object.entries(options.aggregate).forEach(([alias, agg]) => {
+                const aggObj = agg;
+                if (aggObj.$COUNT !== undefined) {
+                    const column = aggObj.$COUNT === '*' ? '*' : `"${aggObj.$COUNT}"`;
+                    selectColumns.push(`COUNT(${column}) AS "${alias}"`);
+                }
+                else if (aggObj.$SUM !== undefined) {
+                    selectColumns.push(`SUM("${aggObj.$SUM}") AS "${alias}"`);
+                }
+                else if (aggObj.$AVG !== undefined) {
+                    selectColumns.push(`AVG("${aggObj.$AVG}") AS "${alias}"`);
+                }
+                else if (aggObj.$MIN !== undefined) {
+                    selectColumns.push(`MIN("${aggObj.$MIN}") AS "${alias}"`);
+                }
+                else if (aggObj.$MAX !== undefined) {
+                    selectColumns.push(`MAX("${aggObj.$MAX}") AS "${alias}"`);
+                }
+                else if (aggObj.$STRING_AGG !== undefined) {
+                    selectColumns.push(`STRING_AGG("${aggObj.$STRING_AGG}", ', ') AS "${alias}"`);
+                }
+                else if (aggObj.$ARRAY_AGG !== undefined) {
+                    selectColumns.push(`ARRAY_AGG("${aggObj.$ARRAY_AGG}") AS "${alias}"`);
+                }
+            });
+        }
+        let query = `SELECT ${selectColumns.join(', ')} FROM "${options.table}"`;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+            paramIndex += values.length;
+        }
+        query += ` GROUP BY ${groupColumns.join(', ')}`;
+        if (options.having) {
+            const { clause, values } = this.buildWhereClause(options.having, paramIndex);
+            query += ` HAVING ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build multi-aggregate query
+     */
+    buildMultiAggregateQuery(options) {
+        const params = [];
+        let paramIndex = 1;
+        const aggregations = Object.entries(options.operations).map(([alias, agg]) => {
+            const aggObj = agg;
+            if (aggObj.$COUNT !== undefined) {
+                const column = aggObj.$COUNT === '*' ? '*' : `"${aggObj.$COUNT}"`;
+                return `COUNT(${column}) AS "${alias}"`;
+            }
+            if (aggObj.$SUM !== undefined) {
+                return `SUM("${aggObj.$SUM}") AS "${alias}"`;
+            }
+            if (aggObj.$AVG !== undefined) {
+                return `AVG("${aggObj.$AVG}") AS "${alias}"`;
+            }
+            if (aggObj.$MIN !== undefined) {
+                return `MIN("${aggObj.$MIN}") AS "${alias}"`;
+            }
+            if (aggObj.$MAX !== undefined) {
+                return `MAX("${aggObj.$MAX}") AS "${alias}"`;
+            }
+            if (aggObj.$STRING_AGG !== undefined) {
+                return `STRING_AGG("${aggObj.$STRING_AGG}", ', ') AS "${alias}"`;
+            }
+            if (aggObj.$ARRAY_AGG !== undefined) {
+                return `ARRAY_AGG("${aggObj.$ARRAY_AGG}") AS "${alias}"`;
+            }
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.VALIDATION_ERROR, `Invalid aggregation operation for alias "${alias}". Use format: { $COUNT: '*' }, { $SUM: 'column' }, etc.`);
+        });
+        let query = `SELECT ${aggregations.join(', ')} FROM "${options.table}"`;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+            paramIndex += values.length;
+        }
+        if (options.groupBy && options.groupBy.length > 0) {
+            const groupCols = options.groupBy.map(col => `"${col}"`).join(', ');
+            query += ` GROUP BY ${groupCols}`;
+        }
+        if (options.having) {
+            const { clause, values } = this.buildWhereClause(options.having, paramIndex);
+            query += ` HAVING ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build WHERE clause from WhereClause object
+     * Supports both simplified syntax (GT, LT, AND, OR) and legacy syntax ($gt, $lt, $and, $or)
+     */
+    buildWhereClause(where, startIndex = 1) {
+        const values = [];
+        let paramIndex = startIndex;
+        const buildCondition = (condition) => {
+            if (typeof condition !== 'object' || condition === null) {
+                values.push(condition);
+                return `$${paramIndex++}`;
+            }
+            // Handle logical operators (supports $AND, AND, and legacy $and)
+            if (condition.$AND || condition.AND || condition.$and) {
+                const andConditions = condition.$AND || condition.AND || condition.$and;
+                if (typeof andConditions === 'object' && !Array.isArray(andConditions)) {
+                    // New syntax: { $AND: { col1: val1, col2: val2 } }
+                    return buildCondition(andConditions);
+                }
+                else {
+                    // Legacy syntax: { $and: [cond1, cond2] }
+                    const subConditions = andConditions.map(buildCondition);
+                    return `(${subConditions.join(' AND ')})`;
+                }
+            }
+            if (condition.$OR || condition.OR || condition.$or) {
+                const orConditions = condition.$OR || condition.OR || condition.$or;
+                if (typeof orConditions === 'object' && !Array.isArray(orConditions)) {
+                    // New syntax: { $OR: { col1: val1, col2: val2 } }
+                    const subClauses = [];
+                    for (const [key, value] of Object.entries(orConditions)) {
+                        if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
+                            subClauses.push(buildCondition({ [key]: value }));
+                        }
+                        else {
+                            subClauses.push(buildCondition({ [key]: value }));
+                        }
+                    }
+                    return `(${subClauses.join(' OR ')})`;
+                }
+                else {
+                    // Legacy syntax: { $or: [cond1, cond2] }
+                    const subConditions = orConditions.map(buildCondition);
+                    return `(${subConditions.join(' OR ')})`;
+                }
+            }
+            // Handle column conditions
+            const conditions = [];
+            for (const [key, value] of Object.entries(condition)) {
+                // Skip logical operators
+                if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
+                    continue;
+                }
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    // Handle comparison operators
+                    for (const [op, opValue] of Object.entries(value)) {
+                        switch (op) {
+                            // Preferred $-prefixed syntax
+                            case '$GT':
+                            case 'GT':
+                            case '$gt':
+                                values.push(opValue);
+                                conditions.push(`"${key}" > $${paramIndex++}`);
+                                break;
+                            case '$GTE':
+                            case 'GTE':
+                            case '$gte':
+                                values.push(opValue);
+                                conditions.push(`"${key}" >= $${paramIndex++}`);
+                                break;
+                            case '$LT':
+                            case 'LT':
+                            case '$lt':
+                                values.push(opValue);
+                                conditions.push(`"${key}" < $${paramIndex++}`);
+                                break;
+                            case '$LTE':
+                            case 'LTE':
+                            case '$lte':
+                                values.push(opValue);
+                                conditions.push(`"${key}" <= $${paramIndex++}`);
+                                break;
+                            case '$NE':
+                            case '$NOT':
+                            case 'NE':
+                            case 'NOT':
+                            case '$ne':
+                                values.push(opValue);
+                                conditions.push(`"${key}" != $${paramIndex++}`);
+                                break;
+                            case '$IN':
+                            case 'IN':
+                            case '$in':
+                                values.push(opValue);
+                                conditions.push(`"${key}" = ANY($${paramIndex++})`);
+                                break;
+                            case '$NOT_IN':
+                            case 'NOT_IN':
+                            case '$nin':
+                                values.push(opValue);
+                                conditions.push(`"${key}" != ANY($${paramIndex++})`);
+                                break;
+                            case '$LIKE':
+                            case 'LIKE':
+                            case '$like':
+                                values.push(opValue);
+                                conditions.push(`"${key}" LIKE $${paramIndex++}`);
+                                break;
+                            case '$ILIKE':
+                            case 'ILIKE':
+                            case '$ilike':
+                                values.push(opValue);
+                                conditions.push(`"${key}" ILIKE $${paramIndex++}`);
+                                break;
+                            case '$IS_NULL':
+                            case 'IS_NULL':
+                            case '$null':
+                                conditions.push(`"${key}" IS NULL`);
+                                break;
+                            case '$IS_NOT_NULL':
+                            case 'IS_NOT_NULL':
+                            case '$notNull':
+                                conditions.push(`"${key}" IS NOT NULL`);
+                                break;
+                            case '$BETWEEN':
+                            case 'BETWEEN':
+                            case '$between':
+                                if (Array.isArray(opValue) && opValue.length === 2) {
+                                    values.push(opValue[0], opValue[1]);
+                                    conditions.push(`"${key}" BETWEEN $${paramIndex++} AND $${paramIndex++}`);
+                                }
+                                break;
+                        }
+                    }
+                }
+                else {
+                    // Simple equality
+                    values.push(value);
+                    conditions.push(`"${key}" = $${paramIndex++}`);
+                }
+            }
+            return conditions.join(' AND ');
+        };
+        const clause = buildCondition(where);
+        return { clause, values };
+    }
+    /**
+     * Build CREATE TABLE query
+     */
+    buildCreateTableQuery(schema, options) {
+        const columnDefs = schema.columns.map((col) => {
+            let def = `"${col.name}" ${this.mapColumnTypeToPostgreSQL(col.type)}`;
+            if (col.length) {
+                def += `(${col.length})`;
+            }
+            else if (col.precision && col.scale) {
+                def += `(${col.precision}, ${col.scale})`;
+            }
+            else if (col.precision) {
+                def += `(${col.precision})`;
+            }
+            if (col.primaryKey) {
+                def += ' PRIMARY KEY';
+            }
+            if (col.unique) {
+                def += ' UNIQUE';
+            }
+            if (!col.nullable && !col.primaryKey) {
+                def += ' NOT NULL';
+            }
+            if (col.defaultValue !== undefined) {
+                def += ` DEFAULT ${col.defaultValue}`;
+            }
+            if (col.autoIncrement) {
+                def = `"${col.name}" SERIAL PRIMARY KEY`;
+            }
+            return def;
+        });
+        let query = `CREATE TABLE ${(options === null || options === void 0 ? void 0 : options.ifNotExists) ? 'IF NOT EXISTS ' : ''}"${schema.name}" (${columnDefs.join(', ')})`;
+        return query;
+    }
+    /**
+     * Build ALTER TABLE queries
+     */
+    buildAlterTableQueries(tableName, alterations) {
+        return alterations.map((alt) => {
+            let query = `ALTER TABLE "${tableName}" `;
+            switch (alt.type) {
+                case schema_types_1.ColumnAlterationType.ADD:
+                    query += `ADD COLUMN "${alt.column.name}" ${this.mapColumnTypeToPostgreSQL(alt.column.type)}`;
+                    if (!alt.column.nullable) {
+                        query += ' NOT NULL';
+                    }
+                    break;
+                case schema_types_1.ColumnAlterationType.DROP:
+                    query += `DROP COLUMN "${alt.oldName}"`;
+                    break;
+                case schema_types_1.ColumnAlterationType.MODIFY:
+                    query += `ALTER COLUMN "${alt.column.name}" TYPE ${this.mapColumnTypeToPostgreSQL(alt.column.type)}`;
+                    break;
+                case schema_types_1.ColumnAlterationType.RENAME:
+                    query += `RENAME COLUMN "${alt.oldName}" TO "${alt.newName}"`;
+                    break;
+            }
+            return query;
+        });
+    }
+    /**
+     * Build CREATE INDEX query
+     */
+    buildCreateIndexQuery(options) {
+        const unique = options.index.unique ? 'UNIQUE ' : '';
+        const columns = options.index.columns.map((col) => `"${col.name}"`).join(', ');
+        return `CREATE ${unique}INDEX ${options.ifNotExists ? 'IF NOT EXISTS ' : ''}"${options.index.name}" ON "${options.table}" (${columns})`;
+    }
+    /**
+     * Map ColumnType to PostgreSQL type
+     */
+    mapColumnTypeToPostgreSQL(type) {
+        const typeMap = {
+            [schema_types_1.ColumnType.STRING]: 'VARCHAR',
+            [schema_types_1.ColumnType.TEXT]: 'TEXT',
+            [schema_types_1.ColumnType.VARCHAR]: 'VARCHAR',
+            [schema_types_1.ColumnType.CHAR]: 'CHAR',
+            [schema_types_1.ColumnType.INTEGER]: 'INTEGER',
+            [schema_types_1.ColumnType.BIGINT]: 'BIGINT',
+            [schema_types_1.ColumnType.SMALLINT]: 'SMALLINT',
+            [schema_types_1.ColumnType.DECIMAL]: 'DECIMAL',
+            [schema_types_1.ColumnType.NUMERIC]: 'NUMERIC',
+            [schema_types_1.ColumnType.FLOAT]: 'REAL',
+            [schema_types_1.ColumnType.DOUBLE]: 'DOUBLE PRECISION',
+            [schema_types_1.ColumnType.REAL]: 'REAL',
+            [schema_types_1.ColumnType.BOOLEAN]: 'BOOLEAN',
+            [schema_types_1.ColumnType.DATE]: 'DATE',
+            [schema_types_1.ColumnType.TIME]: 'TIME',
+            [schema_types_1.ColumnType.DATETIME]: 'TIMESTAMP',
+            [schema_types_1.ColumnType.TIMESTAMP]: 'TIMESTAMP',
+            [schema_types_1.ColumnType.JSON]: 'JSONB',
+            [schema_types_1.ColumnType.JSONB]: 'JSONB',
+            [schema_types_1.ColumnType.UUID]: 'UUID',
+            [schema_types_1.ColumnType.BLOB]: 'BYTEA',
+            [schema_types_1.ColumnType.BINARY]: 'BYTEA',
+            [schema_types_1.ColumnType.ARRAY]: 'ARRAY',
+            [schema_types_1.ColumnType.OBJECT]: 'JSONB',
+            [schema_types_1.ColumnType.ENUM]: 'VARCHAR',
+        };
+        return typeMap[type] || 'TEXT';
+    }
+    /**
+     * Map PostgreSQL type to ColumnType
+     */
+    mapPostgreSQLTypeToColumnType(pgType) {
+        const typeMap = {
+            'character varying': schema_types_1.ColumnType.VARCHAR,
+            varchar: schema_types_1.ColumnType.VARCHAR,
+            text: schema_types_1.ColumnType.TEXT,
+            character: schema_types_1.ColumnType.CHAR,
+            char: schema_types_1.ColumnType.CHAR,
+            integer: schema_types_1.ColumnType.INTEGER,
+            bigint: schema_types_1.ColumnType.BIGINT,
+            smallint: schema_types_1.ColumnType.SMALLINT,
+            decimal: schema_types_1.ColumnType.DECIMAL,
+            numeric: schema_types_1.ColumnType.NUMERIC,
+            real: schema_types_1.ColumnType.FLOAT,
+            'double precision': schema_types_1.ColumnType.DOUBLE,
+            boolean: schema_types_1.ColumnType.BOOLEAN,
+            date: schema_types_1.ColumnType.DATE,
+            time: schema_types_1.ColumnType.TIME,
+            timestamp: schema_types_1.ColumnType.TIMESTAMP,
+            'timestamp without time zone': schema_types_1.ColumnType.TIMESTAMP,
+            jsonb: schema_types_1.ColumnType.JSONB,
+            json: schema_types_1.ColumnType.JSON,
+            uuid: schema_types_1.ColumnType.UUID,
+            bytea: schema_types_1.ColumnType.BINARY,
+        };
+        return typeMap[pgType.toLowerCase()] || schema_types_1.ColumnType.TEXT;
+    }
+    /**
+     * Ensure migration table exists
+     */
+    async ensureMigrationTable(client) {
+        const query = `
+      CREATE TABLE IF NOT EXISTS _ductape_migrations (
+        tag VARCHAR(255) PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+        await client.query(query);
+    }
+    /**
+     * Record migration execution
+     */
+    async recordMigration(client, migration, direction) {
+        await this.ensureMigrationTable(client);
+        const query = `
+      INSERT INTO _ductape_migrations (tag, name, executed_at)
+      VALUES ($1, $2, CURRENT_TIMESTAMP)
+      ON CONFLICT (tag) DO UPDATE SET executed_at = CURRENT_TIMESTAMP
+    `;
+        await client.query(query, [migration.tag, migration.name]);
+    }
+    /**
+     * Remove migration from history
+     */
+    async removeMigration(client, tag) {
+        await this.ensureMigrationTable(client);
+        const query = `DELETE FROM _ductape_migrations WHERE tag = $1`;
+        await client.query(query, [tag]);
+    }
+    // ==================== Utility Methods ====================
+    /**
+     * Escape identifier (table/column name)
+     */
+    escapeIdentifier(identifier) {
+        return `"${identifier.replace(/"/g, '""')}"`;
+    }
+    /**
+     * Escape value for SQL
+     */
+    escapeValue(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            return `'${value.replace(/'/g, "''")}'`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'TRUE' : 'FALSE';
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        if (Array.isArray(value)) {
+            return `ARRAY[${value.map((v) => this.escapeValue(v)).join(', ')}]`;
+        }
+        if (typeof value === 'object') {
+            return `'${JSON.stringify(value)}'::jsonb`;
+        }
+        return String(value);
+    }
+    /**
+     * Get database version
+     */
+    async getDatabaseVersion(connection) {
+        var _a;
+        try {
+            const pool = connection.getClient();
+            const result = await pool.query('SELECT version()');
+            return ((_a = result.rows[0]) === null || _a === void 0 ? void 0 : _a.version) || 'Unknown';
+        }
+        catch (error) {
+            return 'Unknown';
+        }
+    }
+}
+exports.PostgreSQLAdapter = PostgreSQLAdapter;
+//# sourceMappingURL=postgresql.adapter.js.map