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

package/AbstractSqlDriver.js

@@ -1248,6 +1248,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (owners.length === 0) {
             return {};
         }
+        // The pivot order is recomputed via `getPivotOrderBy`, so the parent `populateOrderBy` must not leak
+        // into the pivot subquery — its keys reference the parent entity, not the pivot (GH #7910).
+        if (options?.populateOrderBy != null) {
+            options = { ...options, populateOrderBy: undefined };
+        }
         const pivotMeta = this.metadata.get(prop.pivotEntity);
         if (prop.discriminatorColumn && QueryHelper.isUnionTargetPolymorphic(prop)) {
             return this.loadFromUnionTargetPolymorphicPivotTable(prop, owners, where, orderBy, ctx, options, pivotJoin);
@@ -2209,6 +2214,20 @@ export class AbstractSqlDriver extends DatabaseDriver {
                 const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
                 const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true }) ?? parentAlias;
                 if (!join) {
+                    // an owner to-one relation that is not joined (e.g. ordering a populated collection by such
+                    // a relation's primary key) can be ordered by its local FK columns, matching the `select-in`
+                    // and `balanced` strategies instead of silently dropping the clause
+                    if (prop.owner &&
+                        [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                        Utils.isPlainObject(childOrder)) {
+                        for (const childField of Utils.getObjectQueryKeys(childOrder)) {
+                            const idx = prop.referencedPKs.indexOf(childField);
+                            const order = childOrder[childField];
+                            if (idx !== -1 && order) {
+                                orderBy.push({ [`${parentAlias}.${prop.joinColumns[idx]}`]: order });
+                            }
+                        }
+                    }
                     continue;
                 }
                 if (join &&

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -603,7 +603,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             .map(p => {
             const dir = p.direction === 'in' ? '' : `${p.direction.toUpperCase()} `;
             const def = p.defaultRaw ? ` default ${p.defaultRaw}` : '';
-            return `${dir}${this.platform.quoteIdentifier(p.name)} ${p.type}${def}`;
+            const name = p.name ? `${this.platform.quoteIdentifier(p.name)} ` : '';
+            return `${dir}${name}${p.type}${def}`;
         })
             .join(', ');
     }
@@ -614,15 +615,16 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return signature.split(/,(?![^()]*\))/).map(part => {
             const trimmed = part.trim();
             // INOUT before IN/OUT, with required trailing space so identifiers like `input` aren't
-            // mis-parsed as a direction keyword.
-            const match = /^(?:(INOUT|VARIADIC|IN|OUT)\s+)?(?:"((?:[^"]|"")+)"|([\w$]+))\s+(.+?)(?:\s+default\s+.+)?$/i.exec(trimmed);
+            // mis-parsed as a direction keyword. The name is optional — `pg_get_function_arguments`
+            // omits it for unnamed parameters (e.g. `text`), leaving just the type.
+            const match = /^(?:(INOUT|VARIADIC|IN|OUT)\s+)?(?:(?:"((?:[^"]|"")+)"|([\w$]+))\s+)?(.+?)(?:\s+default\s+.+)?$/i.exec(trimmed);
             /* v8 ignore next 3: defensive guard for unexpected `pg_get_function_arguments` output shapes */
             if (!match) {
                 throw new Error(`Could not parse PostgreSQL routine parameter signature: ${JSON.stringify(trimmed)}`);
             }
             const dirRaw = (match[1] ?? 'in').toLowerCase();
             const direction = dirRaw === 'inout' ? 'inout' : dirRaw === 'out' ? 'out' : 'in';
-            const name = match[2] != null ? match[2].replaceAll('""', '"') : match[3];
+            const name = match[2] != null ? match[2].replaceAll('""', '"') : (match[3] ?? '');
             return {
                 name,
                 type: match[4].trim(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.5-dev.9",
+  "version": "7.1.5",
   "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.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.1.4"
+    "@mikro-orm/core": "^7.1.5"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.5-dev.9"
+    "@mikro-orm/core": "7.1.5"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/ObjectCriteriaNode.js

@@ -39,7 +39,11 @@ export class ObjectCriteriaNode extends CriteriaNode {
                         throw new Error('Mixing collection operators with other filters is not allowed.');
                     }
                     const payload = this.payload[key].unwrap();
-                    const qb2 = qb.clone(true, ['schema']);
+                    // entities with a fixed schema must resolve the `from` table's own schema in the subquery,
+                    // otherwise a nested operator inherits the root entity's schema (GH #7894); for wildcard or
+                    // schema-less entities the schema is resolved dynamically and needs to be carried over
+                    const fixedSchema = parentMeta.schema && parentMeta.schema !== '*';
+                    const qb2 = qb.clone(true, fixedSchema ? undefined : ['schema']);
                     const joinAlias = qb2.getNextAlias(this.prop.targetMeta.class);
                     const sub = qb2
                         .from(parentMeta.class)

package/query/QueryBuilderHelper.js

@@ -600,6 +600,8 @@ export class QueryBuilderHelper {
                 }
                 return `(${tmp.join(', ')})`;
             }
+            // array custom types (e.g. `$contains`/`$overlap` on `string[]` columns) are converted to a single
+            // array literal, so we emit a single bound parameter — not one per element wrapped in a tuple
             if (prop?.customType instanceof ArrayType) {
                 const item = prop.customType.convertToDatabaseValue(value, this.#platform, {
                     fromQuery: true,
@@ -607,10 +609,9 @@ export class QueryBuilderHelper {
                     mode: 'query',
                 });
                 params.push(item);
+                return '?';
             }
-            else {
-                value.forEach(p => params.push(p));
-            }
+            value.forEach(p => params.push(p));
             return `(${value.map(() => '?').join(', ')})`;
         }
         if (value === null) {

package/schema/DatabaseSchema.js

@@ -1,5 +1,6 @@
 import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
+import { normalizeViewDefinition } from './SchemaHelper.js';
 import { getTablePartitioning } from './partitioning.js';
 /**
  * @internal
@@ -364,7 +365,7 @@ export class DatabaseSchema {
     }
     static getViewDefinition(meta, em, platform) {
         if (typeof meta.expression === 'string') {
-            return meta.expression;
+            return normalizeViewDefinition(meta.expression);
         }
         // Expression is a function, need to evaluate it
         /* v8 ignore next */
@@ -378,7 +379,7 @@ export class DatabaseSchema {
         }
         /* v8 ignore next */
         if (typeof result === 'string') {
-            return result;
+            return normalizeViewDefinition(result);
         }
         /* v8 ignore next */
         if (isRaw(result)) {

package/schema/SchemaHelper.d.ts

@@ -6,6 +6,17 @@ import type { DatabaseSchema } from './DatabaseSchema.js';
 import type { DatabaseTable } from './DatabaseTable.js';
 /** Flattens `;\n` boundaries so the schema-generator's statement splitter doesn't break the routine DDL apart. Other whitespace is preserved. */
 export declare function stripStatementNewlines(body: string): string;
+/**
+ * Strips SQL line comments and blank lines from a view definition. Comments are dropped by the
+ * database on `create view` anyway, and a `--` comment would otherwise comment out the rest of the
+ * definition once newlines are collapsed; blank lines act as statement separators in the
+ * schema-generator's statement splitter, which would break the view DDL apart.
+ *
+ * Comment stripping is not string-literal aware, so a `--` inside a string literal (or `a--b` style
+ * arithmetic) is treated as a comment — an accepted tradeoff to avoid a full SQL tokenizer.
+ * @see https://github.com/mikro-orm/mikro-orm/issues/7875
+ */
+export declare function normalizeViewDefinition(definition: string): string;
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;

package/schema/SchemaHelper.js

@@ -3,6 +3,24 @@ import { isRaw, Utils, } from '@mikro-orm/core';
 export function stripStatementNewlines(body) {
     return body.replace(/;[\t ]*\r?\n/g, '; ');
 }
+/**
+ * Strips SQL line comments and blank lines from a view definition. Comments are dropped by the
+ * database on `create view` anyway, and a `--` comment would otherwise comment out the rest of the
+ * definition once newlines are collapsed; blank lines act as statement separators in the
+ * schema-generator's statement splitter, which would break the view DDL apart.
+ *
+ * Comment stripping is not string-literal aware, so a `--` inside a string literal (or `a--b` style
+ * arithmetic) is treated as a comment — an accepted tradeoff to avoid a full SQL tokenizer.
+ * @see https://github.com/mikro-orm/mikro-orm/issues/7875
+ */
+export function normalizeViewDefinition(definition) {
+    return definition
+        .replace(/--[^\n]*/g, '')
+        .split('\n')
+        .filter(line => line.trim() !== '')
+        .join('\n')
+        .trim();
+}
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export class SchemaHelper {
     platform;

package/schema/SqlSchemaGenerator.js

@@ -130,7 +130,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
             await this.execute(this.helper.disableForeignKeysSQL());
         }
         const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
-        for (const meta of this.getOrderedMetadata(schema).reverse()) {
+        for (const meta of this.getOrderedMetadataForClear(schema).reverse()) {
             try {
                 await this.driver
                     .createQueryBuilder(meta.class, this.em?.getTransactionContext(), 'write', false)