@ductape/sdk 0.0.4-v41 → 0.0.4-v43

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

@@ -0,0 +1,1288 @@
+"use strict";
+/**
+ * PostgreSQL Database Adapter
+ * Implements database operations for PostgreSQL
+ */
+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 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 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 {
+            // TODO: Import pg library dynamically
+            // const { Pool } = await import('pg');
+            // TODO: Create connection pool
+            // const pool = new Pool({
+            //   host: config.host,
+            //   port: config.port || 5432,
+            //   database: config.database,
+            //   user: config.user,
+            //   password: config.password,
+            //   ssl: config.ssl,
+            //   max: config.poolSize || 10,
+            //   connectionTimeoutMillis: config.connectionTimeout || 5000,
+            // });
+            // TODO: Test connection
+            // await pool.query('SELECT 1');
+            // TODO: Create connection wrapper
+            // const connectionId = `postgresql-${config.database}-${Date.now()}`;
+            // const connection = new PostgreSQLConnection(connectionId, pool);
+            // return connection;
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, 'PostgreSQL adapter not fully implemented yet - connection pending pg library integration');
+        }
+        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) {
+        const client = connection.getClient();
+        await client.query('BEGIN');
+        return { client };
+    }
+    async commitTransaction(connection, transaction) {
+        await transaction.client.query('COMMIT');
+    }
+    async rollbackTransaction(connection, transaction) {
+        await transaction.client.query('ROLLBACK');
+    }
+    async createSavepoint(connection, transaction, savepointName) {
+        await transaction.client.query(`SAVEPOINT ${savepointName}`);
+    }
+    async rollbackToSavepoint(connection, transaction, savepointName) {
+        await transaction.client.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+    }
+    async releaseSavepoint(connection, transaction, savepointName) {
+        await transaction.client.query(`RELEASE SAVEPOINT ${savepointName}`);
+    }
+    // ==================== 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;
+        // SELECT clause
+        const selectColumns = options.select && options.select.length > 0
+            ? options.select.map((col) => `"${col}"`).join(', ')
+            : '*';
+        let query = `SELECT ${options.distinct ? 'DISTINCT ' : ''}${selectColumns} FROM "${options.table}"`;
+        // 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(', ')}`;
+        }
+        // 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) => `"${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 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]) => {
+                selectColumns.push(`${agg.function}("${agg.column}") 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]) => {
+            return `${agg.function}("${agg.column}") as "${alias}"`;
+        });
+        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);
+        }
+        return { query, params };
+    }
+    /**
+     * Build WHERE clause from WhereClause object
+     */
+    buildWhereClause(where, startIndex = 1) {
+        const values = [];
+        let paramIndex = startIndex;
+        const buildCondition = (condition) => {
+            if (typeof condition !== 'object' || condition === null) {
+                values.push(condition);
+                return `$${paramIndex++}`;
+            }
+            // Handle operators like $and, $or
+            if (condition.$and) {
+                const subConditions = condition.$and.map(buildCondition);
+                return `(${subConditions.join(' AND ')})`;
+            }
+            if (condition.$or) {
+                const subConditions = condition.$or.map(buildCondition);
+                return `(${subConditions.join(' OR ')})`;
+            }
+            // Handle column conditions
+            const conditions = [];
+            for (const [key, value] of Object.entries(condition)) {
+                if (typeof value === 'object' && value !== null) {
+                    // Handle operators like $gt, $lt, $gte, $lte, $ne, $in, $like
+                    for (const [op, opValue] of Object.entries(value)) {
+                        switch (op) {
+                            case '$gt':
+                                values.push(opValue);
+                                conditions.push(`"${key}" > $${paramIndex++}`);
+                                break;
+                            case '$gte':
+                                values.push(opValue);
+                                conditions.push(`"${key}" >= $${paramIndex++}`);
+                                break;
+                            case '$lt':
+                                values.push(opValue);
+                                conditions.push(`"${key}" < $${paramIndex++}`);
+                                break;
+                            case '$lte':
+                                values.push(opValue);
+                                conditions.push(`"${key}" <= $${paramIndex++}`);
+                                break;
+                            case '$ne':
+                                values.push(opValue);
+                                conditions.push(`"${key}" != $${paramIndex++}`);
+                                break;
+                            case '$in':
+                                values.push(opValue);
+                                conditions.push(`"${key}" = ANY($${paramIndex++})`);
+                                break;
+                            case '$like':
+                                values.push(opValue);
+                                conditions.push(`"${key}" LIKE $${paramIndex++}`);
+                                break;
+                            case '$ilike':
+                                values.push(opValue);
+                                conditions.push(`"${key}" ILIKE $${paramIndex++}`);
+                                break;
+                        }
+                    }
+                }
+                else {
+                    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