@mikro-orm/knex 5.8.11-dev.8 → 5.9.0

package/AbstractSqlDriver.d.ts

@@ -21,7 +21,6 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
     mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T>, map?: Dictionary): EntityData<T> | null;
     private mapJoinedProps;
-    private appendToCollection;
     count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;

package/AbstractSqlDriver.js

@@ -186,7 +186,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             });
             if ([core_1.ReferenceType.MANY_TO_MANY, core_1.ReferenceType.ONE_TO_MANY].includes(relation.reference)) {
                 result[relation.name] = result[relation.name] || [];
-                this.appendToCollection(meta2, result[relation.name], relationPojo);
+                result[relation.name].push(relationPojo);
             }
             else {
                 result[relation.name] = relationPojo;
@@ -195,17 +195,6 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             this.mapJoinedProps(relationPojo, meta2, populateChildren, qb, root, map, path);
         });
     }
-    appendToCollection(meta, collection, relationPojo) {
-        if (collection.length === 0) {
-            return void collection.push(relationPojo);
-        }
-        const last = collection[collection.length - 1];
-        const pk1 = core_1.Utils.getCompositeKeyHash(last, meta);
-        const pk2 = core_1.Utils.getCompositeKeyHash(relationPojo, meta);
-        if (pk1 !== pk2) {
-            collection.push(relationPojo);
-        }
-    }
     async count(entityName, where, options = {}) {
         const meta = this.metadata.find(entityName);
         if (meta?.virtual) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "5.8.11-dev.8",
+  "version": "5.9.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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -63,12 +63,12 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.8.10"
+    "@mikro-orm/core": "^5.9.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "5.8.11-dev.8",
-    "@mikro-orm/entity-generator": "5.8.11-dev.8",
-    "@mikro-orm/migrations": "5.8.11-dev.8",
+    "@mikro-orm/core": "^5.0.0",
+    "@mikro-orm/entity-generator": "^5.0.0",
+    "@mikro-orm/migrations": "^5.0.0",
     "better-sqlite3": "*",
     "mssql": "*",
     "mysql": "*",

package/query/QueryBuilder.js

@@ -690,6 +690,12 @@ class QueryBuilder {
     }
     prepareFields(fields, type = 'where') {
         const ret = [];
+        const getFieldName = (name) => {
+            if (type === 'groupBy') {
+                return this.helper.mapper(name, this.type, undefined, null);
+            }
+            return this.helper.mapper(name, this.type);
+        };
         fields.forEach(field => {
             if (!core_1.Utils.isString(field)) {
                 return ret.push(field);
@@ -706,19 +712,18 @@ class QueryBuilder {
             }
             if (prop?.embedded) {
                 const name = this._aliases[a] ? `${a}.${prop.fieldNames[0]}` : prop.fieldNames[0];
-                const fieldName = this.helper.mapper(name, this.type);
-                ret.push(fieldName);
+                ret.push(getFieldName(name));
                 return;
             }
             if (prop?.reference === core_1.ReferenceType.EMBEDDED) {
                 if (prop.object) {
-                    ret.push(this.helper.mapper(prop.fieldNames[0], this.type));
+                    ret.push(getFieldName(prop.fieldNames[0]));
                 }
                 else {
                     const nest = (prop) => {
                         for (const childProp of Object.values(prop.embeddedProps)) {
                             if (childProp.fieldNames) {
-                                ret.push(this.helper.mapper(childProp.fieldNames[0], this.type));
+                                ret.push(getFieldName(childProp.fieldNames[0]));
                             }
                             else {
                                 nest(childProp);
@@ -730,10 +735,10 @@ class QueryBuilder {
                 return;
             }
             if (prop && prop.fieldNames.length > 1) {
-                ret.push(...prop.fieldNames.map(f => this.helper.mapper(f, this.type)));
+                ret.push(...prop.fieldNames.map(f => getFieldName(f)));
                 return;
             }
-            ret.push(this.helper.mapper(field, this.type));
+            ret.push(getFieldName(field));
         });
         const meta = this.mainAlias.metadata;
         /* istanbul ignore next */
@@ -777,6 +782,8 @@ class QueryBuilder {
     getQueryBase() {
         const qb = this.getKnex();
         const schema = this.getSchema(this.mainAlias);
+        // Joined tables doesn't need to belong to the same schema as the main table
+        const joinSchema = this._schema ?? this.em?.schema ?? schema;
         if (schema) {
             qb.withSchema(schema);
         }
@@ -795,12 +802,12 @@ class QueryBuilder {
                 else if (this.flags.has(core_1.QueryFlag.DISTINCT)) {
                     qb.distinct();
                 }
-                this.helper.processJoins(qb, this._joins, schema);
+                this.helper.processJoins(qb, this._joins, joinSchema);
                 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)) });
-                this.helper.processJoins(qb, this._joins, schema);
+                this.helper.processJoins(qb, this._joins, joinSchema);
                 break;
             }
             case enums_1.QueryType.INSERT:
@@ -993,7 +1000,7 @@ class QueryBuilder {
     getSchema(alias) {
         const { metadata } = alias;
         const metaSchema = metadata?.schema && metadata.schema !== '*' ? metadata.schema : undefined;
-        return this._schema ?? metaSchema ?? this.em?.config.get('schema');
+        return this._schema ?? metaSchema ?? this.em?.schema ?? this.em?.config.get('schema');
     }
     createAlias(entityName, aliasName, subQuery) {
         const metadata = this.metadata.find(entityName);

package/query/QueryBuilderHelper.js

@@ -133,7 +133,7 @@ class QueryBuilderHelper {
         return {
             prop, type, cond, ownerAlias, alias,
             table: this.getTableName(prop.type),
-            schema: this.driver.getSchemaName(prop.targetMeta),
+            schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta),
             joinColumns: prop.referencedColumnNames,
             primaryKeys: prop.fieldNames,
         };
@@ -150,7 +150,7 @@ class QueryBuilderHelper {
                 primaryKeys: prop.referencedColumnNames,
                 cond: {},
                 table: pivotMeta.tableName,
-                schema: this.driver.getSchemaName(pivotMeta),
+                schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(pivotMeta),
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
             },
         };
@@ -393,7 +393,11 @@ class QueryBuilderHelper {
     processObjectSubCondition(cond, key, qb, method, m, type) {
         // grouped condition for one field
         let value = cond[key];
-        if (core_1.Utils.getObjectKeysSize(value) > 1) {
+        const size = core_1.Utils.getObjectKeysSize(value);
+        if (core_1.Utils.isPlainObject(value) && size === 0) {
+            return;
+        }
+        if (size > 1) {
             const subCondition = Object.entries(value).map(([subKey, subValue]) => ({ [key]: { [subKey]: subValue } }));
             return subCondition.forEach(sub => this.appendQueryCondition(type, sub, qb, '$and', method));
         }
@@ -402,6 +406,7 @@ class QueryBuilderHelper {
         }
         // operators
         const op = Object.keys(core_1.QueryOperator).find(op => op in value);
+        /* istanbul ignore next */
         if (!op) {
             throw new Error(`Invalid query condition: ${(0, util_1.inspect)(cond)}`);
         }