@mikro-orm/sql 7.2.3-dev.9 → 7.2.3

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -5,6 +5,8 @@ import { normalizePartitionBound, normalizePartitionDefinition } from '../../sch
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
 /** Dollar-quote delimiter, e.g. `$$` or `$body$`, captured so `split` keeps it. */
 const DOLLAR_QUOTE_TAG = /(\$(?:[A-Za-z_]\w*)?\$)/;
+/** pg-added `(<operand>)::type` cast in a check body, including multi word types like `double precision`. */
+const CHECK_CAST_RE = /\(([^()]*)\)::\w+(?: precision| varying| with(?:out)? time zone)?(?:\[\])?/g;
 export class PostgreSqlSchemaHelper extends SchemaHelper {
     static DEFAULT_VALUES = {
         'now()': ['now()', 'current_timestamp'],
@@ -513,7 +515,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             // SchemaHelper.createCheck).
             const m = /^check \(\((.*)\)\)$/is.exec(check.expression);
             const single = m ? null : /^check \((.*)\)$/is.exec(check.expression);
-            const def = m ? m[1].replace(/\(([^()]*)\)::\w+(?:\[\])?/g, '$1') : single ? single[1] : check.expression;
+            const def = m ? m[1].replace(CHECK_CAST_RE, '$1') : single ? single[1] : check.expression;
             ret[key].push({
                 name: check.name,
                 columnName: check.column_name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.2.3-dev.9",
+  "version": "7.2.3",
   "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",
@@ -50,10 +50,10 @@
     "kysely": "0.29.6"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.2.2"
+    "@mikro-orm/core": "^7.2.3"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.3-dev.9"
+    "@mikro-orm/core": "7.2.3"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilderHelper.js

@@ -2,6 +2,16 @@ import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, JsonType, inspect,
 import { EMBEDDABLE_ARRAY_OPS, JoinType, QueryType } from './enums.js';
 /** Captures the column name that follows the alias placeholder. */
 const QUALIFYING_ALIAS_RE = new RegExp(ALIAS_REPLACEMENT_RE + '(?=["\'`\\]]*\\.["\'`\\[]?([\\w$]+))', 'g');
+/** Maps regexp tokens to LIKE pattern tokens, escaping LIKE wildcards with `!`. */
+const LIKE_REPLACEMENTS = {
+    '\\.': '.',
+    '\\/': '/',
+    '.*': '%',
+    '.': '_',
+    '!': '!!',
+    '%': '!%',
+    _: '!_',
+};
 /**
  * @internal
  */
@@ -359,19 +369,17 @@ export class QueryBuilderHelper {
         if (!(re instanceof RegExp)) {
             return false;
         }
-        if (re.flags.includes('i')) {
+        if (/[im]/.test(re.flags)) {
             return false;
         }
-        // when including the opening bracket/paren we consider it complex
-        return !/[{[(]/.exec(re.source);
+        // LIKE can only express edge anchors, `.`, `.*` and escaped `.` or `/`, anything else needs the regexp operator
+        return /^\^?(?:[^\\^$.*+?|{}[\]()]|\\[./]|\.\*?)*\$?$/.test(re.source);
     }
     getRegExpParam(re) {
         const value = re.source
-            .replace(/\.\*/g, '%') // .* -> %
-            .replace(/\./g, '_') // .  -> _
-            .replace(/\\_/g, '.') // \. -> .
-            .replace(/^\^/g, '') // remove ^ from start
-            .replace(/\$$/g, ''); // remove $ from end
+            .replace(/^\^/, '') // remove ^ from start
+            .replace(/\$$/, '') // remove $ from end
+            .replace(/\\[./]|\.\*|[.!%_]/g, m => LIKE_REPLACEMENTS[m]);
         if (re.source.startsWith('^') && re.source.endsWith('$')) {
             return value;
         }
@@ -445,7 +453,8 @@ export class QueryBuilderHelper {
         const parts = [];
         const params = [];
         if (this.isSimpleRegExp(cond[key])) {
-            parts.push(`${this.#platform.quoteIdentifier(this.mapper(key, type))} like ?`);
+            const escape = /[!%_]/.test(cond[key].source) ? ` escape '!'` : '';
+            parts.push(`${this.#platform.quoteIdentifier(this.mapper(key, type))} like ?${escape}`);
             params.push(this.getRegExpParam(cond[key]));
             return { sql: parts.join(' and '), params };
         }

package/schema/DatabaseTable.js

@@ -975,17 +975,22 @@ export class DatabaseTable {
             throw new Error(`Index '${name}' on entity '${meta.className}': cannot combine \`expression\` with \`where\` — inline the WHERE clause into the \`expression\` escape hatch, or drop \`expression\` and use structured \`properties\` + \`where\`.`);
         }
         const where = this.processIndexWhere(index.where, meta);
+        const expression = this.processIndexExpression(name, index.expression, meta);
         this.#indexes.push({
             keyName: name,
             columnNames: properties,
             composite: properties.length > 1,
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them.
             // Partial indexes (`where`) must use CREATE [UNIQUE] INDEX form — constraints can't carry predicates.
-            constraint: type !== 'index' && !properties.some((d) => d.includes('.')) && !where,
+            // Raw `create [unique] index` expressions are plain indexes, not constraints.
+            constraint: type !== 'index' &&
+                !properties.some((d) => d.includes('.')) &&
+                !where &&
+                !/^\s*create\s/i.test(expression ?? ''),
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
-            expression: this.processIndexExpression(name, index.expression, meta),
+            expression,
             where,
             options: index.options,
             deferMode: index.deferMode,

package/schema/SchemaComparator.d.ts

@@ -30,7 +30,7 @@ export declare class SchemaComparator {
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable: DatabaseTable, toTable: DatabaseTable, inverseTableDiff?: TableDifference): TableDifference | false;
+    diffTable(fromTable: DatabaseTable, toTable: DatabaseTable, inverseTableDiff?: TableDifference, inverse?: boolean): TableDifference | false;
     /**
      * Try to find columns that only changed their name, rename operations maybe cheaper than add/drop
      * however ambiguities between different possibilities should not lead to renaming at all.

package/schema/SchemaComparator.js

@@ -77,7 +77,7 @@ export class SchemaComparator {
                 diff.newTables[tableName] = toSchema.getTable(tableName);
             }
             else {
-                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName), inverseDiff?.changedTables[tableName]);
+                const tableDifferences = this.diffTable(fromSchema.getTable(tableName), toSchema.getTable(tableName), inverseDiff?.changedTables[tableName], !!inverseDiff);
                 if (tableDifferences !== false) {
                     diff.changedTables[tableName] = tableDifferences;
                 }
@@ -319,7 +319,7 @@ export class SchemaComparator {
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.
      */
-    diffTable(fromTable, toTable, inverseTableDiff) {
+    diffTable(fromTable, toTable, inverseTableDiff, inverse = false) {
         let changes = 0;
         const tableDifferences = {
             name: fromTable.getShortestName(),
@@ -353,7 +353,9 @@ export class SchemaComparator {
             });
             changes++;
         }
-        if (diffPartitioning(fromTable.getPartitioning(), toTable.getPartitioning(), this.#platform.getDefaultSchemaName())) {
+        // partitioning is diffed one way (declared vs. existing), so the down diff has to compare it like the up one did
+        const [existingTable, declaredTable] = inverse ? [toTable, fromTable] : [fromTable, toTable];
+        if (diffPartitioning(existingTable.getPartitioning(), declaredTable.getPartitioning(), this.#platform.getDefaultSchemaName())) {
             tableDifferences.changedPartitioning = {
                 from: fromTable.getPartitioning(),
                 to: toTable.getPartitioning(),
@@ -477,8 +479,10 @@ export class SchemaComparator {
             if (!this.diffExpression(check.expression, toTableCheck.expression)) {
                 continue;
             }
+            // only auto-generated enum checks, a user check tagged with an enum column must be diffed by expression
             if (fromColumn?.enumItems &&
                 toColumn?.enumItems &&
+                check.name === this.#platform.getIndexName(fromTable.name, [fromColumn.name], 'check') &&
                 !this.diffEnumItems(fromColumn.enumItems, toColumn.enumItems)) {
                 continue;
             }
@@ -907,6 +911,7 @@ export class SchemaComparator {
                 ?.replace(/(?<![\w'])_\w+'(.*?)'/g, '$1')
                 .replace(/!=/g, '<>')
                 // `\b` keeps this from firing inside identifiers like `min(...)`
+                .replace(/\bnot\s+in\s*\((.*?)\)/gi, '<> all (array[$1])')
                 .replace(/\bin\s*\((.*?)\)/gi, '= any (array[$1])')
                 // MySQL normalizes count(*) to count(0)
                 .replace(/\bcount\s*\(\s*0\s*\)/gi, 'count(*)')
@@ -922,6 +927,8 @@ export class SchemaComparator {
                 // MySQL adds table/alias prefixes to columns (e.g., a.name or table_name.column vs just column)
                 // Strip these prefixes - match word.word patterns and keep only the last part
                 .replace(/\b\w+\.(\w+)/g, '$1')
+                // PostgreSQL rewrites `x [not] between a and b` to `x >= a and x <= b` (`x < a or x > b`), cast targets are skipped
+                .replace(/(?<!::\s*)\b(?!not\b)(\w+)\s+(not\s+)?between\s+(\S+)\s+and\s+(\S+)/gi, (_, x, not, a, b) => not ? `${x} < ${a} or ${x} > ${b}` : `${x} >= ${a} and ${x} <= ${b}`)
                 // Normalize JOIN syntax: inner join -> join (equivalent in SQL)
                 .replace(/\binner\s+join\b/gi, 'join')
                 // PostgreSQL names an unaliased bare function call after the function itself,

package/schema/SqlSchemaGenerator.d.ts

@@ -38,10 +38,13 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         schema?: string;
     }): string;
     /**
-     * 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).
+     * Foreign keys the referencing table drops or changes in the same diff are left to its own alter, and those of dropped tables are skipped.
      */
-    /** Collects foreign keys from other tables that reference `table` (self-references are excluded — those travel with the rebuild). */
     private getInboundForeignKeys;
+    /**
+     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+     */
     private preAlterTable;
     /**
      * creates new database and connects to it

package/schema/SqlSchemaGenerator.js

@@ -327,14 +327,16 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         // 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 dropsTables = !!options.dropTables && !options.safe;
         const partitioningRebuilds = changedTables
             .filter(changedTable => changedTable.changedPartitioning)
-            .map(diff => ({ diff, inboundForeignKeys: this.getInboundForeignKeys(schemaDiff.fromSchema, diff.toTable) }));
+            .map(diff => ({ diff, inboundForeignKeys: this.getInboundForeignKeys(schemaDiff, diff.toTable, dropsTables) }));
         const alteredTables = changedTables.filter(changedTable => !changedTable.changedPartitioning);
-        this.append(ret, this.helper.getPartitioningRebuildSQL(partitioningRebuilds, options.safe), true);
+        // before the rebuild, so inbound FKs the referencing table drops or changes are gone by then
         for (const changedTable of alteredTables) {
             this.append(ret, this.preAlterTable(changedTable, options.safe), true);
         }
+        this.append(ret, this.helper.getPartitioningRebuildSQL(partitioningRebuilds, options.safe), true);
         for (const changedTable of alteredTables) {
             this.append(ret, this.helper.alterTable(changedTable, options.safe), true);
         }
@@ -394,18 +396,24 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         return this.wrapSchema(ret, options);
     }
     /**
-     * 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).
+     * Foreign keys the referencing table drops or changes in the same diff are left to its own alter, and those of dropped tables are skipped.
      */
-    /** Collects foreign keys from other tables that reference `table` (self-references are excluded — those travel with the rebuild). */
-    getInboundForeignKeys(fromSchema, table) {
+    getInboundForeignKeys(schemaDiff, table, dropsTables) {
         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) {
+        for (const other of schemaDiff.fromSchema.getTables()) {
+            if ((other.name === table.name && other.schema === table.schema) ||
+                (dropsTables && other.getShortestName() in schemaDiff.removedTables)) {
                 continue;
             }
+            const otherDiff = schemaDiff.changedTables[other.getShortestName(false)];
             for (const foreignKey of Object.values(other.getForeignKeys())) {
+                const name = foreignKey.constraintName;
+                if (otherDiff && (name in otherDiff.removedForeignKeys || name in otherDiff.changedForeignKeys)) {
+                    continue;
+                }
                 if (unqualified(foreignKey.referencedTableName) === targetName) {
                     ret.push({ table: other, foreignKey });
                 }
@@ -413,6 +421,9 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         }
         return ret;
     }
+    /**
+     * We need to drop foreign keys first for all tables to allow dropping PK constraints.
+     */
     preAlterTable(diff, safe) {
         const ret = [];
         // removed/changed policies must be dropped before any column type alter, including the pre-alter

package/schema/partitioning.js

@@ -270,18 +270,18 @@ export const diffPartitioning = (from, to, defaultSchema) => {
     if (!from) {
         return true;
     }
-    if (normalizeQuotedIdentifiers(normalizePartitionDefinition(from.definition)) !==
-        normalizeQuotedIdentifiers(normalizePartitionDefinition(to.definition))) {
+    const toDefinition = normalizeQuotedIdentifiers(normalizePartitionDefinition(to.definition));
+    if (normalizeQuotedIdentifiers(normalizePartitionDefinition(from.definition)) !== toDefinition) {
         return true;
     }
-    if (from.partitions.length !== to.partitions.length) {
+    // list/range partitions created outside of metadata (e.g. at runtime) are left unmanaged, hash partitions are not
+    if (toDefinition.startsWith('hash') && from.partitions.length !== to.partitions.length) {
         return true;
     }
     const normalizeSchema = (schema) => (schema && schema !== defaultSchema ? schema : '');
     const serializePartition = (partition) => `${normalizeSchema(partition.schema)}.${partition.name}:${normalizeQuotedIdentifiers(normalizePartitionBound(partition.bound))}`;
-    const fromPartitions = from.partitions.map(serializePartition).sort();
-    const toPartitions = to.partitions.map(serializePartition).sort();
-    return fromPartitions.some((partition, index) => partition !== toPartitions[index]);
+    const fromPartitions = new Set(from.partitions.map(serializePartition));
+    return to.partitions.some(partition => !fromPartitions.has(serializePartition(partition)));
 };
 const SUPPORTED_PARTITION_TYPES = ['hash', 'list', 'range'];
 const isSupportedPartitionType = (value) => SUPPORTED_PARTITION_TYPES.includes(value);