@mikro-orm/sql 7.1.6-dev.9 → 7.1.7-dev.0

package/AbstractSqlDriver.js

@@ -494,6 +494,11 @@ export class AbstractSqlDriver extends DatabaseDriver {
         if (prop.fieldNames.every(name => typeof root[`${relationAlias}__${name}`] === 'undefined')) {
             return;
         }
+        // inline embeddables are mapped via their flattened child props; mapping the embedded root prop
+        // here would leak a raw column value into the snapshot and produce a phantom changeset
+        if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && !meta.embeddable) {
+            return;
+        }
         if (prop.polymorphic && prop.kind !== ReferenceKind.EMBEDDED) {
             const discriminatorAlias = `${relationAlias}__${prop.fieldNames[0]}`;
             const discriminatorValue = root[discriminatorAlias];

package/dialects/mysql/BaseMySqlPlatform.d.ts

@@ -9,10 +9,10 @@ export declare class BaseMySqlPlatform extends AbstractSqlPlatform {
     protected readonly schemaHelper: MySqlSchemaHelper;
     protected readonly exceptionConverter: MySqlExceptionConverter;
     protected readonly ORDER_BY_NULLS_TRANSLATE: {
-        readonly "asc nulls first": "is not null";
-        readonly "asc nulls last": "is null";
-        readonly "desc nulls first": "is not null";
-        readonly "desc nulls last": "is null";
+        readonly "asc nulls first": 'is not null';
+        readonly "asc nulls last": 'is null';
+        readonly "desc nulls first": 'is not null';
+        readonly "desc nulls last": 'is null';
     };
     supportsMultiColumnCountDistinct(): boolean;
     /** @internal */

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -9,6 +9,7 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: {
         'now()': string[];
         'current_timestamp(?)': string[];
+        'curdate()': string[];
         '0': string[];
     };
     private static readonly PARTIAL_INDEX_RE;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -5,6 +5,7 @@ export class MySqlSchemaHelper extends SchemaHelper {
     static DEFAULT_VALUES = {
         'now()': ['now()', 'current_timestamp'],
         'current_timestamp(?)': ['current_timestamp(?)'],
+        'curdate()': ['(current_date)', 'curdate()'],
         '0': ['0', 'false'],
     };
     // Greedy `(.+)` so nested CASE expressions inside the predicate don't trip the match on

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.6-dev.9",
+  "version": "7.1.7-dev.0",
   "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",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.29.2"
+    "kysely": "0.29.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.1.5"
+    "@mikro-orm/core": "^7.1.6"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.6-dev.9"
+    "@mikro-orm/core": "7.1.7-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/CriteriaNode.d.ts

@@ -9,13 +9,13 @@ export declare class CriteriaNode<T extends object> implements ICriteriaNode<T>
     protected readonly metadata: MetadataStorage;
     readonly entityName: EntityName<T>;
     readonly parent?: ICriteriaNode<T> | undefined;
-    readonly key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined;
+    readonly key?: EntityKey<T> | RawQueryFragmentSymbol | undefined;
     readonly validate: boolean;
     readonly strict: boolean;
     payload: any;
     prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: EntityName<T>, parent?: ICriteriaNode<T> | undefined, key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined, validate?: boolean, strict?: boolean);
+    constructor(metadata: MetadataStorage, entityName: EntityName<T>, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | RawQueryFragmentSymbol | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     shouldInline(payload: any): boolean;

package/query/QueryBuilder.d.ts

@@ -236,7 +236,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     #private;
     protected readonly metadata: MetadataStorage;
     protected readonly driver: AbstractSqlDriver;
-    protected readonly context?: Transaction | undefined;
+    protected readonly context?: Transaction;
     protected connectionType?: ConnectionType | undefined;
     protected em?: SqlEntityManager | undefined;
     protected loggerContext?: (LoggingOptions & Dictionary) | undefined;
@@ -253,7 +253,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     /**
      * @internal
      */
-    constructor(entityName: EntityName<Entity> | QueryBuilder<Entity, any, any, any>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Transaction | undefined, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
+    constructor(entityName: EntityName<Entity> | QueryBuilder<Entity, any, any, any>, metadata: MetadataStorage, driver: AbstractSqlDriver, context?: Transaction, alias?: string, connectionType?: ConnectionType | undefined, em?: SqlEntityManager | undefined, loggerContext?: (LoggingOptions & Dictionary) | undefined);
     /**
      * Creates a SELECT query, specifying the fields to retrieve.
      *
@@ -982,6 +982,22 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
      */
     private processNestedJoins;
     private hasToManyJoins;
+    /**
+     * Resolves a `persist: false` virtual field referenced in `orderBy` (e.g. `qb.as('reviewCount')` or a
+     * `raw()` fragment aliased in the select) to the alias and SQL expression it was selected under. The
+     * alias is used to order the outer query; the raw expression is inlined into `min(...)` inside the
+     * pagination sub-query, where dialects like PostgreSQL cannot reference a select alias.
+     */
+    protected resolveVirtualField(propName: string, fieldName: string): {
+        alias: string;
+        expr: string;
+    } | undefined;
+    /**
+     * Rewrites `orderBy` keys that reference a `persist: false` virtual field selected via `qb.as(alias)` so
+     * they point at the actual select alias. The mapper would otherwise resolve such a key to the property's
+     * naming-strategy column name, which does not exist when the alias literal differs (e.g. `reviewCount`).
+     */
+    private rewriteVirtualFieldOrderBy;
     protected wrapPaginateSubQuery(meta: EntityMetadata): void;
     /**
      * Wraps the inner query (which has ROW_NUMBER in SELECT) with an outer query

package/query/QueryBuilder.js

@@ -4,6 +4,12 @@ import { JoinType, QueryType } from './enums.js';
 import { QueryBuilderHelper } from './QueryBuilderHelper.js';
 import { CriteriaNodeFactory } from './CriteriaNodeFactory.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
+/**
+ * Tags a {@link NativeQueryBuilder} produced by `qb.as(alias)` with the alias literal, so it can be
+ * matched back to its `orderBy`/pagination usage. A symbol is used (rather than a string key) so the
+ * tag survives `clone()` — {@link Utils.copy} preserves non-enumerable symbols but drops string keys.
+ */
+const VirtualFieldAlias = Symbol('virtualFieldAlias');
 /** Matches 'path as alias' — safe because ORM property names are JS identifiers (no spaces). */
 const FIELD_ALIAS_RE = /^(.+?)\s+as\s+(\w+)$/i;
 /**
@@ -816,7 +822,7 @@ export class QueryBuilder {
         Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this.#state.groupBy, 'groupBy', schema)), isNotEmptyObject(this.#state.groupBy));
         Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this.#state.having, qb, undefined, 'having'), isNotEmptyObject(this.#state.having));
         Utils.runIfNotEmpty(() => {
-            const queryOrder = this.helper.getQueryOrder(this.type, this.#state.orderBy, this.#state.populateMap, this.#state.collation);
+            const queryOrder = this.helper.getQueryOrder(this.type, this.rewriteVirtualFieldOrderBy(this.#state.orderBy), this.#state.populateMap, this.#state.collation);
             if (queryOrder.length > 0) {
                 const sql = Utils.unique(queryOrder).join(', ');
                 qb.orderBy(sql);
@@ -1195,8 +1201,8 @@ export class QueryBuilder {
             finalAlias = meta.properties[alias]?.fieldNames[0] ?? alias;
         }
         qb.as(finalAlias);
-        // tag the instance, so it is possible to detect it easily
-        Object.defineProperty(qb, '__as', { enumerable: false, value: finalAlias });
+        // tag the instance, so it is possible to detect it easily (symbol survives clone, see VirtualFieldAlias)
+        Object.defineProperty(qb, VirtualFieldAlias, { value: finalAlias });
         return qb;
     }
     /**
@@ -2070,6 +2076,72 @@ export class QueryBuilder {
             return [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(join.prop.kind);
         });
     }
+    /**
+     * Resolves a `persist: false` virtual field referenced in `orderBy` (e.g. `qb.as('reviewCount')` or a
+     * `raw()` fragment aliased in the select) to the alias and SQL expression it was selected under. The
+     * alias is used to order the outer query; the raw expression is inlined into `min(...)` inside the
+     * pagination sub-query, where dialects like PostgreSQL cannot reference a select alias.
+     */
+    resolveVirtualField(propName, fieldName) {
+        const field = this.#state.fields?.find(f => {
+            if (f instanceof NativeQueryBuilder) {
+                const as = f[VirtualFieldAlias];
+                return as === propName || as === fieldName;
+            }
+            // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
+            return isRaw(f) && (f.sql.includes(propName) || f.sql.includes(fieldName));
+        });
+        if (field instanceof NativeQueryBuilder) {
+            const alias = field[VirtualFieldAlias];
+            const rendered = field.toString();
+            // strip the known trailing alias via the platform quoting, so it works on every dialect (mssql uses `[...]`)
+            const suffix = ` as ${this.platform.quoteIdentifier(alias)}`;
+            return { alias, expr: rendered.endsWith(suffix) ? rendered.slice(0, -suffix.length) : rendered };
+        }
+        if (isRaw(field)) {
+            const compiled = this.platform.formatQuery(field.sql, field.params);
+            const close = compiled[compiled.length - 1];
+            const open = close === ']' ? '[' : close === '"' ? '"' : close === '`' ? '`' : undefined;
+            // scan back for the trailing `as <quoted alias>` (linear, avoids regex backtracking on user SQL)
+            const start = open ? compiled.lastIndexOf(open, compiled.length - 2) : -1;
+            if (start >= 4 && compiled.slice(start - 4, start) === ' as ') {
+                return { alias: compiled.slice(start + 1, -1), expr: compiled.slice(0, start - 4) };
+            }
+            return { alias: fieldName, expr: compiled };
+        }
+        return undefined;
+    }
+    /**
+     * Rewrites `orderBy` keys that reference a `persist: false` virtual field selected via `qb.as(alias)` so
+     * they point at the actual select alias. The mapper would otherwise resolve such a key to the property's
+     * naming-strategy column name, which does not exist when the alias literal differs (e.g. `reviewCount`).
+     */
+    rewriteVirtualFieldOrderBy(orderBy) {
+        // only aliased sub-queries (`qb.as(...)`) or `raw()` fragments can back a virtual field, skip otherwise
+        if (!this.#state.fields?.some(f => f instanceof NativeQueryBuilder || isRaw(f))) {
+            return orderBy;
+        }
+        return orderBy.map(orderMap => {
+            const out = {};
+            for (const key of Utils.getObjectQueryKeys(orderMap)) {
+                const direction = orderMap[key];
+                if (!RawQueryFragment.isKnownFragmentSymbol(key)) {
+                    const [a, f] = this.helper.splitField(key);
+                    const prop = this.helper.getProperty(f, a);
+                    if (prop?.persist === false && !prop.formula && !prop.embedded) {
+                        const fieldName = this.helper.mapper(key, this.type, undefined, null);
+                        const virtual = this.resolveVirtualField(f, fieldName);
+                        if (virtual) {
+                            out[raw(this.platform.quoteIdentifier(virtual.alias))] = direction;
+                            continue;
+                        }
+                    }
+                }
+                out[key] = direction;
+            }
+            return out;
+        });
+    }
     wrapPaginateSubQuery(meta) {
         const schema = this.getSchema(this.mainAlias);
         const pks = this.prepareFields(meta.primaryKeys, 'sub-query', schema);
@@ -2086,7 +2158,6 @@ export class QueryBuilder {
         if (this.#state.offset) {
             subQuery.offset(this.#state.offset);
         }
-        const addToSelect = [];
         if (this.#state.orderBy.length > 0) {
             const orderBy = [];
             for (const orderMap of this.#state.orderBy) {
@@ -2100,42 +2171,19 @@ export class QueryBuilder {
                     const prop = this.helper.getProperty(f, a);
                     const type = this.platform.castColumn(prop);
                     const fieldName = this.helper.mapper(field, this.type, undefined, null);
-                    if (!prop?.persist && !prop?.formula && !prop?.hasConvertToJSValueSQL && !pks.includes(fieldName)) {
-                        addToSelect.push(fieldName);
-                    }
-                    const quoted = this.platform.quoteIdentifier(fieldName);
-                    const key = raw(`min(${quoted}${type})`);
-                    orderBy.push({ [key]: direction });
+                    // virtual fields (e.g. `qb.as(...)`) have no column to reference inside `min()`; inline their
+                    // expression instead, as a select alias is not resolvable there on some dialects (e.g. PostgreSQL)
+                    const virtual = !prop?.persist && !prop?.formula && !prop?.hasConvertToJSValueSQL && !pks.includes(fieldName)
+                        ? this.resolveVirtualField(f, fieldName)
+                        : undefined;
+                    const expr = virtual ? virtual.expr : this.platform.quoteIdentifier(fieldName);
+                    orderBy.push({ [raw(`min(${expr}${type})`)]: direction });
                 }
             }
             subQuery.orderBy(orderBy);
         }
         subQuery.#state.finalized = true;
         const innerQuery = subQuery.as(this.mainAlias.aliasName).clear('select').select(pks);
-        if (addToSelect.length > 0) {
-            addToSelect.forEach(prop => {
-                const field = this.#state.fields.find(field => {
-                    if (typeof field === 'object' && field && '__as' in field) {
-                        return field.__as === prop;
-                    }
-                    if (isRaw(field)) {
-                        // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
-                        return field.sql.includes(prop);
-                    }
-                    return false;
-                });
-                /* v8 ignore next */
-                if (isRaw(field)) {
-                    innerQuery.select(field);
-                }
-                else if (field instanceof NativeQueryBuilder) {
-                    innerQuery.select(field.toRaw());
-                }
-                else if (field) {
-                    innerQuery.select(field);
-                }
-            });
-        }
         // multiple sub-queries are needed to get around mysql limitations with order by + limit + where in + group by (o.O)
         // https://stackoverflow.com/questions/17892762/mysql-this-version-of-mysql-doesnt-yet-support-limit-in-all-any-some-subqu
         const subSubQuery = this.platform.createNativeQueryBuilder();

package/schema/DatabaseSchema.js

@@ -230,6 +230,12 @@ export class DatabaseSchema {
             table.addIndex(meta, { properties: pkPropsForIndex.map(prop => prop.name) }, 'primary');
             for (const check of meta.checks) {
                 const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
+                // In TPT, inherited columns live on the parent table only, so a check
+                // that references such a column must not be emitted onto the child
+                // table, where that column does not exist.
+                if (meta.inheritanceType === 'tpt' && meta.tptParent && columnName && !table.hasColumn(columnName)) {
+                    continue;
+                }
                 const expression = isRaw(check.expression)
                     ? platform.formatQuery(check.expression.sql, check.expression.params)
                     : check.expression;

package/schema/SchemaComparator.js

@@ -894,7 +894,8 @@ export class SchemaComparator {
         // e.g. quotes might be added (https://github.com/mikro-orm/mikro-orm/issues/3827)
         const simplify = (str) => {
             return (str
-                ?.replace(/_\w+'(.*?)'/g, '$1')
+                // lookbehind: only strip a real charset introducer, never an underscore inside a literal like 'a_b'
+                ?.replace(/(?<![\w'])_\w+'(.*?)'/g, '$1')
                 .replace(/!=/g, '<>')
                 .replace(/in\s*\((.*?)\)/gi, '= any (array[$1])')
                 // MySQL normalizes count(*) to count(0)

package/typings.d.ts

@@ -359,7 +359,10 @@ type InferColumnValue<TBuilder, TProcessOnCreate extends boolean> = TBuilder ext
         value: infer Value;
     };
     '~options': infer TOptions;
-} ? MaybeNever<MaybeGenerated<MaybeJoinKey<Value, TOptions>, TOptions, TProcessOnCreate>, TOptions> : never;
+} ? MaybeNever<MaybeGenerated<MaybeJoinKey<MaybeArray<Value, TOptions>, TOptions>, TOptions, TProcessOnCreate>, TOptions> : never;
+type MaybeArray<TValue, TOptions> = TOptions extends {
+    array: true;
+} ? TValue[] : TValue;
 type MaybeGenerated<TValue, TOptions, TProcessOnCreate extends boolean> = TOptions extends {
     nullable: true;
 } ? TValue | null : TOptions extends {