@warlock.js/cascade 4.0.162 → 4.0.164

package/cjs/drivers/postgres/postgres-driver.js

@@ -0,0 +1,1010 @@
+'use strict';var copper=require('@mongez/copper'),logger=require('@warlock.js/logger'),databaseTransactionContext=require('../../context/database-transaction-context.js'),transactionRollback_error=require('../../errors/transaction-rollback.error.js'),sqlDatabaseDirtyTracker=require('../../sql-database-dirty-tracker.js'),isValidDateValue=require('../../utils/is-valid-date-value.js'),postgresBlueprint=require('./postgres-blueprint.js'),postgresDialect=require('./postgres-dialect.js'),postgresMigrationDriver=require('./postgres-migration-driver.js'),postgresQueryBuilder=require('./postgres-query-builder.js'),postgresSqlSerializer=require('./postgres-sql-serializer.js'),postgresSyncAdapter=require('./postgres-sync-adapter.js');function _interopNamespace(e){if(e&&e.__esModule)return e;var n=Object.create(null);if(e){Object.keys(e).forEach(function(k){if(k!=='default'){var d=Object.getOwnPropertyDescriptor(e,k);Object.defineProperty(n,k,d.get?d:{enumerable:true,get:function(){return e[k]}});}})}n.default=e;return Object.freeze(n)}/**
+ * PostgreSQL Driver
+ *
+ * Main driver implementation for PostgreSQL database operations.
+ * Implements the DriverContract interface to provide a unified API
+ * for CRUD operations, transactions, and query building.
+ *
+ * Uses the `pg` package for database connectivity with connection pooling.
+ *
+ * @module cascade/drivers/postgres
+ */
+/**
+ * Cached pg module reference.
+ */
+let pgModule;
+/**
+ * Lazily load the pg package.
+ *
+ * @returns The pg module
+ * @throws Error if pg is not installed
+ */
+async function loadPg() {
+    if (pgModule) {
+        return pgModule;
+    }
+    try {
+        pgModule = await Promise.resolve().then(function(){return /*#__PURE__*/_interopNamespace(require('pg'))});
+        return pgModule;
+    }
+    catch {
+        throw new Error('The "pg" package is required for PostgreSQL support. ' + "Please install it: npm install pg");
+    }
+}
+/**
+ * PostgreSQL database driver implementing the Cascade DriverContract.
+ *
+ * Provides connection pooling, CRUD operations, transactions, and
+ * integration with Cascade's query builder and migration systems.
+ *
+ * @example
+ * ```typescript
+ * const driver = new PostgresDriver({
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'myapp',
+ *   user: 'postgres',
+ *   password: 'secret'
+ * });
+ *
+ * await driver.connect();
+ *
+ * // Insert a document
+ * const result = await driver.insert('users', { name: 'Alice', email: 'alice@example.com' });
+ *
+ * // Query using the query builder
+ * const users = await driver.queryBuilder('users')
+ *   .where('name', 'Alice')
+ *   .get();
+ *
+ * await driver.disconnect();
+ * ```
+ */
+class PostgresDriver {
+    config;
+    /**
+     * Driver name identifier.
+     */
+    name = "postgres";
+    /**
+     * SQL dialect for PostgreSQL-specific syntax.
+     */
+    dialect = new postgresDialect.PostgresDialect();
+    /**
+     * PostgreSQL driver model defaults.
+     *
+     * PostgreSQL follows SQL conventions:
+     * - snake_case naming for columns (created_at, updated_at, deleted_at)
+     * - Native AUTO_INCREMENT for IDs (no manual generation)
+     * - Timestamps enabled by default
+     * - Permanent delete strategy (hard deletes)
+     */
+    modelDefaults = {
+        namingConvention: "snake_case",
+        createdAtColumn: "created_at",
+        updatedAtColumn: "updated_at",
+        deletedAtColumn: "deleted_at",
+        timestamps: true,
+        autoGenerateId: false,
+        strictMode: "fail",
+        deleteStrategy: "permanent",
+    };
+    /**
+     * Connection pool instance.
+     */
+    _pool;
+    /**
+     * Event listeners for driver lifecycle events.
+     */
+    _eventListeners = new Map();
+    /**
+     * Whether the driver is currently connected.
+     */
+    _isConnected = false;
+    /**
+     * Blueprint instance (lazy-loaded).
+     */
+    _blueprint;
+    /**
+     * Migration driver instance (lazy-loaded).
+     */
+    _migrationDriver;
+    /**
+     * Sync adapter instance (lazy-loaded).
+     */
+    _syncAdapter;
+    /**
+     * Create a new PostgreSQL driver instance.
+     *
+     * @param config - PostgreSQL connection configuration
+     */
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Get the connection pool instance.
+     *
+     * @throws Error if not connected
+     */
+    get pool() {
+        if (!this._pool) {
+            throw new Error("PostgreSQL driver is not connected. Call connect() first.");
+        }
+        return this._pool;
+    }
+    /**
+     * Get database native client
+     */
+    getClient() {
+        return this.pool;
+    }
+    /**
+     * Check if the driver is currently connected.
+     */
+    get isConnected() {
+        return this._isConnected;
+    }
+    /**
+     * Get the driver blueprint (information schema).
+     */
+    get blueprint() {
+        if (!this._blueprint) {
+            this._blueprint = new postgresBlueprint.PostgresBlueprint(this);
+        }
+        return this._blueprint;
+    }
+    /**
+     * Establish connection to the PostgreSQL database.
+     *
+     * Creates a connection pool with the configured options.
+     * Emits 'connected' event on successful connection.
+     */
+    async connect() {
+        if (this._isConnected) {
+            return;
+        }
+        const pg = await loadPg();
+        try {
+            const poolConfig = {
+                host: this.config.host ?? "localhost",
+                port: this.config.port ?? 5432,
+                database: this.config.database,
+                user: this.config.user,
+                password: this.config.password,
+                connectionString: this.config.connectionString,
+                max: this.config.max ?? 10,
+                min: this.config.min ?? 0,
+                idleTimeoutMillis: this.config.idleTimeoutMillis ?? 30000,
+                connectionTimeoutMillis: this.config.connectionTimeoutMillis ?? 2000,
+                application_name: this.config.application_name ?? "cascade",
+                ssl: this.config.ssl,
+            };
+            logger.log.info("database.postgres", "connection", `Connecting to database ${copper.colors.bold(copper.colors.yellowBright(this.config.database))}`);
+            this._pool = new pg.Pool(poolConfig);
+            // Test the connection
+            const client = await this._pool.connect();
+            client.release();
+            logger.log.success("database.postgres", "connection", `Connected to database ${copper.colors.bold(copper.colors.yellowBright(this.config.database))}`);
+            this._isConnected = true;
+            this.emit("connected");
+        }
+        catch (error) {
+            logger.log.error("database.postgres", "connection", "Failed to connect to database");
+            throw error;
+        }
+    }
+    /**
+     * Close the database connection pool.
+     *
+     * Waits for all active queries to complete before closing.
+     * Emits 'disconnected' event on successful disconnection.
+     */
+    async disconnect() {
+        if (!this._isConnected || !this._pool) {
+            return;
+        }
+        await this._pool.end();
+        this._pool = undefined;
+        this._isConnected = false;
+        this.emit("disconnected");
+    }
+    /**
+     * Register an event listener for driver lifecycle events.
+     *
+     * @param event - Event name ('connected', 'disconnected', etc.)
+     * @param listener - Callback function to invoke
+     */
+    on(event, listener) {
+        if (!this._eventListeners.has(event)) {
+            this._eventListeners.set(event, new Set());
+        }
+        this._eventListeners.get(event).add(listener);
+    }
+    /**
+     * Serialize data for storage in PostgreSQL.
+     *
+     * Handles Date objects, BigInt, and other JavaScript types
+     * that need special handling for PostgreSQL storage.
+     *
+     * @param data - The data object to serialize
+     * @returns Serialized data ready for PostgreSQL
+     */
+    serialize(data) {
+        const serialized = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined) {
+                continue; // Skip undefined values
+            }
+            if (value instanceof Date) {
+                serialized[key] = value.toISOString();
+            }
+            else if (typeof value === "bigint") {
+                serialized[key] = value.toString();
+            }
+            else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                // Nested objects will be stored as JSONB
+                serialized[key] = value;
+            }
+            else if (Array.isArray(value) &&
+                value.length > 0 &&
+                value.every((v) => typeof v === "number")) {
+                // pgvector columns expect the literal '[n1,n2,...]' format.
+                // If we pass a raw JS number[] the pg driver serializes it as a
+                // PostgreSQL array '{n1,n2,...}' which the vector type rejects.
+                serialized[key] = `[${value.join(",")}]`;
+            }
+            else {
+                serialized[key] = value;
+            }
+        }
+        return serialized;
+    }
+    /**
+     * Get the dirty tracker for this driver.
+     */
+    getDirtyTracker(data) {
+        return new sqlDatabaseDirtyTracker.SqlDatabaseDirtyTracker(data);
+    }
+    /**
+     * Deserialize data retrieved from PostgreSQL.
+     *
+     * Converts PostgreSQL types back to JavaScript equivalents.
+     *
+     * @param data - The data object from PostgreSQL
+     * @returns Deserialized JavaScript object
+     */
+    deserialize(data) {
+        // PostgreSQL pg driver handles most type conversions automatically
+        // Special handling can be added here if needed
+        for (const [key, value] of Object.entries(data)) {
+            // Only re-inflate strings — pg already returns Date objects from DB reads
+            if (typeof value !== "string")
+                continue;
+            if (isValidDateValue.isValidDateValue(value)) {
+                data[key] = new Date(value);
+                continue;
+            }
+            // pgvector columns are returned as '[n1,n2,...]' strings.
+            // charCodeAt is faster than startsWith/endsWith — no string allocation.
+            // '[' = 91, ']' = 93
+            if (value.charCodeAt(0) === 91 && value.charCodeAt(value.length - 1) === 93) {
+                const parts = value.slice(1, -1).split(",");
+                const nums = new Array(parts.length);
+                let isNumericVector = parts.length > 0;
+                for (let i = 0; i < parts.length; i++) {
+                    const n = +parts[i]; // unary + is the fastest string-to-number coercion
+                    if (!Number.isFinite(n)) {
+                        isNumericVector = false;
+                        break; // early-exit — not a numeric vector, leave value untouched
+                    }
+                    nums[i] = n;
+                }
+                if (isNumericVector) {
+                    data[key] = nums;
+                }
+            }
+        }
+        return data;
+    }
+    /**
+     * Insert a single row into a table.
+     *
+     * Uses INSERT ... RETURNING to get the inserted row with generated values.
+     *
+     * @param table - Target table name
+     * @param document - Data to insert
+     * @param options - Optional insertion options
+     * @returns The inserted document
+     */
+    async insert(table, document, _options) {
+        const serialized = this.serialize(document);
+        // Filter out id if null/undefined to let PostgreSQL SERIAL auto-generate
+        const filteredData = Object.fromEntries(Object.entries(serialized).filter(([key, value]) => {
+            // Exclude id if null/undefined (let SERIAL handle it)
+            if (key === "id" && (value === null || value === undefined)) {
+                return false;
+            }
+            return true;
+        }));
+        const columns = Object.keys(filteredData);
+        const values = Object.values(filteredData);
+        if (columns.length === 0) {
+            throw new Error("Cannot insert empty document");
+        }
+        const quotedColumns = columns.map((c) => this.dialect.quoteIdentifier(c)).join(", ");
+        const placeholders = columns.map((_, i) => this.dialect.placeholder(i + 1)).join(", ");
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        const sql = `INSERT INTO ${quotedTable} (${quotedColumns}) VALUES (${placeholders}) RETURNING *`;
+        const result = await this.query(sql, values);
+        return {
+            document: result.rows[0],
+        };
+    }
+    /**
+     * Insert multiple rows into a table.
+     *
+     * Uses a single INSERT statement with multiple value sets for efficiency.
+     *
+     * @param table - Target table name
+     * @param documents - Array of documents to insert
+     * @param options - Optional insertion options
+     * @returns Array of inserted documents
+     */
+    async insertMany(table, documents, _options) {
+        if (documents.length === 0) {
+            return [];
+        }
+        // Get all unique columns across all documents
+        const allColumns = new Set();
+        for (const doc of documents) {
+            const serialized = this.serialize(doc);
+            Object.keys(serialized).forEach((key) => allColumns.add(key));
+        }
+        const columns = Array.from(allColumns);
+        const quotedColumns = columns.map((c) => this.dialect.quoteIdentifier(c)).join(", ");
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        // Build value sets and params
+        const valueSets = [];
+        const params = [];
+        let paramIndex = 1;
+        for (const doc of documents) {
+            const serialized = this.serialize(doc);
+            const rowPlaceholders = [];
+            for (const col of columns) {
+                if (col in serialized) {
+                    rowPlaceholders.push(this.dialect.placeholder(paramIndex++));
+                    params.push(serialized[col]);
+                }
+                else {
+                    rowPlaceholders.push("DEFAULT");
+                }
+            }
+            valueSets.push(`(${rowPlaceholders.join(", ")})`);
+        }
+        const sql = `INSERT INTO ${quotedTable} (${quotedColumns}) VALUES ${valueSets.join(", ")} RETURNING *`;
+        const result = await this.query(sql, params);
+        return result.rows;
+    }
+    /**
+     * Update a single row matching the filter.
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param update - Update operations ($set, $unset, $inc)
+     * @param options - Optional update options
+     * @returns Update result with modified count
+     */
+    async update(table, filter, update, _options) {
+        const { sql, params } = this.buildUpdateQuery(table, filter, update, 1);
+        try {
+            const result = await this.query(sql, params);
+            return {
+                modifiedCount: result.rowCount ?? 0,
+            };
+        }
+        catch (error) {
+            console.log("PG Query Error in:", sql, params);
+            throw error;
+        }
+    }
+    /**
+     * Find one and update a single row matching the filter and return the updated row
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param update - Update operations ($set, $unset, $inc)
+     * @param options - Optional update options
+     * @returns The updated row or null
+     */
+    async findOneAndUpdate(table, filter, update, _options) {
+        const { sql, params } = this.buildUpdateQuery(table, filter, update, 1);
+        // Add RETURNING * to get the updated row back
+        const sqlWithReturning = `${sql} RETURNING *`;
+        const result = await this.query(sqlWithReturning, params);
+        return result.rows[0] ?? null;
+    }
+    /**
+     * Update multiple rows matching the filter.
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param update - Update operations
+     * @param options - Optional update options
+     * @returns Update result with modified count
+     */
+    async updateMany(table, filter, update, _options) {
+        const { sql, params } = this.buildUpdateQuery(table, filter, update);
+        const result = await this.query(sql, params);
+        return {
+            modifiedCount: result.rowCount ?? 0,
+        };
+    }
+    /**
+     * Replace a document matching the filter.
+     *
+     * Completely replaces the document (not a partial update).
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param document - New document data
+     * @param options - Optional options
+     * @returns The replaced document or null
+     */
+    async replace(table, filter, document, _options) {
+        const serialized = this.serialize(document);
+        const columns = Object.keys(serialized);
+        const values = Object.values(serialized);
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        const setClauses = columns
+            .map((col, i) => `${this.dialect.quoteIdentifier(col)} = ${this.dialect.placeholder(i + 1)}`)
+            .join(", ");
+        const { whereClause, whereParams } = this.buildWhereClause(filter, columns.length + 1);
+        const sql = `UPDATE ${quotedTable} SET ${setClauses} ${whereClause} RETURNING *`;
+        const params = [...values, ...whereParams];
+        const result = await this.query(sql, params);
+        return result.rows[0] ?? null;
+    }
+    /**
+     * Upsert (insert or update) a single row.
+     *
+     * Uses PostgreSQL's INSERT ... ON CONFLICT ... DO UPDATE syntax.
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions to find existing row (used for conflict detection)
+     * @param document - Document data to insert or update
+     * @param options - Upsert options (conflictColumns for conflict target)
+     * @returns The upserted row
+     */
+    async upsert(table, filter, document, options) {
+        const serialized = this.serialize(document);
+        const columns = Object.keys(serialized);
+        const values = Object.values(serialized);
+        if (columns.length === 0) {
+            throw new Error("Cannot upsert empty document");
+        }
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        const quotedColumns = columns.map((c) => this.dialect.quoteIdentifier(c)).join(", ");
+        const placeholders = columns.map((_, i) => this.dialect.placeholder(i + 1)).join(", ");
+        // Determine conflict columns from options or filter
+        const conflictColumns = options?.conflictColumns ?? Object.keys(filter);
+        if (conflictColumns.length === 0) {
+            throw new Error("Upsert requires conflictColumns option or filter with columns");
+        }
+        const quotedConflictColumns = conflictColumns
+            .map((c) => this.dialect.quoteIdentifier(c))
+            .join(", ");
+        // Build UPDATE clause for ON CONFLICT
+        // Update all columns except the conflict columns (they stay the same)
+        const updateColumns = columns.filter((col) => !conflictColumns.includes(col));
+        const setClauses = updateColumns
+            .map((col, i) => {
+            const valueIndex = columns.indexOf(col) + 1;
+            return `${this.dialect.quoteIdentifier(col)} = ${this.dialect.placeholder(valueIndex)}`;
+        })
+            .join(", ");
+        // If there are no columns to update (all columns are conflict columns), use EXCLUDED
+        const updateClause = setClauses.length > 0
+            ? setClauses
+            : columns
+                .map((col) => `${this.dialect.quoteIdentifier(col)} = EXCLUDED.${this.dialect.quoteIdentifier(col)}`)
+                .join(", ");
+        const sql = `INSERT INTO ${quotedTable} (${quotedColumns}) VALUES (${placeholders}) ON CONFLICT (${quotedConflictColumns}) DO UPDATE SET ${updateClause} RETURNING *`;
+        const result = await this.query(sql, values);
+        return result.rows[0];
+    }
+    /**
+     * Find one and delete a single row matching the filter and return the deleted row.
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param options - Optional delete options
+     * @returns The deleted row or null
+     */
+    async findOneAndDelete(table, filter, _options) {
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        const { whereClause, whereParams } = this.buildWhereClause(filter, 1);
+        // Use ctid for single row deletion with RETURNING
+        const sql = `DELETE FROM ${quotedTable} WHERE ctid IN (SELECT ctid FROM ${quotedTable} ${whereClause} LIMIT 1) RETURNING *`;
+        const result = await this.query(sql, whereParams);
+        return result.rows[0] ? result.rows[0] : null;
+    }
+    /**
+     * Delete a single row matching the filter.
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param options - Optional options
+     * @returns Number of deleted rows (0 or 1)
+     */
+    async delete(table, filter, _options) {
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        const { whereClause, whereParams } = this.buildWhereClause(filter ?? {}, 1);
+        // Use ctid for single row deletion
+        const sql = `DELETE FROM ${quotedTable} WHERE ctid IN (SELECT ctid FROM ${quotedTable} ${whereClause} LIMIT 1)`;
+        const result = await this.query(sql, whereParams);
+        return result.rowCount ?? 0;
+    }
+    /**
+     * Delete multiple rows matching the filter.
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param options - Optional options
+     * @returns Number of deleted rows
+     */
+    async deleteMany(table, filter, _options) {
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        const { whereClause, whereParams } = this.buildWhereClause(filter ?? {}, 1);
+        const sql = `DELETE FROM ${quotedTable} ${whereClause}`;
+        const result = await this.query(sql, whereParams);
+        return result.rowCount ?? 0;
+    }
+    /**
+     * Truncate a table (remove all rows).
+     *
+     * Uses TRUNCATE TABLE for fast deletion with RESTART IDENTITY.
+     *
+     * @param table - Target table name
+     * @param options - Optional options
+     * @param options.cascade - If true, automatically truncate all tables with foreign key references (use with caution)
+     * @returns Number of deleted rows (always 0 for TRUNCATE)
+     */
+    async truncateTable(table, options) {
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        const cascadeClause = options?.cascade ? " CASCADE" : "";
+        await this.query(`TRUNCATE TABLE ${quotedTable} RESTART IDENTITY${cascadeClause}`);
+        return 0; // TRUNCATE doesn't return row count
+    }
+    /**
+     * Get a query builder for the specified table.
+     *
+     * @param table - Target table name
+     * @returns Query builder instance
+     */
+    queryBuilder(table) {
+        return new postgresQueryBuilder.PostgresQueryBuilder(table);
+    }
+    /**
+     * Begin a new database transaction.
+     *
+     * Acquires a client from the pool and starts a transaction.
+     * The client is stored in AsyncLocalStorage for automatic
+     * participation by subsequent queries.
+     *
+     * @param options - Optional transaction options
+     * @returns Transaction contract with commit/rollback methods
+     */
+    async beginTransaction(options) {
+        const client = await this.pool.connect();
+        let beginSql = "BEGIN";
+        if (options?.isolationLevel) {
+            beginSql += ` ISOLATION LEVEL ${options.isolationLevel.toUpperCase()}`;
+        }
+        if (options?.readOnly) {
+            beginSql += " READ ONLY";
+        }
+        if (options?.deferrable) {
+            beginSql += " DEFERRABLE";
+        }
+        await client.query(beginSql);
+        return {
+            context: client,
+            commit: async () => {
+                await client.query("COMMIT");
+                client.release();
+            },
+            rollback: async () => {
+                await client.query("ROLLBACK");
+                client.release();
+            },
+        };
+    }
+    /**
+     * Execute a function within a transaction scope (recommended pattern).
+     *
+     * Automatically commits on success, rolls back on any error, and guarantees
+     * resource cleanup. This is the recommended way to use transactions.
+     *
+     * @param fn - Async function to execute within transaction
+     * @param options - Transaction options (isolation level, read-only, etc.)
+     * @returns The return value of the callback function
+     * @throws {Error} If transaction fails or is explicitly rolled back
+     */
+    async transaction(fn, options) {
+        // Prevent nested transaction() calls
+        if (databaseTransactionContext.databaseTransactionContext.hasActiveTransaction()) ;
+        const tx = await this.beginTransaction(options);
+        // Set transaction context for queries within callback
+        databaseTransactionContext.databaseTransactionContext.enter({ session: tx.context });
+        try {
+            // Create transaction context with rollback method
+            const ctx = {
+                rollback(reason) {
+                    throw new transactionRollback_error.TransactionRollbackError(reason);
+                },
+            };
+            // Execute callback
+            const result = await fn(ctx);
+            // Auto-commit on success
+            await tx.commit();
+            return result;
+        }
+        catch (error) {
+            // Auto-rollback on any error (including explicit rollback)
+            await tx.rollback();
+            logger.logger.error(`database.postgress`, "transaction", "Transaction operation failed, rolled back everything");
+            throw error;
+        }
+        finally {
+            // Guaranteed cleanup
+            databaseTransactionContext.databaseTransactionContext.exit();
+        }
+    }
+    /**
+     * Perform an atomic update operation.
+     *
+     * Uses PostgreSQL's row-level locking for atomicity.
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param operations - Update operations
+     * @param options - Optional options
+     * @returns Update result
+     */
+    async atomic(table, filter, operations, _options) {
+        // For PostgreSQL, we use SELECT FOR UPDATE to lock the row
+        // then perform the update
+        const { sql, params } = this.buildUpdateQuery(table, filter, operations, 1);
+        const result = await this.query(sql, params);
+        return {
+            modifiedCount: result.rowCount ?? 0,
+        };
+    }
+    /**
+     * Get the sync adapter for bulk denormalized updates.
+     *
+     * @returns Sync adapter instance
+     */
+    syncAdapter() {
+        if (!this._syncAdapter) {
+            this._syncAdapter = new postgresSyncAdapter.PostgresSyncAdapter(this);
+        }
+        return this._syncAdapter;
+    }
+    /**
+     * Get the migration driver for schema operations.
+     *
+     * @returns Migration driver instance
+     */
+    migrationDriver() {
+        if (!this._migrationDriver) {
+            this._migrationDriver = new postgresMigrationDriver.PostgresMigrationDriver(this);
+        }
+        return this._migrationDriver;
+    }
+    /**
+     * Return a SQL serializer for this driver's dialect.
+     * Used by Migration.toSQL() to convert pending operations to SQL strings.
+     */
+    getSQLSerializer() {
+        return new postgresSqlSerializer.PostgresSQLSerializer(this.dialect);
+    }
+    /**
+     * Execute a raw SQL query.
+     *
+     * Automatically uses the transaction client if one is active.
+     *
+     * @param sql - SQL query string
+     * @param params - Query parameters
+     * @returns Query result
+     */
+    async query(sql, params = []) {
+        // Check for active transaction client
+        const txClient = databaseTransactionContext.databaseTransactionContext.getSession();
+        const startTime = this.config.logging ? performance.now() : 0;
+        let paramsString = "";
+        if (this.config.logging && params.length > 0) {
+            paramsString = JSON.stringify(params);
+            if (paramsString.length > 300) {
+                paramsString = paramsString.substring(0, 300) + '...';
+            }
+            paramsString = ` | Params: ${paramsString}`;
+        }
+        try {
+            let result;
+            if (this.config.logging) {
+                logger.log.info({
+                    module: "database.postgres",
+                    action: "query.executing",
+                    message: `${sql}${paramsString}`,
+                    context: { params, sql },
+                });
+            }
+            if (txClient) {
+                result = await txClient.query(sql, params);
+            }
+            else {
+                result = await this.pool.query(sql, params);
+            }
+            if (this.config.logging) {
+                const duration = (performance.now() - startTime).toFixed(2);
+                logger.log.success({
+                    module: "database.postgres",
+                    action: "query.executed",
+                    message: `[${duration}ms] ${sql}${paramsString}`,
+                    context: { params, sql, duration },
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            if (this.config.logging) {
+                const duration = (performance.now() - startTime).toFixed(2);
+                logger.log.error({
+                    module: "database.postgres",
+                    action: "query.error",
+                    message: `[${duration}ms] ${sql}${paramsString}`,
+                    context: {
+                        sql,
+                        params,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Emit an event to all registered listeners.
+     *
+     * @param event - Event name
+     * @param args - Event arguments
+     */
+    emit(event, ...args) {
+        const listeners = this._eventListeners.get(event);
+        if (listeners) {
+            for (const listener of listeners) {
+                listener(...args);
+            }
+        }
+    }
+    /**
+     * Build a simple WHERE clause from a filter object.
+     *
+     * @param filter - Filter conditions
+     * @param startParamIndex - Starting parameter index
+     * @returns Object with WHERE clause string and parameters
+     */
+    buildWhereClause(filter, startParamIndex) {
+        const conditions = [];
+        const params = [];
+        let paramIndex = startParamIndex;
+        for (const [key, value] of Object.entries(filter)) {
+            const quotedKey = this.dialect.quoteIdentifier(key);
+            if (value === null) {
+                conditions.push(`${quotedKey} IS NULL`);
+            }
+            else {
+                conditions.push(`${quotedKey} = ${this.dialect.placeholder(paramIndex++)}`);
+                params.push(value);
+            }
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        return { whereClause, whereParams: params };
+    }
+    /**
+     * Build an UPDATE query from update operations.
+     *
+     * @param table - Target table name
+     * @param filter - Filter conditions
+     * @param update - Update operations
+     * @param limit - Optional limit (for single row update)
+     * @returns Object with SQL and parameters
+     */
+    buildUpdateQuery(table, filter, update, limit) {
+        const setClauses = [];
+        const params = [];
+        let paramIndex = 1;
+        // Handle $set
+        if (update.$set) {
+            for (const [key, value] of Object.entries(update.$set)) {
+                setClauses.push(`${this.dialect.quoteIdentifier(key)} = ${this.dialect.placeholder(paramIndex++)}`);
+                params.push(value);
+            }
+        }
+        // Handle $unset (set to NULL)
+        if (update.$unset) {
+            for (const key of Object.keys(update.$unset)) {
+                setClauses.push(`${this.dialect.quoteIdentifier(key)} = NULL`);
+            }
+        }
+        // Handle $inc
+        if (update.$inc) {
+            for (const [key, amount] of Object.entries(update.$inc)) {
+                const quotedKey = this.dialect.quoteIdentifier(key);
+                setClauses.push(`${quotedKey} = COALESCE(${quotedKey}, 0) + ${this.dialect.placeholder(paramIndex++)}`);
+                params.push(amount);
+            }
+        }
+        // Handle $dec
+        if (update.$dec) {
+            for (const [key, amount] of Object.entries(update.$dec)) {
+                const quotedKey = this.dialect.quoteIdentifier(key);
+                setClauses.push(`${quotedKey} = COALESCE(${quotedKey}, 0) - ${this.dialect.placeholder(paramIndex++)}`);
+                params.push(amount);
+            }
+        }
+        if (setClauses.length === 0) {
+            throw new Error("No update operations specified");
+        }
+        const quotedTable = this.dialect.quoteIdentifier(table);
+        const { whereClause, whereParams } = this.buildWhereClause(filter, paramIndex);
+        params.push(...whereParams);
+        let sql = `UPDATE ${quotedTable} SET ${setClauses.join(", ")} ${whereClause}`;
+        // For single row update, use ctid subquery
+        if (limit === 1 && whereClause) {
+            sql = `UPDATE ${quotedTable} SET ${setClauses.join(", ")} WHERE ctid IN (SELECT ctid FROM ${quotedTable} ${whereClause} LIMIT 1)`;
+        }
+        return { sql, params };
+    }
+    // ============================================================
+    // Database Lifecycle Operations
+    // ============================================================
+    /**
+     * Create a new database.
+     *
+     * Note: This requires connecting to a system database (like 'postgres')
+     * since you cannot create a database while connected to it.
+     *
+     * @param name - Database name to create
+     * @param options - Creation options (encoding, template, etc.)
+     * @returns true if created, false if already exists
+     */
+    async createDatabase(name, options) {
+        // Check if database already exists
+        if (await this.databaseExists(name)) {
+            return false;
+        }
+        // Build CREATE DATABASE statement
+        const quotedName = this.dialect.quoteIdentifier(name);
+        let sql = `CREATE DATABASE ${quotedName}`;
+        const withClauses = [];
+        if (options?.encoding) {
+            withClauses.push(`ENCODING = '${options.encoding}'`);
+        }
+        if (options?.template) {
+            withClauses.push(`TEMPLATE = ${this.dialect.quoteIdentifier(options.template)}`);
+        }
+        if (options?.locale) {
+            withClauses.push(`LC_COLLATE = '${options.locale}'`);
+            withClauses.push(`LC_CTYPE = '${options.locale}'`);
+        }
+        if (options?.owner) {
+            withClauses.push(`OWNER = ${this.dialect.quoteIdentifier(options.owner)}`);
+        }
+        if (withClauses.length > 0) {
+            sql += ` WITH ${withClauses.join(" ")}`;
+        }
+        try {
+            await this.query(sql);
+            logger.log.success("database", "lifecycle", `Created database ${name}`);
+            return true;
+        }
+        catch (error) {
+            logger.log.error("database", "lifecycle", `Failed to create database ${name}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Drop a database.
+     *
+     * @param name - Database name to drop
+     * @param options - Drop options
+     * @returns true if dropped, false if didn't exist
+     */
+    async dropDatabase(name, options) {
+        // Check if database exists first (if ifExists option not set)
+        if (!options?.ifExists && !(await this.databaseExists(name))) {
+            return false;
+        }
+        const quotedName = this.dialect.quoteIdentifier(name);
+        let sql = "DROP DATABASE";
+        if (options?.ifExists) {
+            sql += " IF EXISTS";
+        }
+        sql += ` ${quotedName}`;
+        // PostgreSQL 13+ supports WITH (FORCE) to terminate active connections
+        if (options?.force) {
+            sql += " WITH (FORCE)";
+        }
+        try {
+            await this.query(sql);
+            logger.log.success("database", "lifecycle", `Dropped database ${name}`);
+            return true;
+        }
+        catch (error) {
+            logger.log.error("database", "lifecycle", `Failed to drop database ${name}: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Check if a database exists.
+     *
+     * @param name - Database name to check
+     * @returns true if database exists
+     */
+    async databaseExists(name) {
+        const result = await this.query(`SELECT EXISTS(SELECT 1 FROM pg_database WHERE datname = $1) as exists`, [name]);
+        return result.rows[0]?.exists ?? false;
+    }
+    /**
+     * List all databases.
+     *
+     * @returns Array of database names
+     */
+    async listDatabases() {
+        const result = await this.query(`SELECT datname FROM pg_database WHERE datistemplate = false ORDER BY datname`);
+        return result.rows.map((row) => row.datname);
+    }
+    // ============================================================
+    // Table Management Operations
+    // ============================================================
+    /**
+     * Drop a table.
+     *
+     * @param name - Table name to drop
+     * @throws Error if table doesn't exist
+     */
+    async dropTable(name) {
+        const quotedName = this.dialect.quoteIdentifier(name);
+        await this.query(`DROP TABLE ${quotedName}`);
+        logger.log.success("database", "table", `Dropped table ${name}`);
+    }
+    /**
+     * Drop a table if it exists.
+     *
+     * @param name - Table name to drop
+     */
+    async dropTableIfExists(name) {
+        const quotedName = this.dialect.quoteIdentifier(name);
+        await this.query(`DROP TABLE IF EXISTS ${quotedName}`);
+    }
+    /**
+     * Drop all tables in the current database.
+     *
+     * Uses CASCADE to handle foreign key dependencies.
+     * Useful for `migrate:fresh` command.
+     */
+    async dropAllTables() {
+        // Get all tables from blueprint
+        const tables = await this.blueprint.listTables();
+        if (tables.length === 0) {
+            return;
+        }
+        // Drop all tables with CASCADE to handle foreign keys
+        for (const table of tables) {
+            const quotedName = this.dialect.quoteIdentifier(table);
+            await this.query(`DROP TABLE IF EXISTS ${quotedName} CASCADE`);
+        }
+        logger.log.success("database", "table", `Dropped ${tables.length} tables`);
+    }
+}exports.PostgresDriver=PostgresDriver;//# sourceMappingURL=postgres-driver.js.map