ts-prorm-orm 1.1.0

package/dist/migrations/query-interface.js

@@ -0,0 +1,435 @@
+"use strict";
+/**
+ * QueryInterface for migrations
+ * Provides methods for schema modifications during migrations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryInterface = void 0;
+exports.createQueryInterface = createQueryInterface;
+/**
+ * QueryInterface class for migrations
+ * Provides a unified API for schema modifications across dialects
+ */
+class QueryInterface {
+    /**
+     * Create a new QueryInterface instance
+     * @param dialect - The database dialect to use
+     */
+    constructor(dialect) {
+        this.transaction = null;
+        this.dialect = dialect;
+    }
+    /**
+     * Set the current transaction
+     */
+    setTransaction(transaction) {
+        this.transaction = transaction;
+    }
+    /**
+     * Get the current transaction
+     */
+    getTransaction() {
+        return this.transaction;
+    }
+    /**
+     * Get the underlying dialect
+     */
+    getDialect() {
+        return this.dialect;
+    }
+    /**
+     * Create a new table
+     * @param tableName - Name of the table to create
+     * @param columns - Column definitions
+     * @param options - Table options
+     */
+    async createTable(tableName, columns, options) {
+        await this.dialect.createTable(tableName, columns, options);
+    }
+    /**
+     * Drop a table
+     * @param tableName - Name of the table to drop
+     * @param options - Drop options
+     */
+    async dropTable(tableName, options) {
+        await this.dialect.dropTable(tableName, options);
+    }
+    /**
+     * Drop all tables (dialect-specific)
+     */
+    async dropAllTables(_options) {
+        const tables = await this.showTables();
+        for (const table of tables) {
+            await this.dropTable(table);
+        }
+    }
+    /**
+     * Rename a table
+     * @param oldName - Current table name
+     * @param newName - New table name
+     */
+    async renameTable(oldName, newName) {
+        await this.dialect.renameTable(oldName, newName);
+    }
+    /**
+     * Show all tables in the database
+     */
+    async showTables() {
+        return this.dialect.showTables();
+    }
+    /**
+     * Describe a table (get column information)
+     * @param tableName - Name of the table to describe
+     */
+    async describeTable(tableName) {
+        const description = await this.dialect.describeTable(tableName);
+        return description;
+    }
+    /**
+     * Add a column to a table
+     * @param tableName - Name of the table
+     * @param columnName - Name of the new column
+     * @param definition - Column definition
+     */
+    async addColumn(tableName, columnName, definition) {
+        await this.dialect.addColumn(tableName, columnName, definition);
+    }
+    /**
+     * Remove a column from a table
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column to remove
+     */
+    async removeColumn(tableName, columnName) {
+        await this.dialect.removeColumn(tableName, columnName);
+    }
+    /**
+     * Change a column definition
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column to change
+     * @param definition - New column definition
+     */
+    async changeColumn(tableName, columnName, definition) {
+        await this.dialect.changeColumn(tableName, columnName, definition);
+    }
+    /**
+     * Rename a column
+     * @param tableName - Name of the table
+     * @param oldColumnName - Current column name
+     * @param newColumnName - New column name
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        // Get current column definition
+        const description = await this.describeTable(tableName);
+        const columnDef = description[oldColumnName];
+        if (!columnDef) {
+            throw new Error(`Column ${oldColumnName} does not exist in table ${tableName}`);
+        }
+        // Add new column with new name
+        await this.addColumn(tableName, newColumnName, {
+            type: columnDef.type,
+            allowNull: columnDef.allowNull,
+            defaultValue: columnDef.defaultValue,
+        });
+        // Copy data from old column
+        await this.prormQuery(`UPDATE ${this.dialect.escapeId(tableName)} SET ${this.dialect.escapeId(newColumnName)} = ${this.dialect.escapeId(oldColumnName)}`);
+        // Remove old column
+        await this.removeColumn(tableName, oldColumnName);
+    }
+    /**
+     * Add an index to a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     * @param fields - Fields to index
+     * @param options - Index options
+     */
+    async addIndex(tableName, indexName, fields, options) {
+        await this.dialect.addIndex(tableName, indexName, fields, options);
+    }
+    /**
+     * Remove an index from a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     */
+    async removeIndex(tableName, indexName) {
+        await this.dialect.removeIndex(tableName, indexName);
+    }
+    /**
+     * Show indexes for a table
+     * @param tableName - Name of the table
+     */
+    async showIndexes(tableName) {
+        // Delegate to the dialect so each database uses its own system-table query
+        // (SQLite PRAGMA, Postgres pg_indexes, MySQL SHOW INDEX, etc.) instead of
+        // hardcoding sqlite_master.
+        const indexes = await this.dialect.showIndexes(tableName);
+        return indexes.map((idx) => ({
+            name: idx.name,
+            unique: idx.unique ?? false,
+            fields: idx.fields ?? [],
+            type: idx.type,
+        }));
+    }
+    /**
+     * Add a constraint to a table
+     * @param tableName - Name of the table
+     * @param constraintName - Name of the constraint
+     * @param constraintDefinition - Constraint definition
+     */
+    async addConstraint(tableName, constraintName, constraintDefinition) {
+        // A UNIQUE constraint is portably expressed as a unique index, so keep the
+        // existing index-based path (round-trips with removeConstraint below).
+        if (constraintDefinition.type === 'unique') {
+            if (constraintDefinition.fields && constraintDefinition.fields.length > 0) {
+                await this.addIndex(tableName, constraintName, constraintDefinition.fields, {
+                    unique: true,
+                });
+            }
+            return;
+        }
+        // PRIMARY KEY / FOREIGN KEY / CHECK are delegated to the dialect's
+        // createConstraint, which actually applies the constraint (via ALTER TABLE
+        // ADD CONSTRAINT, or a table rebuild for SQLite) instead of silently
+        // succeeding. Unsupported cases surface as a clear dialect error.
+        const typeMap = {
+            primaryKey: 'PRIMARY KEY',
+            foreignKey: 'FOREIGN KEY',
+            check: 'CHECK',
+        };
+        const constraintDef = {
+            name: constraintName,
+            type: typeMap[constraintDefinition.type],
+            fields: constraintDefinition.fields,
+        };
+        if (constraintDefinition.references) {
+            const refFields = constraintDefinition.references.fields;
+            constraintDef.references = {
+                table: constraintDefinition.references.table,
+                // createConstraint accepts a single field or a composite array; pass the
+                // array through for composite keys.
+                field: (refFields.length === 1 ? refFields[0] : refFields),
+                onDelete: constraintDefinition.onDelete,
+                onUpdate: constraintDefinition.onUpdate,
+            };
+        }
+        await this.dialect.createConstraint(tableName, constraintDef);
+    }
+    /**
+     * Remove a constraint from a table
+     * @param tableName - Name of the table
+     * @param constraintName - Name of the constraint
+     * @param constraintType - Type of constraint
+     */
+    async removeConstraint(tableName, constraintName, constraintType) {
+        // UNIQUE constraints are created as unique indexes above, so drop the index.
+        if (constraintType === 'unique') {
+            await this.removeIndex(tableName, constraintName);
+            return;
+        }
+        // PRIMARY KEY / FOREIGN KEY / CHECK are delegated to the dialect's
+        // dropConstraint (ALTER TABLE DROP CONSTRAINT) instead of silently no-oping.
+        // Dialects that cannot drop constraints in place throw a clear error.
+        await this.dialect.dropConstraint(tableName, constraintName);
+    }
+    /**
+     * Bulk insert records into a table
+     * @param tableName - Name of the table
+     * @param records - Array of records to insert
+     */
+    async bulkInsert(tableName, records) {
+        if (records.length === 0) {
+            return 0;
+        }
+        const columns = Object.keys(records[0]);
+        const values = records.map((record) => {
+            return columns.map((col) => this.dialect.escape(record[col])).join(', ');
+        });
+        const columnList = columns.map((col) => this.dialect.escapeId(col)).join(', ');
+        const valueList = values.map((v) => `(${v})`).join(',\n');
+        const sql = `INSERT INTO ${this.dialect.escapeId(tableName)} (${columnList}) VALUES ${valueList}`;
+        const result = await this.dialect.query(sql);
+        return result.rowCount;
+    }
+    /**
+     * Bulk update records in a table
+     * @param tableName - Name of the table
+     * @param values - Values to update
+     * @param where - Where conditions
+     */
+    async bulkUpdate(tableName, values, where) {
+        const setClause = Object.entries(values)
+            .map(([key, value]) => `${this.dialect.escapeId(key)} = ${this.dialect.escape(value)}`)
+            .join(', ');
+        const whereClause = this.buildWhereClause(where);
+        const sql = `UPDATE ${this.dialect.escapeId(tableName)} SET ${setClause} ${whereClause.sql}`;
+        const result = await this.dialect.query(sql, { replacements: whereClause.values });
+        return result.rowCount;
+    }
+    /**
+     * Bulk delete records from a table
+     * @param tableName - Name of the table
+     * @param where - Where conditions
+     */
+    async bulkDelete(tableName, where) {
+        const whereClause = this.buildWhereClause(where);
+        const sql = `DELETE FROM ${this.dialect.escapeId(tableName)} ${whereClause.sql}`;
+        const result = await this.dialect.query(sql, { replacements: whereClause.values });
+        return result.rowCount;
+    }
+    /**
+     * Check if a table exists
+     * @param tableName - Name of the table
+     */
+    async tableExists(tableName) {
+        const tables = await this.showTables();
+        return tables.includes(tableName);
+    }
+    /**
+     * Check if a column exists
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column
+     */
+    async columnExists(tableName, columnName) {
+        const description = await this.describeTable(tableName);
+        return columnName in description;
+    }
+    /**
+     * Check if an index exists
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index
+     */
+    async indexExists(tableName, indexName) {
+        const indexes = await this.showIndexes(tableName);
+        return indexes.some((idx) => idx.name === indexName);
+    }
+    /**
+     * Get all foreign keys for a table
+     * @param tableName - Name of the table
+     */
+    async getForeignKeysForTable(tableName) {
+        // Simplified implementation
+        // Real implementation would query database-specific system tables
+        const description = await this.describeTable(tableName);
+        const foreignKeys = [];
+        for (const [columnName, columnDef] of Object.entries(description)) {
+            if (columnDef.references) {
+                foreignKeys.push({
+                    name: `${tableName}_${columnName}_fkey`,
+                    field: columnName,
+                    references: columnDef.references,
+                });
+            }
+        }
+        return foreignKeys;
+    }
+    /**
+     * Remove foreign key
+     * @param tableName - Name of the table
+     * @param foreignKeyName - Name of the foreign key
+     */
+    async removeForeignKey(tableName, foreignKeyName) {
+        // A foreign key is a named constraint, so delegate to the dialect's
+        // dropConstraint. This avoids emitting MySQL-only `DROP FOREIGN KEY`, which
+        // is invalid on Postgres and others that require `DROP CONSTRAINT`.
+        await this.dialect.dropConstraint(tableName, foreignKeyName);
+    }
+    /**
+     * Add foreign key
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column
+     * @param references - Reference definition
+     */
+    async addForeignKey(tableName, columnName, references, onDelete, onUpdate) {
+        let sql = `ALTER TABLE ${this.dialect.escapeId(tableName)} ADD CONSTRAINT `;
+        sql += `${this.dialect.escapeId(`${tableName}_${columnName}_fkey`)} `;
+        sql += `FOREIGN KEY (${this.dialect.escapeId(columnName)}) `;
+        sql += `REFERENCES ${this.dialect.escapeId(references.table)} (${this.dialect.escapeId(references.field)})`;
+        if (onDelete) {
+            sql += ` ON DELETE ${onDelete}`;
+        }
+        if (onUpdate) {
+            sql += ` ON UPDATE ${onUpdate}`;
+        }
+        await this.prormQuery(sql);
+    }
+    /**
+     * Create a partitioned table (PostgreSQL 10+)
+     * @param tableName - Name of the table to create
+     * @param columns - Column definitions
+     * @param options - Table options including partition configuration
+     */
+    async createPartitionedTable(tableName, columns, options) {
+        await this.dialect.createPartitionedTable(tableName, columns, options);
+    }
+    /**
+     * Create a partition for an existing partitioned table (PostgreSQL 10+)
+     * @param options - Partition creation options
+     */
+    async createPartition(options) {
+        await this.dialect.createPartition(options);
+    }
+    /**
+     * Attach a partition to a partitioned table (PostgreSQL 11+)
+     * @param options - Partition attachment options
+     */
+    async attachPartition(options) {
+        await this.dialect.attachPartition(options);
+    }
+    /**
+     * Detach a partition from a partitioned table (PostgreSQL 11+)
+     * @param options - Partition detachment options
+     */
+    async detachPartition(options) {
+        await this.dialect.detachPartition(options);
+    }
+    /**
+     * Drop a partition (PostgreSQL 10+)
+     * @param partitionName - Name of the partition to drop
+     * @param options - Drop options
+     */
+    async dropPartition(partitionName, options) {
+        await this.dialect.dropPartition(partitionName, options);
+    }
+    /**
+     * Execute a raw SQL query
+     * @param sql - SQL query
+     * @param options - Query options
+     */
+    async prormQuery(sql, options) {
+        return this.dialect.query(sql, options);
+    }
+    /**
+     * Get the database version
+     */
+    async getDatabaseVersion() {
+        return this.dialect.getDatabaseVersion();
+    }
+    /**
+     * Build a WHERE clause from WhereOptions
+     */
+    buildWhereClause(where) {
+        const conditions = [];
+        const values = [];
+        for (const [key, value] of Object.entries(where)) {
+            if (value === null) {
+                conditions.push(`${this.dialect.escapeId(key)} IS NULL`);
+            }
+            else if (Array.isArray(value)) {
+                conditions.push(`${this.dialect.escapeId(key)} IN (${value.map(() => '?').join(', ')})`);
+                values.push(...value);
+            }
+            else {
+                conditions.push(`${this.dialect.escapeId(key)} = ?`);
+                values.push(value);
+            }
+        }
+        const sql = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        return { sql, values };
+    }
+}
+exports.QueryInterface = QueryInterface;
+/**
+ * Create a QueryInterface from a dialect
+ */
+function createQueryInterface(dialect) {
+    return new QueryInterface(dialect);
+}