ts-prorm-orm 1.1.0

package/dist/query-interface.js

@@ -0,0 +1,622 @@
+"use strict";
+/**
+ * QueryInterface - Provides methods for executing database operations during migrations
+ * Works with all supported dialects: SQLite, MySQL, PostgreSQL, MariaDB
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateQueryInterface = void 0;
+exports.createQueryInterface = createQueryInterface;
+/**
+ * CreateQueryInterface - Provides migration operations for all database dialects
+ */
+class CreateQueryInterface {
+    /**
+     * Create a new QueryInterface instance
+     * @param dialect - The database dialect to use
+     */
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    /**
+     * Get the dialect instance
+     */
+    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) {
+        const columnDefinitions = {};
+        for (const [colName, colDef] of Object.entries(columns)) {
+            columnDefinitions[colName] = {
+                type: typeof colDef.type === 'string'
+                    ? colDef.type
+                    : colDef.type,
+                allowNull: colDef.allowNull,
+                defaultValue: colDef.defaultValue,
+                primaryKey: colDef.primaryKey,
+                autoIncrement: colDef.autoIncrement,
+                unique: colDef.unique,
+                references: colDef.references
+                    ? {
+                        table: colDef.references.model,
+                        field: colDef.references.key || 'id',
+                        onDelete: colDef.references.onDelete,
+                        onUpdate: colDef.references.onUpdate,
+                    }
+                    : undefined,
+                comment: colDef.comment,
+            };
+        }
+        await this.dialect.createTable(tableName, columnDefinitions, options);
+    }
+    /**
+     * 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) {
+        const columnDefinitions = {};
+        for (const [colName, colDef] of Object.entries(columns)) {
+            columnDefinitions[colName] = {
+                type: typeof colDef.type === 'string'
+                    ? colDef.type
+                    : colDef.type,
+                allowNull: colDef.allowNull,
+                defaultValue: colDef.defaultValue,
+                primaryKey: colDef.primaryKey,
+                autoIncrement: colDef.autoIncrement,
+                unique: colDef.unique,
+                references: colDef.references
+                    ? {
+                        table: colDef.references.model,
+                        field: colDef.references.key || 'id',
+                        onDelete: colDef.references.onDelete,
+                        onUpdate: colDef.references.onUpdate,
+                    }
+                    : undefined,
+                comment: colDef.comment,
+            };
+        }
+        await this.dialect.createPartitionedTable(tableName, columnDefinitions, 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);
+    }
+    /**
+     * 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.dialect.showTables();
+        for (const table of tables) {
+            await this.dialect.dropTable(table);
+        }
+    }
+    /**
+     * Rename a table
+     * @param oldName - Current table name
+     * @param newName - New table name
+     */
+    async renameTable(oldName, newName, _options) {
+        await this.dialect.renameTable(oldName, newName);
+    }
+    /**
+     * 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, _options) {
+        const columnDef = {
+            type: typeof definition.type === 'string'
+                ? definition.type
+                : definition.type,
+            allowNull: definition.allowNull,
+            defaultValue: definition.defaultValue,
+            primaryKey: definition.primaryKey,
+            autoIncrement: definition.autoIncrement,
+            unique: definition.unique,
+            references: definition.references
+                ? {
+                    table: definition.references.model,
+                    field: definition.references.key || 'id',
+                    onDelete: definition.references.onDelete,
+                    onUpdate: definition.references.onUpdate,
+                }
+                : undefined,
+            comment: definition.comment,
+        };
+        await this.dialect.addColumn(tableName, columnName, columnDef);
+    }
+    /**
+     * Remove a column from a table
+     * @param tableName - Name of the table
+     * @param columnName - Name of the column to remove
+     */
+    async removeColumn(tableName, columnName, _options) {
+        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, _options) {
+        const columnDef = {
+            type: typeof definition.type === 'string'
+                ? definition.type
+                : definition.type,
+            allowNull: definition.allowNull,
+            defaultValue: definition.defaultValue,
+            primaryKey: definition.primaryKey,
+            autoIncrement: definition.autoIncrement,
+            unique: definition.unique,
+            references: definition.references
+                ? {
+                    table: definition.references.model,
+                    field: definition.references.key || 'id',
+                    onDelete: definition.references.onDelete,
+                    onUpdate: definition.references.onUpdate,
+                }
+                : undefined,
+            comment: definition.comment,
+        };
+        await this.dialect.changeColumn(tableName, columnName, columnDef);
+    }
+    /**
+     * Rename a column
+     * @param tableName - Name of the table
+     * @param oldColumnName - Current column name
+     * @param newColumnName - New column name
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName, _options) {
+        // Get current column definition
+        const tableDescription = await this.dialect.describeTable(tableName);
+        const columnDef = tableDescription[oldColumnName];
+        if (!columnDef) {
+            throw new Error(`Column ${oldColumnName} does not exist in table ${tableName}`);
+        }
+        // Add new column with new name
+        await this.dialect.addColumn(tableName, newColumnName, {
+            type: columnDef.type,
+            allowNull: columnDef.allowNull,
+            defaultValue: columnDef.defaultValue,
+            primaryKey: columnDef.primaryKey,
+            autoIncrement: columnDef.autoIncrement,
+        });
+        // Copy data from old column to new
+        const quotedTable = this.dialect.quoteTable(tableName);
+        const quotedOldColumn = this.dialect.quoteIdentifier(oldColumnName);
+        const quotedNewColumn = this.dialect.quoteIdentifier(newColumnName);
+        await this.dialect.query(`UPDATE ${quotedTable} SET ${quotedNewColumn} = ${quotedOldColumn}`, {
+            raw: true,
+        });
+        // Remove old column
+        await this.dialect.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 include in the index
+     * @param options - Index options
+     */
+    async addIndex(tableName, indexNameOrFields, fieldsOrOptions, options) {
+        let indexName;
+        let fields;
+        let opts;
+        if (Array.isArray(indexNameOrFields)) {
+            // Called as (tableName, fields, options?)
+            fields = indexNameOrFields;
+            opts = fieldsOrOptions;
+            indexName = opts?.name || `${tableName}_${fields.join('_')}_idx`;
+        }
+        else {
+            // Called as (tableName, indexName, fields, options?)
+            indexName = indexNameOrFields;
+            fields = fieldsOrOptions || [];
+            opts = options;
+        }
+        const fieldNames = fields.map((f) => (typeof f === 'string' ? f : f.name));
+        const indexOptions = {
+            unique: opts?.unique,
+            type: opts?.type,
+            using: opts?.using,
+            where: opts?.where,
+            expression: opts?.expression,
+            include: opts?.include,
+        };
+        await this.dialect.addIndex(tableName, indexName, fieldNames, indexOptions);
+    }
+    /**
+     * Remove an index from a table
+     * @param tableName - Name of the table
+     * @param indexName - Name of the index to remove
+     */
+    async removeIndex(tableName, indexName, _options) {
+        await this.dialect.removeIndex(tableName, indexName);
+    }
+    /**
+     * Show all indexes for a table
+     * @param tableName - Name of the table
+     */
+    async showIndexes(tableName) {
+        const indexes = [];
+        if (this.dialect.name === 'sqlite') {
+            const sql = `SELECT name, sql FROM sqlite_master WHERE type='index' AND tbl_name='${tableName}'`;
+            const result = await this.dialect.query(sql, { raw: true });
+            for (const row of result.rows) {
+                if (!row.name)
+                    continue;
+                const isUnique = row.sql ? /CREATE\s+UNIQUE\s+INDEX/i.test(row.sql) : false;
+                // Parse field names from the SQL if available
+                const fieldsMatch = row.sql ? row.sql.match(/\(([^)]+)\)/) : null;
+                const fields = fieldsMatch
+                    ? fieldsMatch[1].split(',').map((f) => f.trim().replace(/^["'`]|["'`]$/g, ''))
+                    : [];
+                indexes.push({ name: row.name, fields, unique: isUnique });
+            }
+        }
+        else {
+            const sql = `SHOW INDEX FROM ${this.dialect.quoteTable(tableName)}`;
+            const result = await this.dialect.query(sql, { raw: true });
+            for (const row of result.rows) {
+                const existingIdx = indexes.find((i) => i.name === row.Key_name);
+                if (existingIdx) {
+                    existingIdx.fields.push(row.Column_name);
+                }
+                else {
+                    indexes.push({
+                        name: row.Key_name,
+                        fields: [row.Column_name],
+                        unique: row.Non_unique === 0,
+                    });
+                }
+            }
+        }
+        return indexes;
+    }
+    /**
+     * Add a constraint to a table
+     * @param tableName - Name of the table
+     * @param constraintName - Name of the constraint
+     * @param constraint - Constraint definition
+     */
+    async addConstraint(tableName, constraintNameOrOptions, constraintOrOptions, _options) {
+        let constraintName;
+        let constraint;
+        if (typeof constraintNameOrOptions === 'object') {
+            // Called as (tableName, { type, fields, name, ... })
+            constraint = constraintNameOrOptions;
+            constraintName = constraintNameOrOptions.name || `${tableName}_constraint`;
+        }
+        else {
+            // Called as (tableName, constraintName, constraint, options?)
+            constraintName = constraintNameOrOptions;
+            constraint = constraintOrOptions;
+        }
+        const quotedTable = this.dialect.quoteTable(tableName);
+        const isSQLite = this.dialect.name === 'sqlite';
+        let sql = '';
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                if (isSQLite)
+                    return; // SQLite doesn't support ADD CONSTRAINT after table creation
+                const pkFields = constraint.fields?.map((f) => this.dialect.quoteIdentifier(f)).join(', ') || '';
+                sql = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.dialect.quoteIdentifier(constraintName)} PRIMARY KEY (${pkFields})`;
+                break;
+            case 'UNIQUE':
+                if (isSQLite) {
+                    // SQLite: use CREATE UNIQUE INDEX as an equivalent
+                    const uFields = constraint.fields?.map((f) => this.dialect.quoteIdentifier(f)).join(', ') || '';
+                    sql = `CREATE UNIQUE INDEX IF NOT EXISTS ${this.dialect.quoteIdentifier(constraintName)} ON ${quotedTable} (${uFields})`;
+                }
+                else {
+                    const uniqueFields = constraint.fields?.map((f) => this.dialect.quoteIdentifier(f)).join(', ') || '';
+                    sql = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.dialect.quoteIdentifier(constraintName)} UNIQUE (${uniqueFields})`;
+                }
+                break;
+            case 'FOREIGN KEY':
+                if (isSQLite)
+                    return; // SQLite doesn't support ADD CONSTRAINT ... FOREIGN KEY after creation
+                const fkFields = constraint.fields?.map((f) => this.dialect.quoteIdentifier(f)).join(', ') || '';
+                const refTable = this.dialect.quoteTable(constraint.references?.table || '');
+                const refFieldList = constraint.references?.field
+                    ? [this.dialect.quoteIdentifier(constraint.references.field)]
+                    : (constraint.references?.fields || []).map((f) => this.dialect.quoteIdentifier(f));
+                const refFields = refFieldList.join(', ');
+                sql = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.dialect.quoteIdentifier(constraintName)} FOREIGN KEY (${fkFields}) REFERENCES ${refTable}(${refFields})`;
+                if (constraint.onDelete) {
+                    sql += ` ON DELETE ${constraint.onDelete}`;
+                }
+                if (constraint.onUpdate) {
+                    sql += ` ON UPDATE ${constraint.onUpdate}`;
+                }
+                break;
+            case 'CHECK':
+                if (isSQLite)
+                    return; // SQLite doesn't support ADD CONSTRAINT CHECK after creation
+                sql = `ALTER TABLE ${quotedTable} ADD CONSTRAINT ${this.dialect.quoteIdentifier(constraintName)} CHECK (${constraint.where || '1=1'})`;
+                break;
+            default:
+                throw new Error(`Unknown constraint type: ${constraint.type}`);
+        }
+        if (sql)
+            await this.dialect.query(sql, { raw: true });
+    }
+    /**
+     * Remove a constraint from a table
+     * @param tableName - Name of the table
+     * @param constraintName - Name of the constraint to remove
+     */
+    async removeConstraint(tableName, constraintName, _typeOrOptions) {
+        const isSQLite = this.dialect.name === 'sqlite';
+        if (isSQLite) {
+            // SQLite: constraint was likely added as an index, try to drop the index
+            try {
+                const sql = `DROP INDEX IF EXISTS ${this.dialect.quoteIdentifier(constraintName)}`;
+                await this.dialect.query(sql, { raw: true });
+            }
+            catch {
+                // Ignore - may not exist as an index
+            }
+            return;
+        }
+        const quotedTable = this.dialect.quoteTable(tableName);
+        const sql = `ALTER TABLE ${quotedTable} DROP CONSTRAINT ${this.dialect.quoteIdentifier(constraintName)}`;
+        await this.dialect.query(sql, { raw: true });
+    }
+    /**
+     * Check if an index exists on a table
+     */
+    async indexExists(tableName, indexName) {
+        const indexes = await this.showIndexes(tableName);
+        return indexes.some((idx) => idx.name === indexName);
+    }
+    /**
+     * Bulk insert records
+     * @param tableName - Name of the table
+     * @param records - Records to insert
+     * @param options - Insert options
+     */
+    async bulkInsert(tableName, records, _options) {
+        if (records.length === 0) {
+            return 0;
+        }
+        const columns = Object.keys(records[0]);
+        const quotedTable = this.dialect.quoteTable(tableName);
+        const quotedColumns = columns.map((c) => this.dialect.quoteIdentifier(c)).join(', ');
+        let totalInserted = 0;
+        for (const record of records) {
+            const values = columns.map((col) => this.dialect.escape(record[col])).join(', ');
+            const sql = `INSERT INTO ${quotedTable} (${quotedColumns}) VALUES (${values})`;
+            const result = await this.dialect.query(sql, { raw: true });
+            totalInserted += result.rowCount;
+        }
+        return totalInserted;
+    }
+    /**
+     * Bulk update records
+     * @param tableName - Name of the table
+     * @param values - Values to update
+     * @param where - Where clause
+     * @param options - Update options
+     */
+    async bulkUpdate(tableName, values, where, _options) {
+        const quotedTable = this.dialect.quoteTable(tableName);
+        const setClauses = Object.entries(values)
+            .map(([key, value]) => `${this.dialect.quoteIdentifier(key)} = ${this.dialect.escape(value)}`)
+            .join(', ');
+        const { sql, values: whereValues } = this.dialect.buildWhereClause(where);
+        const fullSql = this.dialect.replaceReplacements(`UPDATE ${quotedTable} SET ${setClauses} WHERE ${sql}`, whereValues);
+        const result = await this.dialect.query(fullSql, { raw: true });
+        return result.rowCount;
+    }
+    /**
+     * Bulk delete records
+     * @param tableName - Name of the table
+     * @param where - Where clause
+     * @param options - Delete options
+     */
+    async bulkDelete(tableName, where, _options) {
+        const quotedTable = this.dialect.quoteTable(tableName);
+        const { sql, values: whereVals } = this.dialect.buildWhereClause(where);
+        const fullSql = this.dialect.replaceReplacements(`DELETE FROM ${quotedTable} WHERE ${sql}`, whereVals);
+        const result = await this.dialect.query(fullSql, { raw: true });
+        return result.rowCount;
+    }
+    /**
+     * Describe a table (get column information)
+     * @param tableName - Name of the table
+     */
+    async describeTable(tableName) {
+        return this.dialect.describeTable(tableName);
+    }
+    /**
+     * Show all tables in the database
+     */
+    async showTables() {
+        return this.dialect.showTables();
+    }
+    /**
+     * Check if a table exists
+     * @param tableName - Name of the table
+     */
+    async tableExists(tableName) {
+        const tables = await this.dialect.showTables();
+        return tables.includes(tableName);
+    }
+    /**
+     * Get all table names with schema (for PostgreSQL, MySQL, etc.)
+     * @param _schema - Optional schema name
+     */
+    async getTableNames(_schema) {
+        return this.dialect.showTables();
+    }
+    /**
+     * Get foreign keys for a table
+     * @param tableName - Name of the table
+     */
+    async getForeignKeysForTable(_tableName) {
+        // Simplified implementation - dialects can override
+        return [];
+    }
+    /**
+     * Get constraints for a table
+     * @param tableName - Name of the table
+     */
+    async getConstraints(_tableName) {
+        // Simplified implementation - dialects can override
+        return [];
+    }
+    /**
+     * Create a database (for databases that support it)
+     * @param databaseName - Name of the database
+     */
+    async createDatabase(_databaseName, _options) {
+        throw new Error('Creating databases is not supported by this dialect');
+    }
+    /**
+     * Drop a database (for databases that support it)
+     * @param databaseName - Name of the database
+     */
+    async dropDatabase(_databaseName, _options) {
+        throw new Error('Dropping databases is not supported by this dialect');
+    }
+    /**
+     * Create a database view
+     * @param viewName - Name of the view to create
+     * @param query - The SELECT query for the view
+     * @param options - View options
+     */
+    async createView(viewName, query, options) {
+        await this.dialect.createView(viewName, query, options);
+    }
+    /**
+     * Drop a database view
+     * @param viewName - Name of the view to drop
+     * @param options - Drop options
+     */
+    async dropView(viewName, options) {
+        await this.dialect.dropView(viewName, options);
+    }
+    /**
+     * Show all views in the database
+     */
+    async showViews() {
+        return this.dialect.showViews();
+    }
+    /**
+     * Check if a view exists
+     * @param viewName - Name of the view
+     */
+    async viewExists(viewName) {
+        const views = await this.dialect.showViews();
+        return views.includes(viewName);
+    }
+    /**
+     * Create a materialized view
+     * @param options - Materialized view options
+     */
+    async createMaterializedView(options) {
+        await this.dialect.createMaterializedView(options);
+    }
+    /**
+     * Refresh a materialized view
+     * @param viewName - Name of the materialized view to refresh
+     * @param options - Refresh options
+     */
+    async refreshMaterializedView(viewName, options) {
+        await this.dialect.refreshMaterializedView(viewName, options);
+    }
+    /**
+     * Drop a materialized view
+     * @param viewName - Name of the materialized view to drop
+     * @param options - Drop options
+     */
+    async dropMaterializedView(viewName, options) {
+        await this.dialect.dropMaterializedView(viewName, options);
+    }
+    /**
+     * Check if a materialized view exists
+     * @param viewName - Name of the materialized view
+     */
+    async materializedViewExists(viewName) {
+        return this.dialect.hasMaterializedView(viewName);
+    }
+    /**
+     * Show all materialized views in the database
+     */
+    async showMaterializedViews() {
+        return this.dialect.showMaterializedViews();
+    }
+    /**
+     * Execute a raw query
+     * @param sql - The SQL query
+     * @param options - Query options
+     */
+    async query(sql, options) {
+        return this.dialect.query(sql, { raw: options?.logging === true });
+    }
+    /**
+     * Quote an identifier
+     * @param identifier - The identifier to quote
+     */
+    quoteIdentifier(identifier) {
+        return this.dialect.quoteIdentifier(identifier);
+    }
+    /**
+     * Escape a value
+     * @param value - The value to escape
+     */
+    escape(value) {
+        return this.dialect.escape(value);
+    }
+}
+exports.CreateQueryInterface = CreateQueryInterface;
+/**
+ * Factory function to create a QueryInterface from a Prorm instance
+ */
+function createQueryInterface(dialect) {
+    return new CreateQueryInterface(dialect);
+}