@warlock.js/cascade 4.0.174 → 4.1.1

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

@@ -1,900 +0,0 @@
-'use strict';var databaseTransactionContext=require('../../context/database-transaction-context.js');/**
- * PostgreSQL Migration Driver
- *
- * Implements the MigrationDriverContract for PostgreSQL DDL operations.
- * Provides methods for creating/dropping tables, columns, indexes,
- * and constraints.
- *
- * @module cascade/drivers/postgres
- */
-/**
- * PostgreSQL Migration Driver.
- *
- * Handles database schema operations for PostgreSQL including:
- * - Table creation and deletion
- * - Column management
- * - Index creation (B-tree, GIN, GiST, etc.)
- * - Constraint management (foreign keys, unique, etc.)
- *
- * @example
- * ```typescript
- * const migrationDriver = driver.migrationDriver();
- *
- * // Create a table
- * await migrationDriver.createTable('users');
- *
- * // Add columns
- * await migrationDriver.addColumn('users', {
- *   name: 'email',
- *   type: 'string',
- *   length: 255,
- *   nullable: false
- * });
- *
- * // Create unique index
- * await migrationDriver.createUniqueIndex('users', ['email']);
- * ```
- */
-class PostgresMigrationDriver {
-    driver;
-    /**
-     * Active transaction client (if any).
-     */
-    get transactionClient() {
-        return databaseTransactionContext.databaseTransactionContext.getSession();
-    }
-    /**
-     * Create a new migration driver.
-     *
-     * @param driver - The PostgreSQL driver instance
-     */
-    constructor(driver) {
-        this.driver = driver;
-    }
-    // ============================================================================
-    // TABLE OPERATIONS
-    // ============================================================================
-    /**
-     * Create a new table with a default id column.
-     *
-     * @param table - Table name
-     */
-    async createTable(table) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        // Create empty table - columns are added via addColumn operations
-        await this.execute(`CREATE TABLE ${quotedTable} ()`);
-    }
-    /**
-     * Create table if it doesn't exist.
-     *
-     * @param table - Table name
-     */
-    async createTableIfNotExists(table) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        // Create empty table if not exists - columns are added via addColumn operations
-        await this.execute(`CREATE TABLE IF NOT EXISTS ${quotedTable} ()`);
-    }
-    /**
-     * Drop an existing table.
-     *
-     * @param table - Table name
-     */
-    async dropTable(table) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        await this.execute(`DROP TABLE ${quotedTable} CASCADE`);
-    }
-    /**
-     * Drop table if it exists.
-     *
-     * @param table - Table name
-     */
-    async dropTableIfExists(table) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        await this.execute(`DROP TABLE IF EXISTS ${quotedTable} CASCADE`);
-    }
-    /**
-     * Rename a table.
-     *
-     * @param from - Current table name
-     * @param to - New table name
-     */
-    async renameTable(from, to) {
-        const quotedFrom = this.driver.dialect.quoteIdentifier(from);
-        const quotedTo = this.driver.dialect.quoteIdentifier(to);
-        await this.execute(`ALTER TABLE ${quotedFrom} RENAME TO ${quotedTo}`);
-    }
-    /**
-     * Truncate a table — remove all rows efficiently.
-     *
-     * @param table - Table name
-     */
-    async truncateTable(table) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        await this.execute(`TRUNCATE TABLE ${quotedTable}`);
-    }
-    /**
-     * Check if a table exists.
-     *
-     * @param table - Table name
-     * @returns Whether the table exists
-     */
-    async tableExists(table) {
-        const result = await this.driver.query(`SELECT EXISTS (
-        SELECT FROM information_schema.tables
-        WHERE table_schema = 'public'
-        AND table_name = $1
-      )`, [table]);
-        return result.rows[0]?.exists ?? false;
-    }
-    /**
-     * List all columns in a table.
-     *
-     * @param table - Table name
-     * @returns Array of column definitions
-     */
-    async listColumns(table) {
-        const result = await this.driver.query(`SELECT
-        column_name,
-        data_type,
-        character_maximum_length,
-        numeric_precision,
-        numeric_scale,
-        is_nullable,
-        column_default
-      FROM information_schema.columns
-      WHERE table_schema = 'public'
-      AND table_name = $1
-      ORDER BY ordinal_position`, [table]);
-        return result.rows.map((row) => ({
-            name: row.column_name,
-            type: this.mapPostgresTypeToColumnType(row.data_type),
-            length: row.character_maximum_length ?? undefined,
-            precision: row.numeric_precision ?? undefined,
-            scale: row.numeric_scale ?? undefined,
-            nullable: row.is_nullable === "YES",
-            defaultValue: row.column_default ?? undefined,
-        }));
-    }
-    /**
-     * List all tables in the current database.
-     *
-     * @returns Array of table names
-     */
-    async listTables() {
-        const result = await this.driver.query(`SELECT table_name
-       FROM information_schema.tables
-       WHERE table_schema = 'public'
-       ORDER BY table_name`);
-        return result.rows.map((row) => row.table_name);
-    }
-    /**
-     * Ensure the migrations tracking table exists.
-     *
-     * Creates the table with proper schema if it doesn't exist.
-     *
-     * @param tableName - Name of the migrations table
-     */
-    async ensureMigrationsTable(tableName) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(tableName);
-        await this.execute(`
-      CREATE TABLE IF NOT EXISTS ${quotedTable} (
-        "id" SERIAL PRIMARY KEY,
-        "name" VARCHAR(255) NOT NULL UNIQUE,
-        "batch" INTEGER NOT NULL,
-        "executedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
-        "createdAt" TIMESTAMP WITH TIME ZONE
-      )
-    `);
-    }
-    // ============================================================================
-    // COLUMN OPERATIONS
-    // ============================================================================
-    /**
-     * Add a column to an existing table.
-     *
-     * @param table - Table name
-     * @param column - Column definition
-     */
-    async addColumn(table, column) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedColumn = this.driver.dialect.quoteIdentifier(column.name);
-        // For auto-increment integers, use SERIAL/BIGSERIAL instead of INTEGER/BIGINT
-        let sqlType;
-        if (column.autoIncrement) {
-            if (column.type === "bigInteger") {
-                sqlType = "BIGSERIAL";
-            }
-            else {
-                sqlType = "SERIAL";
-            }
-        }
-        else {
-            sqlType = this.driver.dialect.getSqlType(column.type, {
-                length: column.length,
-                precision: column.precision,
-                scale: column.scale,
-                dimensions: column.dimensions,
-            });
-        }
-        let sql = `ALTER TABLE ${quotedTable} ADD COLUMN ${quotedColumn} ${sqlType}`;
-        // Handle generated columns
-        if (column.generated) {
-            sql += ` GENERATED ALWAYS AS (${column.generated.expression})`;
-            if (column.generated.stored) {
-                sql += " STORED";
-            }
-            // PostgreSQL only supports STORED, not VIRTUAL
-            // If virtual is requested, it's simply ignored (PostgreSQL doesn't support it)
-        }
-        else {
-            // SERIAL/BIGSERIAL are always NOT NULL, so skip for those
-            if (!column.autoIncrement && column.nullable === false) {
-                sql += " NOT NULL";
-            }
-            if (column.defaultValue !== undefined) {
-                // Check for special CURRENT_TIMESTAMP marker
-                if (typeof column.defaultValue === "object" &&
-                    column.defaultValue !== null &&
-                    column.defaultValue.__type === "CURRENT_TIMESTAMP") {
-                    sql += " DEFAULT NOW()";
-                }
-                else if (column.isRawDefault === false) {
-                    // Explicit string literal - escape it properly
-                    const escaped = String(column.defaultValue).replace(/'/g, "''");
-                    sql += ` DEFAULT '${escaped}'`;
-                }
-                else if (typeof column.defaultValue === "boolean") {
-                    // Boolean values
-                    sql += ` DEFAULT ${column.defaultValue ? "TRUE" : "FALSE"}`;
-                }
-                else if (typeof column.defaultValue === "number") {
-                    // Numeric values
-                    sql += ` DEFAULT ${column.defaultValue}`;
-                }
-                else {
-                    // Raw SQL expression (default behavior when isRawDefault is true or undefined)
-                    sql += ` DEFAULT ${column.defaultValue}`;
-                }
-            }
-            // Handle primary key
-            if (column.primary) {
-                sql += " PRIMARY KEY";
-            }
-            // Handle unique constraint
-            if (column.unique) {
-                sql += " UNIQUE";
-            }
-        }
-        await this.execute(sql);
-    }
-    /**
-     * Drop a column from a table.
-     *
-     * @param table - Table name
-     * @param column - Column name
-     */
-    async dropColumn(table, column) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedColumn = this.driver.dialect.quoteIdentifier(column);
-        await this.execute(`ALTER TABLE ${quotedTable} DROP COLUMN ${quotedColumn}`);
-    }
-    /**
-     * Drop multiple columns from a table.
-     *
-     * @param table - Table name
-     * @param columns - Column names
-     */
-    async dropColumns(table, columns) {
-        for (const column of columns) {
-            await this.dropColumn(table, column);
-        }
-    }
-    /**
-     * Rename a column.
-     *
-     * @param table - Table name
-     * @param from - Current column name
-     * @param to - New column name
-     */
-    async renameColumn(table, from, to) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedFrom = this.driver.dialect.quoteIdentifier(from);
-        const quotedTo = this.driver.dialect.quoteIdentifier(to);
-        await this.execute(`ALTER TABLE ${quotedTable} RENAME COLUMN ${quotedFrom} TO ${quotedTo}`);
-    }
-    /**
-     * Modify an existing column.
-     *
-     * @param table - Table name
-     * @param column - New column definition
-     */
-    async modifyColumn(table, column) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedColumn = this.driver.dialect.quoteIdentifier(column.name);
-        const sqlType = this.driver.dialect.getSqlType(column.type, {
-            length: column.length,
-            precision: column.precision,
-            scale: column.scale,
-            dimensions: column.dimensions,
-        });
-        // PostgreSQL requires separate ALTER statements for type and nullability
-        await this.execute(`ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} TYPE ${sqlType}`);
-        if (column.nullable === false) {
-            await this.execute(`ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} SET NOT NULL`);
-        }
-        else if (column.nullable === true) {
-            await this.execute(`ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} DROP NOT NULL`);
-        }
-        if (column.defaultValue !== undefined) {
-            let defaultVal;
-            // Check for special CURRENT_TIMESTAMP marker
-            if (typeof column.defaultValue === "object" &&
-                column.defaultValue !== null &&
-                column.defaultValue.__type === "CURRENT_TIMESTAMP") {
-                defaultVal = "NOW()";
-            }
-            else if (typeof column.defaultValue === "string") {
-                defaultVal = `'${column.defaultValue}'`;
-            }
-            else {
-                defaultVal = String(column.defaultValue);
-            }
-            await this.execute(`ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedColumn} SET DEFAULT ${defaultVal}`);
-        }
-    }
-    /**
-     * Create standard timestamp columns (created_at, updated_at).
-     *
-     * PostgreSQL implementation creates TIMESTAMPTZ columns with NOW() defaults.
-     *
-     * @param table - Table name
-     */
-    async createTimestampColumns(table) {
-        await this.addColumn(table, {
-            name: "created_at",
-            type: "timestamp",
-            nullable: false,
-            defaultValue: "NOW()",
-            isRawDefault: true,
-        });
-        await this.addColumn(table, {
-            name: "updated_at",
-            type: "timestamp",
-            nullable: false,
-            defaultValue: "NOW()",
-            isRawDefault: true,
-        });
-    }
-    // ============================================================================
-    // INDEX OPERATIONS
-    // ============================================================================
-    /**
-     * Create an index on one or more columns.
-     *
-     * Supports:
-     * - Regular column indexes
-     * - Expression-based indexes (e.g., `lower(email)`)
-     * - Covering indexes (INCLUDE clause)
-     * - Concurrent index creation (CONCURRENTLY keyword)
-     *
-     * @param table - Table name
-     * @param index - Index definition
-     */
-    async createIndex(table, index) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const indexName = index.name ?? `idx_${table}_${index.columns.join("_")}`;
-        const quotedIndexName = this.driver.dialect.quoteIdentifier(indexName);
-        const uniqueKeyword = index.unique ? "UNIQUE " : "";
-        const concurrentlyKeyword = index.concurrently ? "CONCURRENTLY " : "";
-        let columnsPart;
-        // Handle expression-based indexes
-        if (index.expressions && index.expressions.length > 0) {
-            // Wrap each expression in parentheses
-            columnsPart = index.expressions.map((expr) => `(${expr})`).join(", ");
-        }
-        else {
-            // Regular column indexes
-            const columns = index.columns.map((col, i) => {
-                const quotedCol = this.driver.dialect.quoteIdentifier(col);
-                const direction = index.directions?.[i]?.toUpperCase() ?? "";
-                return direction ? `${quotedCol} ${direction}` : quotedCol;
-            });
-            columnsPart = columns.join(", ");
-        }
-        let sql = `CREATE ${uniqueKeyword}INDEX ${concurrentlyKeyword}${quotedIndexName} ON ${quotedTable} (${columnsPart})`;
-        // Add INCLUDE clause for covering indexes
-        if (index.include && index.include.length > 0) {
-            const includeCols = index.include
-                .map((col) => this.driver.dialect.quoteIdentifier(col))
-                .join(", ");
-            sql += ` INCLUDE (${includeCols})`;
-        }
-        // Add partial index condition
-        if (index.where && Object.keys(index.where).length > 0) {
-            const conditions = Object.entries(index.where)
-                .map(([key, value]) => {
-                const quotedKey = this.driver.dialect.quoteIdentifier(key);
-                return typeof value === "string"
-                    ? `${quotedKey} = '${value}'`
-                    : `${quotedKey} = ${value}`;
-            })
-                .join(" AND ");
-            sql += ` WHERE ${conditions}`;
-        }
-        await this.execute(sql);
-    }
-    /**
-     * Drop an index.
-     *
-     * @param table - Table name
-     * @param indexNameOrColumns - Index name or columns
-     */
-    async dropIndex(table, indexNameOrColumns) {
-        let indexName;
-        if (typeof indexNameOrColumns === "string") {
-            indexName = indexNameOrColumns;
-        }
-        else {
-            indexName = `idx_${table}_${indexNameOrColumns.join("_")}`;
-        }
-        const quotedIndexName = this.driver.dialect.quoteIdentifier(indexName);
-        await this.execute(`DROP INDEX IF EXISTS ${quotedIndexName}`);
-    }
-    /**
-     * Create a unique index.
-     *
-     * @param table - Table name
-     * @param columns - Columns to include
-     * @param name - Optional index name
-     */
-    async createUniqueIndex(table, columns, name) {
-        await this.createIndex(table, { columns, unique: true, name });
-    }
-    /**
-     * Drop a unique index.
-     *
-     * @param table - Table name
-     * @param columns - Columns in the index
-     */
-    async dropUniqueIndex(table, columns) {
-        await this.dropIndex(table, columns);
-    }
-    // ============================================================================
-    // SPECIALIZED INDEXES
-    // ============================================================================
-    /**
-     * Create a full-text search index using GIN.
-     *
-     * @param table - Table name
-     * @param columns - Columns to index
-     * @param options - Full-text options
-     */
-    async createFullTextIndex(table, columns, options) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const indexName = options?.name ?? `idx_${table}_fulltext_${columns.join("_")}`;
-        const quotedIndexName = this.driver.dialect.quoteIdentifier(indexName);
-        const language = options?.language ?? "english";
-        const tsvectors = columns.map((col) => {
-            const weight = options?.weights?.[col] ?? "A";
-            return `setweight(to_tsvector('${language}', COALESCE(${this.driver.dialect.quoteIdentifier(col)}, '')), '${weight}')`;
-        });
-        await this.execute(`CREATE INDEX ${quotedIndexName} ON ${quotedTable} USING GIN ((${tsvectors.join(" || ")}))`);
-    }
-    /**
-     * Drop a full-text search index.
-     *
-     * @param table - Table name
-     * @param name - Index name
-     */
-    async dropFullTextIndex(table, name) {
-        await this.dropIndex(table, name);
-    }
-    /**
-     * Create a geo-spatial index using GiST.
-     *
-     * @param table - Table name
-     * @param column - Geo column
-     * @param options - Geo index options
-     */
-    async createGeoIndex(table, column, options) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedColumn = this.driver.dialect.quoteIdentifier(column);
-        const indexName = options?.name ?? `idx_${table}_geo_${column}`;
-        const quotedIndexName = this.driver.dialect.quoteIdentifier(indexName);
-        await this.execute(`CREATE INDEX ${quotedIndexName} ON ${quotedTable} USING GIST (${quotedColumn})`);
-    }
-    /**
-     * Drop a geo-spatial index.
-     *
-     * @param table - Table name
-     * @param column - Geo column
-     */
-    async dropGeoIndex(table, column) {
-        await this.dropIndex(table, `idx_${table}_geo_${column}`);
-    }
-    /**
-     * Create a vector search index (requires pgvector extension).
-     *
-     * @param table - Table name
-     * @param column - Vector column
-     * @param options - Vector index options
-     */
-    async createVectorIndex(table, column, options) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedColumn = this.driver.dialect.quoteIdentifier(column);
-        const indexName = options.name ?? `idx_${table}_vector_${column}`;
-        const quotedIndexName = this.driver.dialect.quoteIdentifier(indexName);
-        // Map similarity to pgvector operator class
-        const opClass = options.similarity === "euclidean"
-            ? "vector_l2_ops"
-            : options.similarity === "dotProduct"
-                ? "vector_ip_ops"
-                : "vector_cosine_ops";
-        const lists = options.lists ?? 100;
-        await this.execute(`CREATE INDEX ${quotedIndexName} ON ${quotedTable} USING ivfflat (${quotedColumn} ${opClass}) WITH (lists = ${lists})`);
-    }
-    /**
-     * Drop a vector search index.
-     *
-     * @param table - Table name
-     * @param column - Vector column
-     */
-    async dropVectorIndex(table, column) {
-        await this.dropIndex(table, `idx_${table}_vector_${column}`);
-    }
-    /**
-     * Create a TTL index (not natively supported in PostgreSQL).
-     *
-     * Note: PostgreSQL doesn't have native TTL indexes like MongoDB.
-     * This creates a partial index and requires a scheduled job for cleanup.
-     *
-     * @param table - Table name
-     * @param column - Date column
-     * @param expireAfterSeconds - Expiration time in seconds
-     */
-    async createTTLIndex(table, column, expireAfterSeconds) {
-        // Create a partial index for expired rows (for efficient cleanup queries)
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedColumn = this.driver.dialect.quoteIdentifier(column);
-        const indexName = `idx_${table}_ttl_${column}`;
-        const quotedIndexName = this.driver.dialect.quoteIdentifier(indexName);
-        await this.execute(`CREATE INDEX ${quotedIndexName} ON ${quotedTable} (${quotedColumn}) WHERE ${quotedColumn} < NOW() - INTERVAL '${expireAfterSeconds} seconds'`);
-        // Note: User must set up a scheduled job (pg_cron, etc.) to:
-        // DELETE FROM table WHERE column < NOW() - INTERVAL 'X seconds'
-    }
-    /**
-     * Drop a TTL index.
-     *
-     * @param table - Table name
-     * @param column - Column with TTL index
-     */
-    async dropTTLIndex(table, column) {
-        await this.dropIndex(table, `idx_${table}_ttl_${column}`);
-    }
-    /**
-     * List all indexes on a table.
-     *
-     * @param table - Table name
-     * @returns Array of index metadata
-     */
-    async listIndexes(table) {
-        const result = await this.driver.query(`SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = 'public' AND tablename = $1`, [table]);
-        return result.rows.map((row) => {
-            const isUnique = row.indexdef.includes("UNIQUE");
-            const isPrimary = row.indexname.endsWith("_pkey");
-            const columnsMatch = row.indexdef.match(/\(([^)]+)\)/);
-            const columns = columnsMatch
-                ? columnsMatch[1].split(",").map((c) => c.trim().replace(/"/g, ""))
-                : [];
-            let type = "btree";
-            if (row.indexdef.includes("USING GIN"))
-                type = "gin";
-            else if (row.indexdef.includes("USING GIST"))
-                type = "gist";
-            else if (row.indexdef.includes("USING HASH"))
-                type = "hash";
-            else if (row.indexdef.includes("USING ivfflat"))
-                type = "ivfflat";
-            return {
-                name: row.indexname,
-                columns,
-                type,
-                unique: isUnique || isPrimary,
-                partial: row.indexdef.includes("WHERE"),
-                options: { primary: isPrimary, definition: row.indexdef },
-            };
-        });
-    }
-    // ============================================================================
-    // EXTENSIONS
-    // ============================================================================
-    /**
-     * Check if a PostgreSQL extension is available on the database server.
-     *
-     * @param extension - Extension name (e.g., "vector")
-     */
-    async isExtensionAvailable(extension) {
-        try {
-            const result = await this.driver.query(`SELECT name FROM pg_available_extensions WHERE name = $1`, [extension]);
-            return result?.rows?.length > 0;
-        }
-        catch {
-            // If we can't check (e.g., permissions issue or pg_available_extensions not accessible),
-            // we return true to avoid false positives. Execution will just proceed and fail naturally if it's missing.
-            return true;
-        }
-    }
-    /**
-     * Get the official documentation or installation URL for a PostgreSQL extension.
-     *
-     * @param extension - Extension name
-     */
-    getExtensionDocsUrl(extension) {
-        const guideUrls = {
-            vector: "https://github.com/pgvector/pgvector#installation",
-            postgis: "https://postgis.net/documentation/getting_started/",
-            pg_trgm: "https://www.postgresql.org/docs/current/pgtrgm.html",
-            uuid_ossp: "https://www.postgresql.org/docs/current/uuid-ossp.html",
-        };
-        return guideUrls[extension] ?? `https://www.postgresql.org/docs/current/${extension}.html`;
-    }
-    // ============================================================================
-    // CONSTRAINTS
-    // ============================================================================
-    /**
-     * Add a foreign key constraint.
-     *
-     * @param table - Table name
-     * @param foreignKey - Foreign key definition
-     */
-    async addForeignKey(table, foreignKey) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedColumn = this.driver.dialect.quoteIdentifier(foreignKey.column);
-        const quotedRefTable = this.driver.dialect.quoteIdentifier(foreignKey.referencesTable);
-        const quotedRefColumn = this.driver.dialect.quoteIdentifier(foreignKey.referencesColumn);
-        const constraintName = foreignKey.name ?? `fk_${table}_${foreignKey.column}_${foreignKey.referencesTable}`;
-        const quotedConstraint = this.driver.dialect.quoteIdentifier(constraintName);
-        let sql = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${quotedConstraint} FOREIGN KEY (${quotedColumn}) REFERENCES ${quotedRefTable} (${quotedRefColumn})`;
-        if (foreignKey.onDelete) {
-            sql += ` ON DELETE ${this.mapForeignKeyAction(foreignKey.onDelete)}`;
-        }
-        if (foreignKey.onUpdate) {
-            sql += ` ON UPDATE ${this.mapForeignKeyAction(foreignKey.onUpdate)}`;
-        }
-        await this.execute(sql);
-    }
-    /**
-     * Drop a foreign key constraint.
-     *
-     * @param table - Table name
-     * @param name - Constraint name
-     */
-    async dropForeignKey(table, name) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedConstraint = this.driver.dialect.quoteIdentifier(name);
-        await this.execute(`ALTER TABLE ${quotedTable} DROP CONSTRAINT ${quotedConstraint}`);
-    }
-    /**
-     * Add a primary key constraint.
-     *
-     * @param table - Table name
-     * @param columns - Primary key columns
-     */
-    async addPrimaryKey(table, columns) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedColumns = columns.map((c) => this.driver.dialect.quoteIdentifier(c)).join(", ");
-        const constraintName = `pk_${table}`;
-        const quotedConstraint = this.driver.dialect.quoteIdentifier(constraintName);
-        await this.execute(`ALTER TABLE ${quotedTable} ADD CONSTRAINT ${quotedConstraint} PRIMARY KEY (${quotedColumns})`);
-    }
-    /**
-     * Drop the primary key constraint.
-     *
-     * @param table - Table name
-     */
-    async dropPrimaryKey(table) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const constraintName = `pk_${table}`;
-        const quotedConstraint = this.driver.dialect.quoteIdentifier(constraintName);
-        await this.execute(`ALTER TABLE ${quotedTable} DROP CONSTRAINT ${quotedConstraint}`);
-    }
-    /**
-     * Add a CHECK constraint.
-     *
-     * @param table - Table name
-     * @param name - Constraint name
-     * @param expression - SQL CHECK expression
-     */
-    async addCheck(table, name, expression) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedName = this.driver.dialect.quoteIdentifier(name);
-        const sql = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${quotedName} CHECK (${expression})`;
-        await this.execute(sql);
-    }
-    /**
-     * Drop a CHECK constraint.
-     *
-     * @param table - Table name
-     * @param name - Constraint name
-     */
-    async dropCheck(table, name) {
-        const quotedTable = this.driver.dialect.quoteIdentifier(table);
-        const quotedName = this.driver.dialect.quoteIdentifier(name);
-        await this.execute(`ALTER TABLE ${quotedTable} DROP CONSTRAINT ${quotedName}`);
-    }
-    // ============================================================================
-    // SCHEMA VALIDATION (NOT APPLICABLE FOR PostgreSQL)
-    // ============================================================================
-    /**
-     * Set schema validation (no-op for PostgreSQL).
-     *
-     * PostgreSQL uses column constraints instead.
-     */
-    async setSchemaValidation(_table, _schema) {
-        // No-op: PostgreSQL doesn't have MongoDB-style schema validation
-        // Use CHECK constraints instead
-    }
-    /**
-     * Remove schema validation (no-op for PostgreSQL).
-     */
-    async removeSchemaValidation(_table) {
-        // No-op
-    }
-    // ============================================================================
-    // TRANSACTIONS
-    // ============================================================================
-    /**
-     * Begin a transaction.
-     */
-    async beginTransaction() {
-        await this.execute("BEGIN");
-    }
-    /**
-     * Commit the current transaction.
-     */
-    async commit() {
-        await this.execute("COMMIT");
-    }
-    /**
-     * Rollback the current transaction.
-     */
-    async rollback() {
-        await this.execute("ROLLBACK");
-    }
-    /**
-     * Whether transactions are supported.
-     */
-    supportsTransactions() {
-        return true;
-    }
-    /**
-     * Get the default transactional behavior for PostgreSQL.
-     *
-     * PostgreSQL supports transactional DDL operations, so migrations
-     * are wrapped in transactions by default for atomicity and safety.
-     *
-     * @returns true (PostgreSQL DDL is transactional)
-     */
-    getDefaultTransactional() {
-        return true;
-    }
-    // ============================================================================
-    // DEFAULTS
-    // ============================================================================
-    /**
-     * Get the default UUID generation expression for PostgreSQL.
-     *
-     * Resolution order:
-     * 1. `migrationDefaults.uuidExpression` → raw expression (escape hatch)
-     * 2. `migrationDefaults.uuidStrategy` → mapped to PG function
-     * 3. Fallback → `gen_random_uuid()` (v4, PG 13+)
-     *
-     * @param migrationDefaults - Optional overrides from DataSource config
-     * @returns PostgreSQL SQL expression for UUID generation
-     *
-     * @example
-     * ```typescript
-     * driver.getUuidDefault(); // "gen_random_uuid()"
-     * driver.getUuidDefault({ uuidStrategy: "v7" }); // "uuidv7()"
-     * driver.getUuidDefault({ uuidExpression: "uuid_generate_v1mc()" }); // "uuid_generate_v1mc()"
-     * ```
-     */
-    getUuidDefault(migrationDefaults) {
-        // Escape hatch: raw expression takes highest precedence
-        if (migrationDefaults?.uuidExpression) {
-            return migrationDefaults.uuidExpression;
-        }
-        const strategy = migrationDefaults?.uuidStrategy ?? "v4";
-        const strategyMap = {
-            v4: "gen_random_uuid()",
-            v7: "uuidv7()",
-        };
-        return strategyMap[strategy];
-    }
-    // ============================================================================
-    // RAW ACCESS
-    // ============================================================================
-    /**
-     * Execute raw operations with direct driver access.
-     *
-     * @param callback - Callback receiving the driver
-     */
-    async raw(callback) {
-        return callback(this.driver);
-    }
-    // ============================================================================
-    // HELPERS
-    // ============================================================================
-    /**
-     * Execute a SQL statement.
-     *
-     * @param sql - SQL to execute
-     * @param params - Query parameters
-     */
-    async execute(sql, params = []) {
-        await this.driver.query(sql, params);
-    }
-    /**
-     * Map foreign key action to PostgreSQL syntax.
-     */
-    mapForeignKeyAction(action) {
-        const mapping = {
-            cascade: "CASCADE",
-            restrict: "RESTRICT",
-            setNull: "SET NULL",
-            noAction: "NO ACTION",
-        };
-        return mapping[action] ?? "NO ACTION";
-    }
-    /**
-     * Map PostgreSQL data type to ColumnType.
-     */
-    mapPostgresTypeToColumnType(pgType) {
-        const typeMap = {
-            "character varying": "string",
-            varchar: "string",
-            character: "char",
-            char: "char",
-            text: "text",
-            integer: "integer",
-            int: "integer",
-            smallint: "smallInteger",
-            bigint: "bigInteger",
-            real: "float",
-            "double precision": "double",
-            numeric: "decimal",
-            decimal: "decimal",
-            boolean: "boolean",
-            date: "date",
-            timestamp: "dateTime",
-            "timestamp without time zone": "dateTime",
-            "timestamp with time zone": "timestamp",
-            time: "time",
-            "time without time zone": "time",
-            json: "json",
-            jsonb: "json",
-            bytea: "binary",
-            uuid: "uuid",
-            inet: "ipAddress",
-            macaddr: "macAddress",
-            point: "point",
-            polygon: "polygon",
-            line: "lineString",
-            geometry: "geometry",
-            // PostgreSQL array types
-            "integer[]": "arrayInt",
-            "int[]": "arrayInt",
-            "bigint[]": "arrayBigInt",
-            "real[]": "arrayFloat",
-            "decimal[]": "arrayDecimal",
-            "numeric[]": "arrayDecimal",
-            "boolean[]": "arrayBoolean",
-            "text[]": "arrayText",
-            "date[]": "arrayDate",
-            "timestamp with time zone[]": "arrayTimestamp",
-            "timestamptz[]": "arrayTimestamp",
-            "uuid[]": "arrayUuid",
-        };
-        return typeMap[pgType.toLowerCase()] ?? "string";
-    }
-}exports.PostgresMigrationDriver=PostgresMigrationDriver;//# sourceMappingURL=postgres-migration-driver.js.map