@mikro-orm/knex 6.0.3-dev.4 → 6.0.3-dev.6

package/AbstractSqlDriver.js

@@ -699,6 +699,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             for (const field of targetFields) {
                 const f = field.toString();
                 fields.unshift(f.includes('.') ? field : `${targetAlias}.${f}`);
+                if (core_1.RawQueryFragment.isKnownFragment(field)) {
+                    qb.rawFragments.add(f);
+                }
             }
             // we need to handle 1:1 owner auto-joins explicitly, as the QB type is the pivot table, not the target
             populate.forEach(hint => {
@@ -722,6 +725,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         const res = owners.length ? await this.rethrow(qb.execute('all', { mergeResults: false, mapResults: false })) : [];
         const items = res.map((row) => super.mapResult(row, prop.targetMeta));
+        qb.clearRawFragmentsCache();
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
         owners.forEach(owner => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.3-dev.4",
+  "version": "6.0.3-dev.6",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^6.0.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.3-dev.4"
+    "@mikro-orm/core": "6.0.3-dev.6"
   }
 }

package/query/QueryBuilder.d.ts

@@ -54,6 +54,8 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     __populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;
     /** @internal */
     _populateMap: Dictionary<string>;
+    /** @internal */
+    readonly rawFragments: Set<string>;
     private aliasCounter;
     private flags;
     private finalized;
@@ -157,6 +159,10 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
     from<T extends AnyEntity<T> = AnyEntity>(target: QueryBuilder<T>, aliasName?: string): SelectQueryBuilder<T>;
     from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T>): SelectQueryBuilder<T>;
     getKnexQuery(processVirtualEntity?: boolean): Knex.QueryBuilder;
+    /**
+     * @internal
+     */
+    clearRawFragmentsCache(): void;
     /**
      * Returns the query with parameters as wildcards.
      */
@@ -224,7 +230,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * You can provide `EntityName.propName` as alias, then the field name will be used based on the metadata
      */
     as(alias: string): Knex.QueryBuilder;
-    clone(reset?: boolean): QueryBuilder<T>;
+    clone(reset?: boolean | string[]): QueryBuilder<T>;
     getKnex(processVirtualEntity?: boolean): Knex.QueryBuilder;
     private fromVirtual;
     private joinReference;

package/query/QueryBuilder.js

@@ -55,6 +55,8 @@ class QueryBuilder {
     __populateWhere;
     /** @internal */
     _populateMap = {};
+    /** @internal */
+    rawFragments = new Set();
     aliasCounter = 0;
     flags = new Set([core_1.QueryFlag.CONVERT_CUSTOM_TYPES]);
     finalized = false;
@@ -484,8 +486,16 @@ class QueryBuilder {
             this.helper.getLockSQL(qb, this.lockMode, this.lockTables);
         }
         this.helper.finalize(type, qb, this.mainAlias.metadata, this._data, this._returning);
+        this.clearRawFragmentsCache();
         return qb;
     }
+    /**
+     * @internal
+     */
+    clearRawFragmentsCache() {
+        this.rawFragments.forEach(key => core_1.RawQueryFragment.remove(key));
+        this.rawFragments.clear();
+    }
     /**
      * Returns the query with parameters as wildcards.
      */
@@ -719,19 +729,26 @@ class QueryBuilder {
     }
     clone(reset) {
         const qb = new QueryBuilder(this.mainAlias.entityName, this.metadata, this.driver, this.context, this.mainAlias.aliasName, this.connectionType, this.em);
-        if (reset) {
+        if (reset === true) {
             return qb;
         }
-        Object.assign(qb, this);
+        reset = reset || [];
         // clone array/object properties
         const properties = [
             'flags', '_populate', '_populateWhere', '__populateWhere', '_populateMap', '_joins', '_joinedProps', '_cond', '_data', '_orderBy',
             '_schema', '_indexHint', '_cache', 'subQueries', 'lockMode', 'lockTables', '_groupBy', '_having', '_returning',
-            '_comments', '_hintComments',
+            '_comments', '_hintComments', 'rawFragments',
         ];
-        properties.forEach(prop => qb[prop] = core_1.Utils.copy(this[prop]));
+        core_1.RawQueryFragment.cloneRegistry = this.rawFragments;
+        for (const prop of Object.keys(this)) {
+            if (reset.includes(prop)) {
+                continue;
+            }
+            qb[prop] = properties.includes(prop) ? core_1.Utils.copy(this[prop]) : this[prop];
+        }
+        delete core_1.RawQueryFragment.cloneRegistry;
         /* istanbul ignore else */
-        if (this._fields) {
+        if (this._fields && !reset.includes('_fields')) {
             qb._fields = [...this._fields];
         }
         qb._aliases = { ...this._aliases };
@@ -1120,7 +1137,7 @@ class QueryBuilder {
     }
     wrapPaginateSubQuery(meta) {
         const pks = this.prepareFields(meta.primaryKeys, 'sub-query');
-        const subQuery = this.clone().select(pks).groupBy(pks).limit(this._limit);
+        const subQuery = this.clone(['_orderBy', '_fields']).select(pks).groupBy(pks).limit(this._limit);
         // revert the on conditions added via populateWhere, we want to apply those only once
         Object.values(subQuery._joins).forEach(join => join.cond = join.cond_ ?? {});
         if (this._offset) {
@@ -1131,6 +1148,12 @@ class QueryBuilder {
             const orderBy = [];
             for (const orderMap of this._orderBy) {
                 for (const [field, direction] of Object.entries(orderMap)) {
+                    if (core_1.RawQueryFragment.isKnownFragment(field)) {
+                        const rawField = core_1.RawQueryFragment.getKnownFragment(field, false);
+                        this.rawFragments.add(field);
+                        orderBy.push({ [rawField.clone()]: direction });
+                        continue;
+                    }
                     const [a, f] = this.helper.splitField(field);
                     const prop = this.helper.getProperty(f, a);
                     const type = this.platform.castColumn(prop);
@@ -1138,7 +1161,8 @@ class QueryBuilder {
                     if (!prop?.persist && !prop?.formula) {
                         addToSelect.push(fieldName);
                     }
-                    orderBy.push({ [(0, core_1.raw)(`min(${this.knex.ref(fieldName)}${type})`)]: direction });
+                    const key = (0, core_1.raw)(`min(${this.knex.ref(fieldName)}${type})`);
+                    orderBy.push({ [key]: direction });
                 }
             }
             subQuery.orderBy(orderBy);
@@ -1151,10 +1175,17 @@ class QueryBuilder {
                     if (typeof field === 'object' && field && '__as' in field) {
                         return field.__as === prop;
                     }
+                    if (field instanceof core_1.RawQueryFragment) {
+                        // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
+                        return field.sql.includes(prop);
+                    }
                     // not perfect, but should work most of the time, ideally we should check only the alias (`... as alias`)
                     return field.toString().includes(prop);
                 });
-                if (field) {
+                if (field instanceof core_1.RawQueryFragment) {
+                    knexQuery.select(this.platform.formatQuery(field.sql, field.params));
+                }
+                else if (field) {
                     knexQuery.select(field);
                 }
             });
@@ -1241,6 +1272,9 @@ class QueryBuilder {
             prefix = 'Upsert';
             object.onConflict = this._onConflict[0];
         }
+        if (!core_1.Utils.isEmpty(this._orderBy)) {
+            object.orderBy = this._orderBy;
+        }
         const name = this._mainAlias ? `${prefix}QueryBuilder<${this._mainAlias?.entityName}>` : 'QueryBuilder';
         const ret = (0, util_1.inspect)(object, { depth });
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;