@mikro-orm/knex 6.6.5 → 6.6.6-dev.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.6.5",
+  "version": "6.6.6-dev.1",
   "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,7 +66,7 @@
     "@mikro-orm/core": "^6.6.5"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "^6.0.0",
+    "@mikro-orm/core": "6.6.6-dev.1",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/QueryBuilder.d.ts

@@ -290,7 +290,7 @@ export declare class QueryBuilder<Entity extends object = AnyEntity, RootAlias e
     getLoggerContext<T extends Dictionary & LoggingOptions = Dictionary>(): T;
     private fromVirtual;
     private joinReference;
-    protected prepareFields<T, U extends string | Knex.Raw>(fields: Field<T>[], type?: 'where' | 'groupBy' | 'sub-query'): U[];
+    protected prepareFields<T, U extends string | Knex.Raw>(fields: Field<T>[], type?: 'where' | 'groupBy' | 'sub-query', schema?: string): U[];
     private init;
     private getQueryBase;
     private applyDiscriminatorCondition;

package/query/QueryBuilder.js

@@ -553,10 +553,11 @@ class QueryBuilder {
         this._query = {};
         this.finalize();
         const qb = this.getQueryBase(processVirtualEntity);
+        const schema = this.getSchema(this.mainAlias);
         const type = this.type ?? enums_1.QueryType.SELECT;
         qb.__raw = true; // tag it as there is now way to check via `instanceof`
         core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(type, this._cond, qb), this._cond && !this._onConflict);
-        core_1.Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy')), this._groupBy);
+        core_1.Utils.runIfNotEmpty(() => qb.groupBy(this.prepareFields(this._groupBy, 'groupBy', schema)), this._groupBy);
         core_1.Utils.runIfNotEmpty(() => this.helper.appendQueryCondition(type, this._having, qb, undefined, 'having'), this._having);
         core_1.Utils.runIfNotEmpty(() => {
             const queryOrder = this.helper.getQueryOrder(type, this._orderBy, this._populateMap);
@@ -991,13 +992,10 @@ class QueryBuilder {
         }
         return { prop, key: aliasedName };
     }
-    prepareFields(fields, type = 'where') {
+    prepareFields(fields, type = 'where', schema) {
         const ret = [];
         const getFieldName = (name) => {
-            if (type === 'groupBy') {
-                return this.helper.mapper(name, this.type, undefined, null);
-            }
-            return this.helper.mapper(name, this.type);
+            return this.helper.mapper(name, this.type, undefined, type === 'groupBy' ? null : undefined, schema);
         };
         fields.forEach(field => {
             const rawField = core_1.RawQueryFragment.getKnownFragment(field);
@@ -1104,9 +1102,9 @@ class QueryBuilder {
         }
         switch (this.type) {
             case enums_1.QueryType.SELECT:
-                qb.select(this.prepareFields(this._fields));
+                qb.select(this.prepareFields(this._fields, 'where', schema));
                 if (this._distinctOn) {
-                    qb.distinctOn(this.prepareFields(this._distinctOn));
+                    qb.distinctOn(this.prepareFields(this._distinctOn, 'where', schema));
                 }
                 else if (this.flags.has(core_1.QueryFlag.DISTINCT)) {
                     qb.distinct();
@@ -1115,7 +1113,7 @@ class QueryBuilder {
                 break;
             case enums_1.QueryType.COUNT: {
                 const m = this.flags.has(core_1.QueryFlag.DISTINCT) ? 'countDistinct' : 'count';
-                qb[m]({ count: this._fields.map(f => this.helper.mapper(f, this.type)) });
+                qb[m]({ count: this._fields.map(f => this.helper.mapper(f, this.type, undefined, undefined, schema)) });
                 this.helper.processJoins(qb, this._joins, joinSchema);
                 break;
             }
@@ -1328,7 +1326,8 @@ class QueryBuilder {
         });
     }
     wrapPaginateSubQuery(meta) {
-        const pks = this.prepareFields(meta.primaryKeys, 'sub-query');
+        const schema = this.getSchema(this.mainAlias);
+        const pks = this.prepareFields(meta.primaryKeys, 'sub-query', schema);
         const subQuery = this.clone(['_orderBy', '_fields', 'lockMode', 'lockTableAliases']).select(pks).groupBy(pks).limit(this._limit);
         // revert the on conditions added via populateWhere, we want to apply those only once
         for (const join of Object.values(subQuery._joins)) {