@ductape/sdk 0.1.7 → 0.1.8

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

@@ -1,1487 +0,0 @@
-"use strict";
-/**
- * PostgreSQL Adapter
- *
- * Database adapter for PostgreSQL databases using the 'pg' library.
- * Implements all methods from BaseAdapter with PostgreSQL-specific optimizations.
- */
-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 enums_1 = require("../types/enums");
-const database_error_1 = require("../utils/database-error");
-/**
- * PostgreSQL database adapter
- * Provides PostgreSQL-specific implementations for all database operations
- */
-class PostgreSQLAdapter extends base_adapter_1.BaseAdapter {
-    constructor() {
-        super(...arguments);
-        this.databaseType = enums_1.DatabaseType.POSTGRESQL;
-        this.pool = null;
-    }
-    // ==================== CONNECTION METHODS ====================
-    async connect(options) {
-        try {
-            // Dynamic import of pg to avoid bundling issues
-            const { Pool } = await Promise.resolve().then(() => __importStar(require('pg')));
-            this.connectionUrl = options.connectionUrl;
-            this.connectionOptions = options; // Store for auto-reconnection
-            const poolConfig = {
-                connectionString: options.connectionUrl,
-                max: options.poolSize || 10,
-                idleTimeoutMillis: options.idleTimeout || 30000,
-                connectionTimeoutMillis: options.connectionTimeout || 5000,
-                ssl: options.ssl ? { rejectUnauthorized: false } : undefined,
-            };
-            this.pool = new Pool(poolConfig);
-            // Test the connection
-            const client = await this.pool.connect();
-            const versionResult = await client.query('SELECT version()');
-            client.release();
-            this.client = this.pool;
-            this.connected = true;
-            return {
-                connected: true,
-                version: versionResult.rows[0].version,
-            };
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.connectionError(`Failed to connect to PostgreSQL: ${error.message}`, error);
-        }
-    }
-    async testConnection(options) {
-        try {
-            const { Pool } = await Promise.resolve().then(() => __importStar(require('pg')));
-            const pool = new Pool({
-                connectionString: options.connectionUrl,
-                max: 1,
-                connectionTimeoutMillis: options.connectionTimeout || 5000,
-            });
-            const client = await pool.connect();
-            const versionResult = await client.query('SELECT version()');
-            client.release();
-            await pool.end();
-            return {
-                connected: true,
-                version: versionResult.rows[0].version,
-            };
-        }
-        catch (error) {
-            return {
-                connected: false,
-            };
-        }
-    }
-    async disconnect() {
-        if (this.pool) {
-            await this.pool.end();
-            this.pool = null;
-            this.client = null;
-            this.connected = false;
-        }
-    }
-    // ==================== QUERY METHODS ====================
-    async query(query) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b, _c;
-            try {
-                const client = ((_a = query.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-                const result = await client.query(query.sql, query.params);
-                // Get total count if needed for pagination
-                let count = result.rows.length;
-                if (query.options.limit || query.options.offset) {
-                    const countSql = this.buildCountQuery(query);
-                    // Calculate how many params to remove based on actual pagination options
-                    let paramsToRemove = 0;
-                    if (query.options.limit !== undefined)
-                        paramsToRemove++;
-                    if (query.options.offset !== undefined)
-                        paramsToRemove++;
-                    const countParams = paramsToRemove > 0 ? (_b = query.params) === null || _b === void 0 ? void 0 : _b.slice(0, -paramsToRemove) : query.params;
-                    const countResult = await client.query(countSql, countParams);
-                    count = parseInt(countResult.rows[0].count, 10);
-                }
-                return {
-                    data: result.rows,
-                    count,
-                    fields: (_c = result.fields) === null || _c === void 0 ? void 0 : _c.map((f) => f.name),
-                };
-            }
-            catch (error) {
-                throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-            }
-        });
-    }
-    async raw(options) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b;
-            try {
-                const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-                const result = await client.query(options.query, options.params);
-                return {
-                    data: result.rows,
-                    count: result.rowCount || result.rows.length,
-                    fields: (_b = result.fields) === null || _b === void 0 ? void 0 : _b.map((f) => f.name),
-                };
-            }
-            catch (error) {
-                throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-            }
-        });
-    }
-    // ==================== WRITE METHODS ====================
-    async insert(options) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            const data = Array.isArray(options.data) ? options.data : [options.data];
-            if (data.length === 0) {
-                return { data: [], count: 0, insertedIds: [] };
-            }
-            const columns = Object.keys(data[0]);
-            const values = [];
-            const valuePlaceholders = [];
-            data.forEach((record, rowIndex) => {
-                const rowPlaceholders = [];
-                columns.forEach((col, colIndex) => {
-                    values.push(record[col]);
-                    rowPlaceholders.push(`$${rowIndex * columns.length + colIndex + 1}`);
-                });
-                valuePlaceholders.push(`(${rowPlaceholders.join(', ')})`);
-            });
-            let sql = `INSERT INTO ${this.escapeIdentifier(options.table)} (${columns.map(c => this.escapeIdentifier(c)).join(', ')}) VALUES ${valuePlaceholders.join(', ')}`;
-            // Handle ON CONFLICT (upsert)
-            if (options.onConflict) {
-                const conflictColumns = options.onConflict.columns.map(c => this.escapeIdentifier(c)).join(', ');
-                if (options.onConflict.action === 'ignore') {
-                    sql += ` ON CONFLICT (${conflictColumns}) DO NOTHING`;
-                }
-                else if (options.onConflict.action === 'update' && options.onConflict.update) {
-                    const updates = options.onConflict.update.map(col => `${this.escapeIdentifier(col)} = EXCLUDED.${this.escapeIdentifier(col)}`).join(', ');
-                    sql += ` ON CONFLICT (${conflictColumns}) DO UPDATE SET ${updates}`;
-                }
-            }
-            // Always use RETURNING * to get all columns including the primary key
-            // This avoids assuming the primary key column is named 'id'
-            sql += ' RETURNING *';
-            const result = await client.query(sql, values);
-            // Try to extract the primary key value from returned rows
-            // Look for common primary key column names if 'id' doesn't exist
-            const insertedIds = result.rows.map((r) => {
-                // Try common primary key column names in order of likelihood
-                if (r.id !== undefined)
-                    return r.id;
-                if (r._id !== undefined)
-                    return r._id;
-                if (r.uuid !== undefined)
-                    return r.uuid;
-                // Fall back to first column value as a reasonable guess for serial PKs
-                const keys = Object.keys(r);
-                return keys.length > 0 ? r[keys[0]] : undefined;
-            });
-            return {
-                data: options.returning ? result.rows : [],
-                count: result.rowCount || data.length,
-                insertedIds,
-            };
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async update(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-        this.ensureConnected();
-        try {
-            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            const setClauses = [];
-            const values = [];
-            let paramIndex = 1;
-            // Track nested JSON updates to merge them (multiple updates to same column)
-            const jsonbSetUpdates = new Map();
-            // Build SET clause
-            for (const [key, value] of Object.entries(options.data)) {
-                // Check if this is a nested JSON path (e.g., 'metadata.preferences.notifications')
-                if (key.includes('.') && !this.isUpdateOperator(value)) {
-                    const parts = key.split('.');
-                    const column = parts[0];
-                    const jsonPath = parts.slice(1);
-                    // Collect nested updates for the same column
-                    if (!jsonbSetUpdates.has(column)) {
-                        jsonbSetUpdates.set(column, []);
-                    }
-                    jsonbSetUpdates.get(column).push({ path: jsonPath, value, paramIndex });
-                    values.push(JSON.stringify(value));
-                    paramIndex++;
-                    continue;
-                }
-                if (value && typeof value === 'object' && this.isUpdateOperator(value)) {
-                    // Handle update operators - support both lowercase (new) and uppercase (legacy)
-                    if ('$inc' in value || '$INC' in value) {
-                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} + $${paramIndex}`);
-                        values.push((_b = value.$inc) !== null && _b !== void 0 ? _b : value.$INC);
-                        paramIndex++;
-                    }
-                    else if ('$dec' in value || '$DEC' in value) {
-                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} - $${paramIndex}`);
-                        values.push((_c = value.$dec) !== null && _c !== void 0 ? _c : value.$DEC);
-                        paramIndex++;
-                    }
-                    else if ('$mul' in value || '$MUL' in value) {
-                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} * $${paramIndex}`);
-                        values.push((_d = value.$mul) !== null && _d !== void 0 ? _d : value.$MUL);
-                        paramIndex++;
-                    }
-                    else if ('$min' in value || '$MIN' in value) {
-                        // LEAST function for minimum
-                        setClauses.push(`${this.escapeIdentifier(key)} = LEAST(${this.escapeIdentifier(key)}, $${paramIndex})`);
-                        values.push((_e = value.$min) !== null && _e !== void 0 ? _e : value.$MIN);
-                        paramIndex++;
-                    }
-                    else if ('$max' in value || '$MAX' in value) {
-                        // GREATEST function for maximum
-                        setClauses.push(`${this.escapeIdentifier(key)} = GREATEST(${this.escapeIdentifier(key)}, $${paramIndex})`);
-                        values.push((_f = value.$max) !== null && _f !== void 0 ? _f : value.$MAX);
-                        paramIndex++;
-                    }
-                    else if ('$set' in value || '$SET' in value) {
-                        setClauses.push(`${this.escapeIdentifier(key)} = $${paramIndex}`);
-                        values.push((_g = value.$set) !== null && _g !== void 0 ? _g : value.$SET);
-                        paramIndex++;
-                    }
-                    else if (('$unset' in value && value.$unset) || ('$UNSET' in value && value.$UNSET)) {
-                        setClauses.push(`${this.escapeIdentifier(key)} = NULL`);
-                        // No paramIndex increment needed for NULL
-                    }
-                    else if ('$push' in value || '$PUSH' in value) {
-                        // Array append for PostgreSQL (column must be array type)
-                        setClauses.push(`${this.escapeIdentifier(key)} = array_append(${this.escapeIdentifier(key)}, $${paramIndex})`);
-                        values.push((_h = value.$push) !== null && _h !== void 0 ? _h : value.$PUSH);
-                        paramIndex++;
-                    }
-                    else if ('$pull' in value || '$PULL' in value) {
-                        // Array remove for PostgreSQL (column must be array type)
-                        setClauses.push(`${this.escapeIdentifier(key)} = array_remove(${this.escapeIdentifier(key)}, $${paramIndex})`);
-                        values.push((_j = value.$pull) !== null && _j !== void 0 ? _j : value.$PULL);
-                        paramIndex++;
-                    }
-                    else if ('$addToSet' in value || '$ADDTOSET' in value) {
-                        // Add unique value to array - use CASE to check existence first
-                        const addValue = (_k = value.$addToSet) !== null && _k !== void 0 ? _k : value.$ADDTOSET;
-                        setClauses.push(`${this.escapeIdentifier(key)} = CASE WHEN $${paramIndex} = ANY(${this.escapeIdentifier(key)}) THEN ${this.escapeIdentifier(key)} ELSE array_append(${this.escapeIdentifier(key)}, $${paramIndex}) END`);
-                        values.push(addValue);
-                        paramIndex++;
-                    }
-                    else if ('$pop' in value || '$POP' in value) {
-                        const popVal = (_l = value.$pop) !== null && _l !== void 0 ? _l : value.$POP;
-                        // Pop from beginning or end of array
-                        if (popVal === -1) {
-                            setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)}[2:]`);
-                        }
-                        else {
-                            setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)}[1:array_length(${this.escapeIdentifier(key)}, 1)-1]`);
-                        }
-                    }
-                    else if ('$currentDate' in value || '$CURRENTDATE' in value) {
-                        setClauses.push(`${this.escapeIdentifier(key)} = NOW()`);
-                    }
-                }
-                else {
-                    setClauses.push(`${this.escapeIdentifier(key)} = $${paramIndex}`);
-                    values.push(value);
-                    paramIndex++;
-                }
-            }
-            // Build jsonb_set clauses for nested JSON updates
-            for (const [column, updates] of jsonbSetUpdates) {
-                // Build nested jsonb_set calls for multiple updates to the same column
-                let setExpr = this.escapeIdentifier(column);
-                for (const update of updates) {
-                    const pathArray = `'{${update.path.join(',')}}'`;
-                    setExpr = `jsonb_set(COALESCE(${setExpr}, '{}'::jsonb), ${pathArray}, $${update.paramIndex}::jsonb, true)`;
-                }
-                setClauses.push(`${this.escapeIdentifier(column)} = ${setExpr}`);
-            }
-            let sql = `UPDATE ${this.escapeIdentifier(options.table)} SET ${setClauses.join(', ')}`;
-            // Build WHERE clause
-            if (options.where) {
-                const { whereClause, whereParams } = this.buildWhereClause(options.where, paramIndex);
-                sql += ` WHERE ${whereClause}`;
-                values.push(...whereParams);
-            }
-            // Add RETURNING if requested
-            if (options.returning) {
-                sql += ' RETURNING *';
-            }
-            const result = await client.query(sql, values);
-            return {
-                data: options.returning ? result.rows : [],
-                count: result.rowCount || 0,
-            };
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async delete(options) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            let sql = `DELETE FROM ${this.escapeIdentifier(options.table)}`;
-            const values = [];
-            // Build WHERE clause
-            if (options.where) {
-                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
-                sql += ` WHERE ${whereClause}`;
-                values.push(...whereParams);
-            }
-            // Add RETURNING if requested
-            if (options.returning) {
-                sql += ' RETURNING *';
-            }
-            const result = await client.query(sql, values);
-            return {
-                count: result.rowCount || 0,
-                data: options.returning ? result.rows : undefined,
-            };
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async upsert(options) {
-        this.ensureConnected();
-        try {
-            const insertResult = await this.insert(Object.assign(Object.assign({}, options), { onConflict: {
-                    columns: options.conflictKeys,
-                    action: 'update',
-                    update: options.updateColumns || Object.keys(options.data).filter(k => !options.conflictKeys.includes(k)),
-                }, returning: true }));
-            // Determine if it was an insert or update
-            // PostgreSQL doesn't directly tell us, so we check xmax
-            const operation = 'upserted'; // Simplified - PostgreSQL doesn't easily distinguish
-            return {
-                data: insertResult.data,
-                count: insertResult.count,
-                operation: insertResult.count > 0 ? 'inserted' : 'updated',
-            };
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    // ==================== AGGREGATION METHODS ====================
-    async count(options) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            const column = options.column ? this.escapeIdentifier(options.column) : '*';
-            const distinctPrefix = options.distinct ? 'DISTINCT ' : '';
-            let sql = `SELECT COUNT(${distinctPrefix}${column}) as count FROM ${this.escapeIdentifier(options.table)}`;
-            const values = [];
-            if (options.where) {
-                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
-                sql += ` WHERE ${whereClause}`;
-                values.push(...whereParams);
-            }
-            const result = await client.query(sql, values);
-            return parseInt(result.rows[0].count, 10);
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async sum(options) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            let sql = `SELECT COALESCE(SUM(${this.escapeIdentifier(options.column)}), 0) as sum FROM ${this.escapeIdentifier(options.table)}`;
-            const values = [];
-            if (options.where) {
-                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
-                sql += ` WHERE ${whereClause}`;
-                values.push(...whereParams);
-            }
-            const result = await client.query(sql, values);
-            return parseFloat(result.rows[0].sum);
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async avg(options) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            let sql = `SELECT COALESCE(AVG(${this.escapeIdentifier(options.column)}), 0) as avg FROM ${this.escapeIdentifier(options.table)}`;
-            const values = [];
-            if (options.where) {
-                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
-                sql += ` WHERE ${whereClause}`;
-                values.push(...whereParams);
-            }
-            const result = await client.query(sql, values);
-            return parseFloat(result.rows[0].avg);
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async min(options) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            let sql = `SELECT MIN(${this.escapeIdentifier(options.column)}) as min FROM ${this.escapeIdentifier(options.table)}`;
-            const values = [];
-            if (options.where) {
-                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
-                sql += ` WHERE ${whereClause}`;
-                values.push(...whereParams);
-            }
-            const result = await client.query(sql, values);
-            return result.rows[0].min;
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async max(options) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            let sql = `SELECT MAX(${this.escapeIdentifier(options.column)}) as max FROM ${this.escapeIdentifier(options.table)}`;
-            const values = [];
-            if (options.where) {
-                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
-                sql += ` WHERE ${whereClause}`;
-                values.push(...whereParams);
-            }
-            const result = await client.query(sql, values);
-            return result.rows[0].max;
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async aggregate(builtAggregation) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = builtAggregation.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            const result = await client.query(builtAggregation.sql, builtAggregation.params);
-            return result.rows[0] || {};
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    async groupBy(builtGroupBy) {
-        var _a;
-        this.ensureConnected();
-        try {
-            const client = ((_a = builtGroupBy.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
-            const result = await client.query(builtGroupBy.sql, builtGroupBy.params);
-            // Transform rows into IGroupByResult format
-            const options = builtGroupBy.options;
-            return result.rows.map((row) => {
-                var _a;
-                const group = {};
-                const aggregates = {};
-                for (const key of Object.keys(row)) {
-                    if ((_a = options.groupBy) === null || _a === void 0 ? void 0 : _a.includes(key)) {
-                        group[key] = row[key];
-                    }
-                    else {
-                        aggregates[key] = row[key];
-                    }
-                }
-                return { group, aggregates: aggregates };
-            });
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
-        }
-    }
-    // ==================== TRANSACTION METHODS ====================
-    async beginTransaction(isolationLevel, readOnly, timeout) {
-        this.ensureConnected();
-        try {
-            const client = await this.pool.connect();
-            const id = `pg_txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-            // Build BEGIN statement with isolation level
-            let beginSql = 'BEGIN';
-            if (isolationLevel) {
-                beginSql += ` ISOLATION LEVEL ${this.mapIsolationLevel(isolationLevel)}`;
-            }
-            if (readOnly) {
-                beginSql += ' READ ONLY';
-            }
-            await client.query(beginSql);
-            // Set statement timeout if specified
-            if (timeout) {
-                await client.query(`SET LOCAL statement_timeout = ${timeout}`);
-            }
-            return {
-                id,
-                databaseType: 'postgresql',
-                isolationLevel: isolationLevel || enums_1.IsolationLevel.READ_COMMITTED,
-                readOnly: readOnly || false,
-                timeout,
-                startedAt: new Date(),
-                client,
-                savepoints: new Map(),
-                status: 'active',
-            };
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.transactionError(`Failed to begin transaction: ${error.message}`, error);
-        }
-    }
-    async commitTransaction(context) {
-        try {
-            await context.client.query('COMMIT');
-            context.client.release();
-            context.status = 'committed';
-        }
-        catch (error) {
-            context.status = 'error';
-            context.client.release();
-            throw database_error_1.DatabaseError.transactionError(`Failed to commit transaction: ${error.message}`, error);
-        }
-    }
-    async rollbackTransaction(context) {
-        try {
-            await context.client.query('ROLLBACK');
-            context.client.release();
-            context.status = 'rolled_back';
-        }
-        catch (error) {
-            context.status = 'error';
-            context.client.release();
-            throw database_error_1.DatabaseError.transactionError(`Failed to rollback transaction: ${error.message}`, error);
-        }
-    }
-    async createSavepoint(context, name) {
-        try {
-            await context.client.query(`SAVEPOINT ${this.escapeIdentifier(name)}`);
-            const savepoint = {
-                name,
-                release: async () => {
-                    await this.releaseSavepoint(context, savepoint);
-                },
-                rollback: async () => {
-                    await this.rollbackToSavepoint(context, savepoint);
-                },
-            };
-            context.savepoints.set(name, savepoint);
-            return savepoint;
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.transactionError(`Failed to create savepoint: ${error.message}`, error);
-        }
-    }
-    async releaseSavepoint(context, savepoint) {
-        try {
-            await context.client.query(`RELEASE SAVEPOINT ${this.escapeIdentifier(savepoint.name)}`);
-            context.savepoints.delete(savepoint.name);
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.transactionError(`Failed to release savepoint: ${error.message}`, error);
-        }
-    }
-    async rollbackToSavepoint(context, savepoint) {
-        try {
-            await context.client.query(`ROLLBACK TO SAVEPOINT ${this.escapeIdentifier(savepoint.name)}`);
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.transactionError(`Failed to rollback to savepoint: ${error.message}`, error);
-        }
-    }
-    supportsSavepoints() {
-        return true;
-    }
-    // ==================== SCHEMA METHODS ====================
-    async createTable(definition, options) {
-        this.ensureConnected();
-        try {
-            const columnDefs = definition.columns.map(col => this.buildColumnDefinition(col)).join(', ');
-            let sql = 'CREATE';
-            if (options === null || options === void 0 ? void 0 : options.temporary)
-                sql += ' TEMPORARY';
-            if (options === null || options === void 0 ? void 0 : options.unlogged)
-                sql += ' UNLOGGED';
-            sql += ' TABLE';
-            if (options === null || options === void 0 ? void 0 : options.ifNotExists)
-                sql += ' IF NOT EXISTS';
-            sql += ` ${this.escapeIdentifier(definition.name)} (${columnDefs}`;
-            // Add table constraints
-            if (definition.constraints) {
-                const constraintDefs = definition.constraints.map(c => this.buildConstraintDefinition(c)).join(', ');
-                sql += `, ${constraintDefs}`;
-            }
-            sql += ')';
-            // Add inheritance
-            if (options === null || options === void 0 ? void 0 : options.inherits) {
-                sql += ` INHERITS (${this.escapeIdentifier(options.inherits)})`;
-            }
-            // Add tablespace
-            if (options === null || options === void 0 ? void 0 : options.tablespace) {
-                sql += ` TABLESPACE ${this.escapeIdentifier(options.tablespace)}`;
-            }
-            await this.pool.query(sql);
-            // Add table comment
-            if (definition.comment) {
-                await this.pool.query(`COMMENT ON TABLE ${this.escapeIdentifier(definition.name)} IS ${this.escapeValue(definition.comment)}`);
-            }
-            // Create indexes
-            if (definition.indexes) {
-                for (const index of definition.indexes) {
-                    await this.createIndex(index);
-                }
-            }
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to create table: ${error.message}`, error);
-        }
-    }
-    async alterTable(tableName, operations) {
-        this.ensureConnected();
-        try {
-            for (const op of operations) {
-                let sql = `ALTER TABLE ${this.escapeIdentifier(tableName)}`;
-                switch (op.type) {
-                    case 'ADD':
-                        if (op.column) {
-                            sql += ` ADD COLUMN ${this.buildColumnDefinition(op.column)}`;
-                        }
-                        else if (op.constraint) {
-                            sql += ` ADD ${this.buildConstraintDefinition(op.constraint)}`;
-                        }
-                        break;
-                    case 'DROP':
-                        if (op.columnName) {
-                            sql += ` DROP COLUMN ${this.escapeIdentifier(op.columnName)}`;
-                        }
-                        else if (op.constraintName) {
-                            sql += ` DROP CONSTRAINT ${this.escapeIdentifier(op.constraintName)}`;
-                        }
-                        break;
-                    case 'MODIFY':
-                        if (op.column) {
-                            // PostgreSQL uses ALTER COLUMN for modifications
-                            const col = op.column;
-                            if (col.type) {
-                                sql += ` ALTER COLUMN ${this.escapeIdentifier(col.name)} TYPE ${this.getColumnTypeString(col.type, col)}`;
-                            }
-                            if (col.nullable !== undefined) {
-                                if (col.nullable) {
-                                    sql += ` ALTER COLUMN ${this.escapeIdentifier(col.name)} DROP NOT NULL`;
-                                }
-                                else {
-                                    sql += ` ALTER COLUMN ${this.escapeIdentifier(col.name)} SET NOT NULL`;
-                                }
-                            }
-                            if (col.defaultValue !== undefined) {
-                                sql += ` ALTER COLUMN ${this.escapeIdentifier(col.name)} SET DEFAULT ${this.escapeValue(col.defaultValue)}`;
-                            }
-                        }
-                        break;
-                    case 'RENAME':
-                        if (op.oldName && op.newName) {
-                            sql += ` RENAME COLUMN ${this.escapeIdentifier(op.oldName)} TO ${this.escapeIdentifier(op.newName)}`;
-                        }
-                        break;
-                }
-                await this.pool.query(sql);
-            }
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to alter table: ${error.message}`, error);
-        }
-    }
-    async dropTable(tableName, ifExists, cascade) {
-        this.ensureConnected();
-        try {
-            let sql = 'DROP TABLE';
-            if (ifExists)
-                sql += ' IF EXISTS';
-            sql += ` ${this.escapeIdentifier(tableName)}`;
-            if (cascade)
-                sql += ' CASCADE';
-            await this.pool.query(sql);
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to drop table: ${error.message}`, error);
-        }
-    }
-    async listTables() {
-        this.ensureConnected();
-        try {
-            const result = await this.pool.query(`
-        SELECT tablename FROM pg_tables
-        WHERE schemaname = 'public'
-        ORDER BY tablename
-      `);
-            return result.rows.map((r) => r.tablename);
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to list tables: ${error.message}`, error);
-        }
-    }
-    async listTablesWithInfo() {
-        this.ensureConnected();
-        try {
-            const result = await this.pool.query(`
-        SELECT
-          t.tablename as name,
-          t.schemaname as schema,
-          c.reltuples::bigint as estimated_row_count,
-          pg_catalog.obj_description(c.oid, 'pg_class') as comment
-        FROM pg_tables t
-        LEFT JOIN pg_class c ON c.relname = t.tablename
-        WHERE t.schemaname = 'public'
-        ORDER BY t.tablename
-      `);
-            return result.rows.map((r) => ({
-                name: r.name,
-                schema: r.schema,
-                estimatedRowCount: r.estimated_row_count >= 0 ? Number(r.estimated_row_count) : undefined,
-                comment: r.comment || undefined,
-            }));
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to list tables with info: ${error.message}`, error);
-        }
-    }
-    async tableExists(tableName) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const result = await this.pool.query(`
-          SELECT EXISTS (
-            SELECT FROM pg_tables
-            WHERE schemaname = 'public' AND tablename = $1
-          )
-        `, [tableName]);
-                return result.rows[0].exists;
-            }
-            catch (error) {
-                throw database_error_1.DatabaseError.schemaError(`Failed to check table existence: ${error.message}`, error);
-            }
-        });
-    }
-    async getTableSchema(tableName) {
-        this.ensureConnected();
-        try {
-            // Get columns
-            const columnsResult = await this.pool.query(`
-        SELECT
-          column_name as name,
-          data_type as type,
-          is_nullable = 'YES' as nullable,
-          column_default as default_value,
-          character_maximum_length as max_length,
-          numeric_precision as precision,
-          numeric_scale as scale
-        FROM information_schema.columns
-        WHERE table_schema = 'public' AND table_name = $1
-        ORDER BY ordinal_position
-      `, [tableName]);
-            // Get primary key
-            const pkResult = await this.pool.query(`
-        SELECT a.attname as column_name
-        FROM pg_index i
-        JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
-        WHERE i.indrelid = $1::regclass AND i.indisprimary
-      `, [tableName]);
-            const primaryKey = pkResult.rows.map((r) => r.column_name);
-            // Get indexes
-            const indexes = await this.listIndexes(tableName);
-            // Get constraints
-            const constraintsResult = await this.pool.query(`
-        SELECT
-          con.conname as name,
-          CASE con.contype
-            WHEN 'p' THEN 'PRIMARY KEY'
-            WHEN 'f' THEN 'FOREIGN KEY'
-            WHEN 'u' THEN 'UNIQUE'
-            WHEN 'c' THEN 'CHECK'
-          END as type,
-          ARRAY(
-            SELECT a.attname
-            FROM unnest(con.conkey) WITH ORDINALITY AS k(key, ord)
-            JOIN pg_attribute a ON a.attnum = k.key AND a.attrelid = con.conrelid
-            ORDER BY k.ord
-          ) as columns,
-          pg_get_constraintdef(con.oid) as definition
-        FROM pg_constraint con
-        JOIN pg_namespace nsp ON nsp.oid = con.connamespace
-        WHERE con.conrelid = $1::regclass AND nsp.nspname = 'public'
-      `, [tableName]);
-            const columns = columnsResult.rows.map((col) => {
-                var _a;
-                return ({
-                    name: col.name,
-                    type: col.type,
-                    nullable: col.nullable,
-                    defaultValue: col.default_value,
-                    isPrimaryKey: primaryKey.includes(col.name),
-                    isUnique: false, // Would need additional query
-                    isAutoIncrement: (_a = col.default_value) === null || _a === void 0 ? void 0 : _a.includes('nextval'),
-                    maxLength: col.max_length,
-                    precision: col.precision,
-                    scale: col.scale,
-                });
-            });
-            const constraints = constraintsResult.rows.map((c) => ({
-                name: c.name,
-                type: c.type,
-                columns: c.columns,
-                expression: c.definition,
-            }));
-            return {
-                name: tableName,
-                schema: 'public',
-                columns,
-                indexes,
-                constraints,
-                primaryKey: primaryKey.length > 0 ? primaryKey : undefined,
-            };
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to get table schema: ${error.message}`, error);
-        }
-    }
-    async createIndex(index, ifNotExists, concurrent) {
-        this.ensureConnected();
-        try {
-            let sql = 'CREATE';
-            if (index.unique)
-                sql += ' UNIQUE';
-            sql += ' INDEX';
-            if (concurrent)
-                sql += ' CONCURRENTLY';
-            if (ifNotExists)
-                sql += ' IF NOT EXISTS';
-            sql += ` ${this.escapeIdentifier(index.name)} ON ${this.escapeIdentifier(index.table)}`;
-            // Add index method
-            if (index.method) {
-                sql += ` USING ${index.method}`;
-            }
-            // Add columns
-            const columnDefs = index.columns.map(col => {
-                let def = this.escapeIdentifier(col.name);
-                if (col.order)
-                    def += ` ${col.order}`;
-                if (col.nulls)
-                    def += ` NULLS ${col.nulls}`;
-                if (col.opclass)
-                    def += ` ${col.opclass}`;
-                return def;
-            }).join(', ');
-            sql += ` (${columnDefs})`;
-            // Add include columns (covering index)
-            if (index.include && index.include.length > 0) {
-                sql += ` INCLUDE (${index.include.map(c => this.escapeIdentifier(c)).join(', ')})`;
-            }
-            // Add partial index condition
-            if (index.where) {
-                sql += ` WHERE ${index.where}`;
-            }
-            await this.pool.query(sql);
-            // Add comment
-            if (index.comment) {
-                await this.pool.query(`COMMENT ON INDEX ${this.escapeIdentifier(index.name)} IS ${this.escapeValue(index.comment)}`);
-            }
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to create index: ${error.message}`, error);
-        }
-    }
-    async dropIndex(tableName, indexName, ifExists, concurrent, cascade) {
-        this.ensureConnected();
-        try {
-            let sql = 'DROP INDEX';
-            if (concurrent)
-                sql += ' CONCURRENTLY';
-            if (ifExists)
-                sql += ' IF EXISTS';
-            sql += ` ${this.escapeIdentifier(indexName)}`;
-            if (cascade)
-                sql += ' CASCADE';
-            await this.pool.query(sql);
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to drop index: ${error.message}`, error);
-        }
-    }
-    async listIndexes(tableName, includeSystem) {
-        this.ensureConnected();
-        try {
-            let sql = `
-        SELECT
-          i.relname as name,
-          t.relname as table,
-          ARRAY(
-            SELECT a.attname
-            FROM unnest(ix.indkey) WITH ORDINALITY AS k(key, ord)
-            JOIN pg_attribute a ON a.attnum = k.key AND a.attrelid = ix.indrelid
-            ORDER BY k.ord
-          ) as columns,
-          ix.indisunique as unique,
-          ix.indisprimary as primary_key,
-          am.amname as type,
-          pg_relation_size(i.oid) as size,
-          pg_get_indexdef(ix.indexrelid) as definition
-        FROM pg_index ix
-        JOIN pg_class i ON i.oid = ix.indexrelid
-        JOIN pg_class t ON t.oid = ix.indrelid
-        JOIN pg_am am ON am.oid = i.relam
-        JOIN pg_namespace n ON n.oid = t.relnamespace
-        WHERE t.relname = $1 AND n.nspname = 'public'
-      `;
-            if (!includeSystem) {
-                sql += ` AND NOT i.relname LIKE 'pg_%'`;
-            }
-            const result = await this.pool.query(sql, [tableName]);
-            return result.rows.map((row) => ({
-                name: row.name,
-                table: row.table,
-                columns: row.columns,
-                unique: row.unique,
-                primaryKey: row.primary_key,
-                type: row.type,
-                size: parseInt(row.size, 10),
-            }));
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to list indexes: ${error.message}`, error);
-        }
-    }
-    async getIndexStatistics(tableName, indexName) {
-        this.ensureConnected();
-        try {
-            let sql = `
-        SELECT
-          indexrelname as index_name,
-          relname as table_name,
-          idx_scan as scans,
-          idx_tup_read as tuples_read,
-          idx_tup_fetch as tuples_fetched,
-          pg_relation_size(indexrelid) as size_bytes,
-          pg_size_pretty(pg_relation_size(indexrelid)) as size_formatted
-        FROM pg_stat_user_indexes
-        WHERE relname = $1
-      `;
-            const params = [tableName];
-            if (indexName) {
-                sql += ` AND indexrelname = $2`;
-                params.push(indexName);
-            }
-            const result = await this.pool.query(sql, params);
-            return result.rows.map((row) => ({
-                indexName: row.index_name,
-                tableName: row.table_name,
-                scans: parseInt(row.scans, 10),
-                tuplesRead: parseInt(row.tuples_read, 10),
-                tuplesFetched: parseInt(row.tuples_fetched, 10),
-                sizeBytes: parseInt(row.size_bytes, 10),
-                sizeFormatted: row.size_formatted,
-            }));
-        }
-        catch (error) {
-            throw database_error_1.DatabaseError.schemaError(`Failed to get index statistics: ${error.message}`, error);
-        }
-    }
-    // ==================== UTILITY METHODS ====================
-    escapeIdentifier(identifier) {
-        // PostgreSQL uses double quotes for identifiers
-        return `"${identifier.replace(/"/g, '""')}"`;
-    }
-    /**
-     * Format a field reference for use in WHERE clauses.
-     * Handles JSON path notation (e.g., "metadata.role" becomes "metadata"->>'role')
-     */
-    formatFieldRef(field) {
-        if (!field.includes('.')) {
-            return this.escapeIdentifier(field);
-        }
-        // Split the field path - first part is the column, rest are JSON keys
-        const parts = field.split('.');
-        const column = this.escapeIdentifier(parts[0]);
-        // Build the JSON path accessor
-        // Use ->> for the last key to get text value, -> for intermediate keys
-        if (parts.length === 2) {
-            // Simple case: column.key - use ->> to get text value
-            return `${column}->>'${parts[1]}'`;
-        }
-        else {
-            // Nested case: column.key1.key2... - use -> for intermediate, ->> for last
-            let path = column;
-            for (let i = 1; i < parts.length - 1; i++) {
-                path += `->'${parts[i]}'`;
-            }
-            path += `->>'${parts[parts.length - 1]}'`;
-            return path;
-        }
-    }
-    escapeValue(value) {
-        if (value === null || value === undefined) {
-            return 'NULL';
-        }
-        if (typeof value === 'number') {
-            return String(value);
-        }
-        if (typeof value === 'boolean') {
-            return value ? 'TRUE' : 'FALSE';
-        }
-        if (value instanceof Date) {
-            return `'${value.toISOString()}'`;
-        }
-        if (typeof value === 'object') {
-            return `'${JSON.stringify(value).replace(/'/g, "''")}'::jsonb`;
-        }
-        // String - escape single quotes
-        return `'${String(value).replace(/'/g, "''")}'`;
-    }
-    /**
-     * Check if value is an update operator object
-     * Supports both lowercase (new) and uppercase (legacy) operators
-     */
-    isUpdateOperator(value) {
-        if (!value || typeof value !== 'object')
-            return false;
-        // Support both lowercase (Mongoose style) and uppercase (legacy) operators
-        const operators = [
-            '$inc', '$INC', '$dec', '$DEC', '$mul', '$MUL', '$min', '$MIN', '$max', '$MAX',
-            '$set', '$SET', '$unset', '$UNSET', '$push', '$PUSH', '$pull', '$PULL',
-            '$addToSet', '$ADDTOSET', '$pop', '$POP', '$currentDate', '$CURRENTDATE'
-        ];
-        return operators.some(op => op in value);
-    }
-    getParameterPlaceholder(index) {
-        // PostgreSQL uses $1, $2, $3, etc.
-        return `$${index}`;
-    }
-    getColumnTypeString(columnType, options) {
-        const typeMap = {
-            [enums_1.ColumnType.INTEGER]: 'INTEGER',
-            [enums_1.ColumnType.BIGINT]: 'BIGINT',
-            [enums_1.ColumnType.SMALLINT]: 'SMALLINT',
-            [enums_1.ColumnType.FLOAT]: 'REAL',
-            [enums_1.ColumnType.DOUBLE]: 'DOUBLE PRECISION',
-            [enums_1.ColumnType.DECIMAL]: (options === null || options === void 0 ? void 0 : options.precision)
-                ? `NUMERIC(${options.precision}${options.scale ? `, ${options.scale}` : ''})`
-                : 'NUMERIC',
-            [enums_1.ColumnType.STRING]: (options === null || options === void 0 ? void 0 : options.maxLength) ? `VARCHAR(${options.maxLength})` : 'VARCHAR(255)',
-            [enums_1.ColumnType.TEXT]: 'TEXT',
-            [enums_1.ColumnType.BOOLEAN]: 'BOOLEAN',
-            [enums_1.ColumnType.DATE]: 'DATE',
-            [enums_1.ColumnType.DATETIME]: 'TIMESTAMP',
-            [enums_1.ColumnType.TIMESTAMP]: 'TIMESTAMP WITH TIME ZONE',
-            [enums_1.ColumnType.TIME]: 'TIME',
-            [enums_1.ColumnType.JSON]: 'JSON',
-            [enums_1.ColumnType.JSONB]: 'JSONB',
-            [enums_1.ColumnType.UUID]: 'UUID',
-            [enums_1.ColumnType.BINARY]: 'BYTEA',
-            // ENUM type - returns VARCHAR, CHECK constraint is added in buildColumnDefinition
-            [enums_1.ColumnType.ENUM]: 'VARCHAR(255)',
-            [enums_1.ColumnType.ARRAY]: (options === null || options === void 0 ? void 0 : options.arrayType) ? `${options.arrayType}[]` : 'TEXT[]',
-        };
-        return typeMap[columnType] || columnType;
-    }
-    getSupportedFeatures() {
-        return [
-            base_adapter_1.DatabaseFeature.TRANSACTIONS,
-            base_adapter_1.DatabaseFeature.SAVEPOINTS,
-            base_adapter_1.DatabaseFeature.JSONB,
-            base_adapter_1.DatabaseFeature.JSON,
-            base_adapter_1.DatabaseFeature.ARRAYS,
-            base_adapter_1.DatabaseFeature.UUID,
-            base_adapter_1.DatabaseFeature.FULLTEXT_SEARCH,
-            base_adapter_1.DatabaseFeature.GIN_INDEX,
-            base_adapter_1.DatabaseFeature.GIST_INDEX,
-            base_adapter_1.DatabaseFeature.HASH_INDEX,
-            base_adapter_1.DatabaseFeature.PARTIAL_INDEX,
-            base_adapter_1.DatabaseFeature.COVERING_INDEX,
-            base_adapter_1.DatabaseFeature.CONCURRENT_INDEX,
-            base_adapter_1.DatabaseFeature.CTE,
-            base_adapter_1.DatabaseFeature.WINDOW_FUNCTIONS,
-            base_adapter_1.DatabaseFeature.RETURNING,
-            base_adapter_1.DatabaseFeature.UPSERT,
-            base_adapter_1.DatabaseFeature.FOREIGN_KEYS,
-            base_adapter_1.DatabaseFeature.CHECK_CONSTRAINTS,
-            base_adapter_1.DatabaseFeature.STORED_PROCEDURES,
-            base_adapter_1.DatabaseFeature.VIEWS,
-            base_adapter_1.DatabaseFeature.MATERIALIZED_VIEWS,
-            base_adapter_1.DatabaseFeature.TRIGGERS,
-            base_adapter_1.DatabaseFeature.SCHEMAS,
-            base_adapter_1.DatabaseFeature.TABLE_INHERITANCE,
-            base_adapter_1.DatabaseFeature.LIKE,
-            base_adapter_1.DatabaseFeature.ILIKE,
-            base_adapter_1.DatabaseFeature.REGEX,
-            base_adapter_1.DatabaseFeature.BETWEEN,
-            base_adapter_1.DatabaseFeature.ARRAY_CONTAINS,
-            base_adapter_1.DatabaseFeature.LIMIT_OFFSET,
-        ];
-    }
-    parseError(error) {
-        const code = error.code;
-        let type = enums_1.DatabaseErrorType.UNKNOWN_ERROR;
-        // Map PostgreSQL error codes
-        switch (code) {
-            case '23505':
-                type = enums_1.DatabaseErrorType.UNIQUE_VIOLATION;
-                break;
-            case '23503':
-                type = enums_1.DatabaseErrorType.FOREIGN_KEY_VIOLATION;
-                break;
-            case '23502':
-                type = enums_1.DatabaseErrorType.NOT_NULL_VIOLATION;
-                break;
-            case '23514':
-                type = enums_1.DatabaseErrorType.CHECK_VIOLATION;
-                break;
-            case '08000':
-            case '08003':
-            case '08006':
-                type = enums_1.DatabaseErrorType.CONNECTION_ERROR;
-                break;
-            case '42P01':
-            case '42703':
-                type = enums_1.DatabaseErrorType.SCHEMA_ERROR;
-                break;
-            case '28000':
-            case '28P01':
-                type = enums_1.DatabaseErrorType.AUTHENTICATION_ERROR;
-                break;
-            default:
-                if (code === null || code === void 0 ? void 0 : code.startsWith('42')) {
-                    type = enums_1.DatabaseErrorType.QUERY_ERROR;
-                }
-        }
-        return {
-            type,
-            message: error.message || 'Unknown database error',
-            code,
-            details: {
-                constraint: error.constraint,
-                table: error.table,
-                column: error.column,
-                detail: error.detail,
-                hint: error.hint,
-            },
-        };
-    }
-    // ==================== PRIVATE HELPER METHODS ====================
-    ensureConnected() {
-        if (!this.connected || !this.pool) {
-            throw new database_error_1.DatabaseError('Not connected to PostgreSQL database', enums_1.DatabaseErrorType.CONNECTION_ERROR);
-        }
-    }
-    buildWhereClause(where, startIndex) {
-        const clauses = [];
-        const params = [];
-        let paramIndex = startIndex;
-        for (const [key, value] of Object.entries(where)) {
-            // Normalize key to lowercase for logical operators (support both cases for backwards compatibility)
-            const normalizedKey = key.toLowerCase();
-            if (normalizedKey === '$and') {
-                const conditions = Array.isArray(value) ? value : [value];
-                const andClauses = [];
-                for (const cond of conditions) {
-                    const andResult = this.buildWhereClause(cond, paramIndex);
-                    andClauses.push(andResult.whereClause);
-                    params.push(...andResult.whereParams);
-                    paramIndex += andResult.whereParams.length;
-                }
-                clauses.push(`(${andClauses.join(' AND ')})`);
-            }
-            else if (normalizedKey === '$or') {
-                const conditions = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
-                const orClauses = [];
-                for (const cond of conditions) {
-                    const orResult = this.buildWhereClause(cond, paramIndex);
-                    orClauses.push(orResult.whereClause);
-                    params.push(...orResult.whereParams);
-                    paramIndex += orResult.whereParams.length;
-                }
-                clauses.push(`(${orClauses.join(' OR ')})`);
-            }
-            else if (normalizedKey === '$not') {
-                const notResult = this.buildWhereClause(value, paramIndex);
-                clauses.push(`NOT (${notResult.whereClause})`);
-                params.push(...notResult.whereParams);
-                paramIndex += notResult.whereParams.length;
-            }
-            else if (normalizedKey === '$nor') {
-                const conditions = Array.isArray(value) ? value : [value];
-                const norClauses = [];
-                for (const cond of conditions) {
-                    const norResult = this.buildWhereClause(cond, paramIndex);
-                    norClauses.push(norResult.whereClause);
-                    params.push(...norResult.whereParams);
-                    paramIndex += norResult.whereParams.length;
-                }
-                clauses.push(`NOT (${norClauses.join(' OR ')})`);
-            }
-            else if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
-                // Handle operators - use formatFieldRef to support JSON path notation (e.g., metadata.role)
-                const fieldRef = this.formatFieldRef(key);
-                for (const [op, opValue] of Object.entries(value)) {
-                    // Normalize operator to lowercase (support both cases for backwards compatibility)
-                    const normalizedOp = op.toLowerCase();
-                    switch (normalizedOp) {
-                        case '$eq':
-                            clauses.push(`${fieldRef} = $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$ne':
-                            clauses.push(`${fieldRef} != $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$gt':
-                            clauses.push(`${fieldRef} > $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$gte':
-                            clauses.push(`${fieldRef} >= $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$lt':
-                            clauses.push(`${fieldRef} < $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$lte':
-                            clauses.push(`${fieldRef} <= $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$in':
-                            clauses.push(`${fieldRef} = ANY($${paramIndex})`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$nin':
-                        case '$not_in':
-                            clauses.push(`${fieldRef} != ALL($${paramIndex})`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$like':
-                            clauses.push(`${fieldRef} LIKE $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$ilike':
-                            clauses.push(`${fieldRef} ILIKE $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$isnull':
-                        case '$is_null':
-                            clauses.push(`${fieldRef} IS ${opValue ? 'NULL' : 'NOT NULL'}`);
-                            break;
-                        case '$isnotnull':
-                        case '$is_not_null':
-                            clauses.push(`${fieldRef} IS ${opValue ? 'NOT NULL' : 'NULL'}`);
-                            break;
-                        case '$between':
-                            const [min, max] = opValue;
-                            clauses.push(`${fieldRef} BETWEEN $${paramIndex} AND $${paramIndex + 1}`);
-                            params.push(min, max);
-                            paramIndex += 2;
-                            break;
-                        case '$contains':
-                            // Use ANY() for checking if array contains a scalar value
-                            // This works for both native PostgreSQL arrays and JSONB arrays
-                            if (!Array.isArray(opValue)) {
-                                clauses.push(`$${paramIndex} = ANY(${fieldRef})`);
-                                params.push(opValue);
-                            }
-                            else {
-                                // For array values, check if all values are contained
-                                clauses.push(`${fieldRef} @> $${paramIndex}`);
-                                params.push(opValue);
-                            }
-                            paramIndex++;
-                            break;
-                        case '$containedby':
-                        case '$contained_by':
-                            clauses.push(`${fieldRef} <@ $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$overlaps':
-                            clauses.push(`${fieldRef} && $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$regex':
-                            clauses.push(`${fieldRef} ~ $${paramIndex}`);
-                            params.push(opValue);
-                            paramIndex++;
-                            break;
-                        case '$exists':
-                            clauses.push(`${fieldRef} IS ${opValue ? 'NOT NULL' : 'NULL'}`);
-                            break;
-                    }
-                }
-            }
-            else {
-                // Simple equality - use formatFieldRef to support JSON path notation
-                clauses.push(`${this.formatFieldRef(key)} = $${paramIndex}`);
-                params.push(value);
-                paramIndex++;
-            }
-        }
-        return {
-            whereClause: clauses.join(' AND '),
-            whereParams: params,
-        };
-    }
-    buildCountQuery(query) {
-        // Build a COUNT query from the original query
-        const fromIndex = query.sql.toUpperCase().indexOf('FROM');
-        const orderByIndex = query.sql.toUpperCase().indexOf('ORDER BY');
-        const limitIndex = query.sql.toUpperCase().indexOf('LIMIT');
-        let endIndex = query.sql.length;
-        if (orderByIndex > 0)
-            endIndex = Math.min(endIndex, orderByIndex);
-        if (limitIndex > 0)
-            endIndex = Math.min(endIndex, limitIndex);
-        return `SELECT COUNT(*) as count ${query.sql.substring(fromIndex, endIndex)}`;
-    }
-    buildColumnDefinition(column) {
-        let def = `${this.escapeIdentifier(column.name)} ${this.getColumnTypeString(column.type, column)}`;
-        if (column.primaryKey) {
-            def += ' PRIMARY KEY';
-        }
-        if (column.autoIncrement) {
-            // PostgreSQL uses SERIAL/BIGSERIAL
-            def = `${this.escapeIdentifier(column.name)} ${column.type === enums_1.ColumnType.BIGINT ? 'BIGSERIAL' : 'SERIAL'} PRIMARY KEY`;
-            return def;
-        }
-        if (column.nullable === false) {
-            def += ' NOT NULL';
-        }
-        if (column.unique) {
-            def += ' UNIQUE';
-        }
-        if (column.defaultValue !== undefined) {
-            def += ` DEFAULT ${this.escapeValue(column.defaultValue)}`;
-        }
-        if (column.references) {
-            def += ` REFERENCES ${this.escapeIdentifier(column.references.table)}(${this.escapeIdentifier(column.references.column)})`;
-            if (column.references.onDelete) {
-                def += ` ON DELETE ${column.references.onDelete}`;
-            }
-            if (column.references.onUpdate) {
-                def += ` ON UPDATE ${column.references.onUpdate}`;
-            }
-        }
-        // Handle ENUM type with CHECK constraint
-        if (column.type === enums_1.ColumnType.ENUM && column.enumValues && column.enumValues.length > 0) {
-            const escapedValues = column.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(', ');
-            def += ` CHECK (${this.escapeIdentifier(column.name)} IN (${escapedValues}))`;
-        }
-        // Handle custom check constraint (but don't duplicate if we just added one for ENUM)
-        if (column.check && column.type !== enums_1.ColumnType.ENUM) {
-            def += ` CHECK (${column.check})`;
-        }
-        else if (column.check && column.type === enums_1.ColumnType.ENUM) {
-            // If ENUM has custom check, combine them
-            def = def.replace(/\)$/, ` AND ${column.check})`);
-        }
-        return def;
-    }
-    buildConstraintDefinition(constraint) {
-        let def = `CONSTRAINT ${this.escapeIdentifier(constraint.name)}`;
-        switch (constraint.type) {
-            case 'PRIMARY_KEY':
-                def += ` PRIMARY KEY (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
-                break;
-            case 'UNIQUE':
-                def += ` UNIQUE (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
-                break;
-            case 'FOREIGN_KEY':
-                def += ` FOREIGN KEY (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
-                def += ` REFERENCES ${this.escapeIdentifier(constraint.references.table)}(${this.escapeIdentifier(constraint.references.column)})`;
-                if (constraint.references.onDelete) {
-                    def += ` ON DELETE ${constraint.references.onDelete}`;
-                }
-                if (constraint.references.onUpdate) {
-                    def += ` ON UPDATE ${constraint.references.onUpdate}`;
-                }
-                break;
-            case 'CHECK':
-                def += ` CHECK (${constraint.expression})`;
-                break;
-        }
-        return def;
-    }
-    mapIsolationLevel(level) {
-        switch (level) {
-            case enums_1.IsolationLevel.READ_UNCOMMITTED:
-                return 'READ UNCOMMITTED';
-            case enums_1.IsolationLevel.READ_COMMITTED:
-                return 'READ COMMITTED';
-            case enums_1.IsolationLevel.REPEATABLE_READ:
-                return 'REPEATABLE READ';
-            case enums_1.IsolationLevel.SERIALIZABLE:
-                return 'SERIALIZABLE';
-            default:
-                return 'READ COMMITTED';
-        }
-    }
-}
-exports.PostgreSQLAdapter = PostgreSQLAdapter;
-//# sourceMappingURL=postgresql.adapter.js.map