@mikro-orm/sql 7.0.0-rc.0 → 7.0.0-rc.1

package/query/QueryBuilder.js

@@ -3,6 +3,8 @@ import { JoinType, QueryType } from './enums.js';
 import { QueryBuilderHelper } from './QueryBuilderHelper.js';
 import { CriteriaNodeFactory } from './CriteriaNodeFactory.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
+/** Matches 'path as alias' — safe because ORM property names are JS identifiers (no spaces). */
+const FIELD_ALIAS_RE = /^(.+?)\s+as\s+(\w+)$/i;
 /**
  * SQL query builder with fluent interface.
  *
@@ -67,6 +69,7 @@ export class QueryBuilder {
     _joinedProps = new Map();
     _cache;
     _indexHint;
+    _collation;
     _comments = [];
     _hintComments = [];
     flushMode;
@@ -103,8 +106,19 @@ export class QueryBuilder {
         this.ensureNotFinalized();
         this._fields = Utils.asArray(fields).flatMap(f => {
             if (typeof f !== 'string') {
+                // Normalize sql.ref('prop') and sql.ref('prop').as('alias') to string form
+                if (isRaw(f) && f.sql === '??' && f.params.length === 1) {
+                    return this.resolveNestedPath(String(f.params[0]));
+                }
+                if (isRaw(f) && f.sql === '?? as ??' && f.params.length === 2) {
+                    return `${this.resolveNestedPath(String(f.params[0]))} as ${String(f.params[1])}`;
+                }
                 return f;
             }
+            const asMatch = f.match(FIELD_ALIAS_RE);
+            if (asMatch) {
+                return `${this.resolveNestedPath(asMatch[1].trim())} as ${asMatch[2]}`;
+            }
             return this.resolveNestedPath(f);
         });
         if (distinct) {
@@ -307,7 +321,7 @@ export class QueryBuilder {
         for (const p of targetMeta.getPrimaryProps()) {
             fields.push(...this.driver.mapPropToFieldNames(this, p, alias, targetMeta, schema));
         }
-        if (explicitFields) {
+        if (explicitFields && explicitFields.length > 0) {
             for (const field of explicitFields) {
                 const [a, f] = this.helper.splitField(field);
                 const p = targetMeta.properties[f];
@@ -321,7 +335,7 @@ export class QueryBuilder {
         }
         targetMeta.props
             .filter(prop => {
-            if (!explicitFields) {
+            if (!explicitFields || explicitFields.length === 0) {
                 return this.platform.shouldHaveColumn(prop, populate);
             }
             return prop.primary && !explicitFields.includes(prop.name) && !explicitFields.includes(`${alias}.${prop.name}`);
@@ -457,7 +471,18 @@ export class QueryBuilder {
         if (reset) {
             this._orderBy = [];
         }
-        Utils.asArray(orderBy).forEach(o => {
+        const selectAliases = this.getSelectAliases();
+        Utils.asArray(orderBy).forEach(orig => {
+            // Shallow clone to avoid mutating the caller's object — safe because the clone
+            // is only used within this loop iteration and `orig` is not referenced afterward.
+            const o = { ...orig };
+            // Wrap known select aliases in raw() so they bypass property validation and alias prefixing
+            for (const key of Object.keys(o)) {
+                if (selectAliases.has(key)) {
+                    o[raw('??', [key])] = o[key];
+                    delete o[key];
+                }
+            }
             this.helper.validateQueryOrder(o);
             const processed = QueryHelper.processWhere({
                 where: o,
@@ -476,10 +501,27 @@ export class QueryBuilder {
         });
         return this;
     }
+    /** Collect custom aliases from select fields (stored as 'resolved as alias' strings by select()). */
+    getSelectAliases() {
+        const aliases = new Set();
+        for (const field of this._fields ?? []) {
+            if (typeof field === 'string') {
+                const m = field.match(FIELD_ALIAS_RE);
+                if (m) {
+                    aliases.add(m[2]);
+                }
+            }
+        }
+        return aliases;
+    }
     groupBy(fields) {
         this.ensureNotFinalized();
         this._groupBy = Utils.asArray(fields).flatMap(f => {
             if (typeof f !== 'string') {
+                // Normalize sql.ref('prop') to string for proper formula resolution
+                if (isRaw(f) && f.sql === '??' && f.params.length === 1) {
+                    return this.resolveNestedPath(String(f.params[0]));
+                }
                 return f;
             }
             return this.resolveNestedPath(f);
@@ -501,7 +543,7 @@ export class QueryBuilder {
         if (typeof cond === 'string') {
             cond = { [raw(`(${cond})`, params)]: [] };
         }
-        const processed = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond, undefined, undefined, false).process(this);
+        const processed = CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, cond, undefined, undefined, false).process(this, { type: 'having' });
         if (!this._having || !operator) {
             this._having = processed;
         }
@@ -638,6 +680,14 @@ export class QueryBuilder {
         this._indexHint = sql;
         return this;
     }
+    /**
+     * Adds COLLATE clause to ORDER BY expressions.
+     */
+    collation(collation) {
+        this.ensureNotFinalized();
+        this._collation = collation;
+        return this;
+    }
     /**
      * Prepend comment to the sql query using the syntax `/* ... *‍/`. Some characters are forbidden such as `/*, *‍/` and `?`.
      */
@@ -682,7 +732,7 @@ export class QueryBuilder {
         Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy', schema)), isNotEmptyObject(this._groupBy));
         Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(this.type, this._having, qb, undefined, 'having'), isNotEmptyObject(this._having));
         Utils.runIfNotEmpty(() => {
-            const queryOrder = this.helper.getQueryOrder(this.type, this._orderBy, this._populateMap);
+            const queryOrder = this.helper.getQueryOrder(this.type, this._orderBy, this._populateMap, this._collation);
             if (queryOrder.length > 0) {
                 const sql = Utils.unique(queryOrder).join(', ');
                 qb.orderBy(sql);
@@ -1015,7 +1065,7 @@ export class QueryBuilder {
         // clone array/object properties
         const properties = [
             'flags', '_populate', '_populateWhere', '_populateFilter', '__populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
-            '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
+            '_schema', '_indexHint', '_collation', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
             '_comments', '_hintComments', 'aliasCounter',
         ];
         for (const prop of Object.keys(this)) {
@@ -1167,14 +1217,23 @@ export class QueryBuilder {
     }
     prepareFields(fields, type = 'where', schema) {
         const ret = [];
-        const getFieldName = (name) => {
-            return this.helper.mapper(name, this.type, undefined, type === 'groupBy' ? null : undefined, schema);
+        const getFieldName = (name, customAlias) => {
+            const alias = customAlias ?? (type === 'groupBy' ? null : undefined);
+            return this.helper.mapper(name, this.type, undefined, alias, schema);
         };
-        fields.forEach(field => {
-            if (typeof field !== 'string') {
-                ret.push(field);
+        fields.forEach(originalField => {
+            if (typeof originalField !== 'string') {
+                ret.push(originalField);
                 return;
             }
+            // Strip 'as alias' suffix if present — the alias is passed to mapper at the end
+            let field = originalField;
+            let customAlias;
+            const asMatch = originalField.match(FIELD_ALIAS_RE);
+            if (asMatch) {
+                field = asMatch[1].trim();
+                customAlias = asMatch[2];
+            }
             const join = Object.keys(this._joins).find(k => field === k.substring(0, k.indexOf('#')));
             if (join && type === 'where') {
                 ret.push(...this.helper.mapJoinColumns(this.type, this._joins[join]));
@@ -1192,10 +1251,13 @@ export class QueryBuilder {
             if (prop?.embedded || (prop?.kind === ReferenceKind.EMBEDDED && prop.object)) {
                 const name = prop.embeddedPath?.join('.') ?? prop.fieldNames[0];
                 const aliased = this._aliases[a] ? `${a}.${name}` : name;
-                ret.push(getFieldName(aliased));
+                ret.push(getFieldName(aliased, customAlias));
                 return;
             }
             if (prop?.kind === ReferenceKind.EMBEDDED) {
+                if (customAlias) {
+                    throw new Error(`Cannot use 'as ${customAlias}' alias on embedded property '${field}' because it expands to multiple columns. Alias individual fields instead (e.g. '${field}.propertyName as ${customAlias}').`);
+                }
                 const nest = (prop) => {
                     for (const childProp of Object.values(prop.embeddedProps)) {
                         if (childProp.fieldNames && (childProp.kind !== ReferenceKind.EMBEDDED || childProp.object) && childProp.persist !== false) {
@@ -1209,11 +1271,14 @@ export class QueryBuilder {
                 nest(prop);
                 return;
             }
-            if (prop && prop.fieldNames.length > 1) {
+            if (prop && prop.fieldNames.length > 1 && !prop.fieldNames.includes(f)) {
+                if (customAlias) {
+                    throw new Error(`Cannot use 'as ${customAlias}' alias on '${field}' because it expands to multiple columns (${prop.fieldNames.join(', ')}).`);
+                }
                 ret.push(...prop.fieldNames.map(f => getFieldName(f)));
                 return;
             }
-            ret.push(getFieldName(field));
+            ret.push(getFieldName(field, customAlias));
         });
         const requiresSQLConversion = this.mainAlias.meta.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false);
         if (this.flags.has(QueryFlag.CONVERT_CUSTOM_TYPES) &&
@@ -1528,7 +1593,7 @@ export class QueryBuilder {
         if (!this.flags.has(QueryFlag.DISABLE_PAGINATE) && this._groupBy.length === 0 && this.hasToManyJoins()) {
             this.flags.add(QueryFlag.PAGINATE);
         }
-        if (meta && this.flags.has(QueryFlag.PAGINATE) && !this.flags.has(QueryFlag.DISABLE_PAGINATE) && (this._limit > 0 || this._offset > 0)) {
+        if (meta && !meta.virtual && this.flags.has(QueryFlag.PAGINATE) && !this.flags.has(QueryFlag.DISABLE_PAGINATE) && (this._limit > 0 || this._offset > 0)) {
             this.wrapPaginateSubQuery(meta);
         }
         if (meta && (this.flags.has(QueryFlag.UPDATE_SUB_QUERY) || this.flags.has(QueryFlag.DELETE_SUB_QUERY))) {

package/query/QueryBuilderHelper.d.ts

@@ -52,8 +52,8 @@ export declare class QueryBuilderHelper {
     private getValueReplacement;
     private getOperatorReplacement;
     validateQueryOrder<T>(orderBy: QueryOrderMap<T>): void;
-    getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string[];
-    getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string[];
+    getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>, collation?: string): string[];
+    getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>, collation?: string): string[];
     finalize(type: QueryType, qb: NativeQueryBuilder, meta?: EntityMetadata, data?: Dictionary, returning?: InternalField<any>[]): void;
     splitField<T>(field: EntityKey<T>, greedyAlias?: boolean): [string, EntityKey<T>, string | undefined];
     getLockSQL(qb: NativeQueryBuilder, lockMode: LockMode, lockTables?: string[], joinsMap?: Dictionary<JoinOptions>): void;

package/query/QueryBuilderHelper.js

@@ -110,8 +110,8 @@ export class QueryBuilderHelper {
         }
         if (prop?.formula) {
             const alias2 = this.platform.quoteIdentifier(a).toString();
-            const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]).toString();
-            const as = alias === null ? '' : ` as ${aliased}`;
+            const aliasName = alias === undefined ? prop.fieldNames[0] : alias;
+            const as = aliasName === null ? '' : ` as ${this.platform.quoteIdentifier(aliasName)}`;
             const meta = this.aliasMap[a]?.meta ?? this.metadata.get(this.entityName);
             const table = this.createFormulaTable(alias2, meta, schema);
             const columns = meta.createColumnMappingObject(p => this.getTPTAliasForProperty(p.name, a), alias2);
@@ -605,20 +605,20 @@ export class QueryBuilderHelper {
             ].join('\n'));
         }
     }
-    getQueryOrder(type, orderBy, populate) {
+    getQueryOrder(type, orderBy, populate, collation) {
         if (Array.isArray(orderBy)) {
-            return orderBy.flatMap(o => this.getQueryOrder(type, o, populate));
+            return orderBy.flatMap(o => this.getQueryOrder(type, o, populate, collation));
         }
-        return this.getQueryOrderFromObject(type, orderBy, populate);
+        return this.getQueryOrderFromObject(type, orderBy, populate, collation);
     }
-    getQueryOrderFromObject(type, orderBy, populate) {
+    getQueryOrderFromObject(type, orderBy, populate, collation) {
         const ret = [];
         for (const key of Utils.getObjectQueryKeys(orderBy)) {
             const direction = orderBy[key];
             const order = typeof direction === 'number' ? QueryOrderNumeric[direction] : direction;
             if (Raw.isKnownFragmentSymbol(key)) {
                 const raw = Raw.getKnownFragment(key);
-                ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
+                ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order, collation));
                 continue;
             }
             for (const f of Utils.splitPrimaryKeys(key)) {
@@ -638,10 +638,10 @@ export class QueryBuilderHelper {
                     colPart = this.platform.formatQuery(colPart.sql, colPart.params);
                 }
                 if (Array.isArray(order)) {
-                    order.forEach(part => ret.push(...this.getQueryOrderFromObject(type, part, populate)));
+                    order.forEach(part => ret.push(...this.getQueryOrderFromObject(type, part, populate, collation)));
                 }
                 else {
-                    ret.push(...this.platform.getOrderByExpression(colPart, order));
+                    ret.push(...this.platform.getOrderByExpression(colPart, order, collation));
                 }
             }
         }

package/schema/SchemaComparator.js

@@ -165,6 +165,7 @@ export class SchemaComparator {
         if (this.diffComment(fromTable.comment, toTable.comment)) {
             tableDifferences.changedComment = toTable.comment;
             this.log(`table comment changed for ${tableDifferences.name}`, { fromTableComment: fromTable.comment, toTableComment: toTable.comment });
+            changes++;
         }
         const fromTableColumns = fromTable.getColumns();
         const toTableColumns = toTable.getColumns();