@mikro-orm/sql 7.1.6-dev.14 → 7.1.6-dev.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.6-dev.14",
+  "version": "7.1.6-dev.16",
   "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"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.6-dev.14"
+    "@mikro-orm/core": "7.1.6-dev.16"
   },
   "engines": {
     "node": ">= 22.17.0"

package/query/QueryBuilder.d.ts

@@ -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();