@mikro-orm/sql 7.1.3-dev.4 → 7.1.3-dev.6

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -97,6 +97,20 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     private getEnumDefinitions;
     protected getCollateSQL(collation: string): string;
     createTableColumn(column: Column, table: DatabaseTable): string | undefined;
+    /**
+     * Adding partitioning to an existing table (or changing an existing definition) can't be done in place in
+     * PostgreSQL, so we rebuild it: park the original table in a temp schema (its indexes/constraints/sequences
+     * move with it, freeing the names), create the new partitioned table, copy the data across, and restore the
+     * foreign keys that pointed at it. In safe mode the original table is kept in the temp schema for manual
+     * verification; otherwise the temp schema is dropped at the end.
+     */
+    getPartitioningRebuildSQL(rebuilds: {
+        diff: TableDifference;
+        inboundForeignKeys: {
+            table: DatabaseTable;
+            foreignKey: ForeignKey;
+        }[];
+    }[], safe: boolean): string[];
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     castColumn(name: string, type: string): string;
     dropForeignKey(tableName: string, constraintName: string): string;

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -723,6 +723,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       join pg_namespace nsp2 on nsp2.oid = cls2.relnamespace
       where (${[...tablesBySchemas.entries()].map(([schema, tables]) => `(cls1.relname in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(',')}) and nsp1.nspname = ${this.platform.quoteValue(schema)})`).join(' or ')})
       and confrelid > 0
+      and con.conparentid = 0
       order by nsp1.nspname, cls1.relname, constraint_name, ord`;
         const allFks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
@@ -885,13 +886,70 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
         return col.join(' ');
     }
-    getPreAlterTable(tableDiff, safe) {
-        if (tableDiff.changedPartitioning) {
-            const from = tableDiff.changedPartitioning.from?.definition;
-            const to = tableDiff.changedPartitioning.to?.definition;
-            const action = !from ? 'Adding' : !to ? 'Removing' : 'Changing';
-            throw new Error(`${action} partition definitions for existing PostgreSQL tables is not supported automatically (${tableDiff.name}: '${from ?? '<none>'}' -> '${to ?? '<none>'}'); create a manual migration instead`);
+    /**
+     * Adding partitioning to an existing table (or changing an existing definition) can't be done in place in
+     * PostgreSQL, so we rebuild it: park the original table in a temp schema (its indexes/constraints/sequences
+     * move with it, freeing the names), create the new partitioned table, copy the data across, and restore the
+     * foreign keys that pointed at it. In safe mode the original table is kept in the temp schema for manual
+     * verification; otherwise the temp schema is dropped at the end.
+     */
+    getPartitioningRebuildSQL(rebuilds, safe) {
+        if (rebuilds.length === 0) {
+            return [];
+        }
+        const tmpSchema = 'mikro_orm_partition_swap';
+        const ret = [];
+        ret.push(`-- WARNING: changing partitioning rebuilds the table by copying all rows into a new partitioned table under an exclusive lock.`);
+        ret.push(`-- Review for data volume, locking and downtime before running.`);
+        ret.push(`create schema if not exists ${this.quote(tmpSchema)}`);
+        for (const { diff, inboundForeignKeys } of rebuilds) {
+            const table = diff.toTable;
+            const parked = `${this.quote(tmpSchema)}.${this.quote(table.name)}`;
+            // drop foreign keys that reference this table so it can be parked and replaced
+            for (const { table: localTable, foreignKey } of inboundForeignKeys) {
+                ret.push(`alter table ${localTable.getQuotedName()} drop constraint ${this.quote(foreignKey.constraintName)}`);
+            }
+            // move the existing table out of the way; its indexes/constraints/sequences travel with it
+            ret.push(`alter table ${table.getQuotedName()} set schema ${this.quote(tmpSchema)}`);
+            // child partitions are separate tables that don't move with the parent — park them too so their
+            // names are free for the new partitions
+            for (const partition of diff.fromTable.getPartitioning()?.partitions ?? []) {
+                const partitionName = this.quote(this.getTableName(partition.name, partition.schema ?? table.schema));
+                ret.push(`alter table ${partitionName} set schema ${this.quote(tmpSchema)}`);
+            }
+            // create the new partitioned table (+ partitions, indexes, checks)
+            this.append(ret, this.createTable(table, true));
+            // recreate the table's own foreign keys and triggers (createTable emits them separately)
+            if (this.options.createForeignKeyConstraints) {
+                for (const foreignKey of Object.values(table.getForeignKeys())) {
+                    this.append(ret, this.createForeignKey(table, foreignKey));
+                }
+            }
+            for (const trigger of table.getTriggers()) {
+                this.append(ret, this.createTrigger(table, trigger));
+            }
+            // copy data for the columns that exist on both sides
+            const fromColumns = new Set(diff.fromTable.getColumns().map(col => col.name));
+            const columns = table
+                .getColumns()
+                .filter(col => fromColumns.has(col.name))
+                .map(col => this.quote(col.name))
+                .join(', ');
+            ret.push(`insert into ${table.getQuotedName()} (${columns}) select ${columns} from ${parked}`);
+            // restore the inbound foreign keys against the new table
+            for (const { table: localTable, foreignKey } of inboundForeignKeys) {
+                this.append(ret, this.createForeignKey(localTable, foreignKey));
+            }
         }
+        if (safe) {
+            ret.push(`-- safe mode: original tables kept in schema "${tmpSchema}"; drop that schema manually once the data is verified`);
+        }
+        else {
+            ret.push(`drop schema if exists ${this.quote(tmpSchema)} cascade`);
+        }
+        return ret;
+    }
+    getPreAlterTable(tableDiff, safe) {
         const ret = [];
         const parts = tableDiff.name.split('.');
         const tableName = parts.pop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.3-dev.4",
+  "version": "7.1.3-dev.6",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.1.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.3-dev.4"
+    "@mikro-orm/core": "7.1.3-dev.6"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/SchemaHelper.d.ts

@@ -114,6 +114,17 @@ export declare abstract class SchemaHelper {
     createTableColumn(column: Column, table: DatabaseTable, changedProperties?: Set<string>): string | undefined;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+    /**
+     * Generates a data-preserving rebuild for tables whose partitioning was added or changed. Empty by default;
+     * only PostgreSQL introspects partitioning, so this is never invoked for other platforms.
+     */
+    getPartitioningRebuildSQL(rebuilds: {
+        diff: TableDifference;
+        inboundForeignKeys: {
+            table: DatabaseTable;
+            foreignKey: ForeignKey;
+        }[];
+    }[], safe: boolean): string[];
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;

package/schema/SchemaHelper.js

@@ -580,6 +580,13 @@ export class SchemaHelper {
     getPostAlterTable(tableDiff, safe) {
         return [];
     }
+    /**
+     * Generates a data-preserving rebuild for tables whose partitioning was added or changed. Empty by default;
+     * only PostgreSQL introspects partitioning, so this is never invoked for other platforms.
+     */
+    getPartitioningRebuildSQL(rebuilds, safe) {
+        return [];
+    }
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }

package/schema/SqlSchemaGenerator.d.ts

@@ -40,6 +40,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
     /**
      * We need to drop foreign keys first for all tables to allow dropping PK constraints.
      */
+    /** Collects foreign keys from other tables that reference `table` (self-references are excluded — those travel with the rebuild). */
+    private getInboundForeignKeys;
     private preAlterTable;
     /**
      * creates new database and connects to it

package/schema/SqlSchemaGenerator.js

@@ -336,13 +336,21 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 ret.push('');
             }
         }
-        for (const changedTable of Object.values(schemaDiff.changedTables)) {
+        // Tables whose partitioning was added/changed can't be altered in place — they are rebuilt as a unit
+        // (the helper handles the data-preserving swap), so keep them out of the regular alter passes.
+        const changedTables = Object.values(schemaDiff.changedTables);
+        const partitioningRebuilds = changedTables
+            .filter(changedTable => changedTable.changedPartitioning)
+            .map(diff => ({ diff, inboundForeignKeys: this.getInboundForeignKeys(schemaDiff.fromSchema, diff.toTable) }));
+        const alteredTables = changedTables.filter(changedTable => !changedTable.changedPartitioning);
+        this.append(ret, this.helper.getPartitioningRebuildSQL(partitioningRebuilds, options.safe), true);
+        for (const changedTable of alteredTables) {
             this.append(ret, this.preAlterTable(changedTable, options.safe), true);
         }
-        for (const changedTable of Object.values(schemaDiff.changedTables)) {
+        for (const changedTable of alteredTables) {
             this.append(ret, this.helper.alterTable(changedTable, options.safe), true);
         }
-        for (const changedTable of Object.values(schemaDiff.changedTables)) {
+        for (const changedTable of alteredTables) {
             this.append(ret, this.helper.getPostAlterTable(changedTable, options.safe), true);
         }
         if (!options.safe && this.platform.supportsNativeEnums()) {
@@ -382,6 +390,23 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     /**
      * We need to drop foreign keys first for all tables to allow dropping PK constraints.
      */
+    /** Collects foreign keys from other tables that reference `table` (self-references are excluded — those travel with the rebuild). */
+    getInboundForeignKeys(fromSchema, table) {
+        const unqualified = (name) => name.split('.').pop();
+        const targetName = unqualified(table.name);
+        const ret = [];
+        for (const other of fromSchema.getTables()) {
+            if (other.name === table.name && other.schema === table.schema) {
+                continue;
+            }
+            for (const foreignKey of Object.values(other.getForeignKeys())) {
+                if (unqualified(foreignKey.referencedTableName) === targetName) {
+                    ret.push({ table: other, foreignKey });
+                }
+            }
+        }
+        return ret;
+    }
     preAlterTable(diff, safe) {
         const ret = [];
         this.append(ret, this.helper.getPreAlterTable(diff, safe));

package/schema/partitioning.js

@@ -261,10 +261,13 @@ export const getTablePartitioning = (meta, tableSchema, quoteIdentifier = id =>
 };
 /** @internal */
 export const diffPartitioning = (from, to, defaultSchema) => {
-    if (!from && !to) {
+    // Metadata does not declare `partitionBy`, so partitioning is left unmanaged — never drop or alter an
+    // existing table's partitioning just because the entity omits it (in-place removal isn't supported anyway).
+    if (!to) {
         return false;
     }
-    if (!from || !to) {
+    // Metadata declares partitioning the table does not have yet (adding it in place isn't supported).
+    if (!from) {
         return true;
     }
     if (normalizeQuotedIdentifiers(normalizePartitionDefinition(from.definition)) !==