@mikro-orm/knex 6.0.0-dev.119 → 6.0.0-dev.120

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

@@ -209,7 +209,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             });
             if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(relation.kind)) {
                 result[relation.name] ??= [];
-                this.appendToCollection(meta2, result[relation.name], relationPojo);
+                result[relation.name].push(relationPojo);
             }
             else {
                 result[relation.name] = relationPojo;
@@ -218,17 +218,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) {
@@ -344,7 +333,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         if (meta && this.platform.usesReturningStatement()) {
             const returningProps = meta.props
-                .filter(prop => prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw))
+                .filter(prop => prop.persist !== false && ((prop.primary && prop.autoincrement) || prop.defaultRaw || prop.autoincrement))
                 .filter(prop => !(prop.name in data[0]) || core_1.Utils.isRawSql(data[0][prop.name]));
             const returningFields = core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames));
             /* istanbul ignore next */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.119",
+  "version": "6.0.0-dev.120",
   "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,9 +63,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.8.10"
+    "@mikro-orm/core": "^5.9.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-dev.119"
+    "@mikro-orm/core": "6.0.0-dev.120"
   }
 }

package/query/QueryBuilder.js

@@ -757,6 +757,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 => {
             const rawField = core_1.RawQueryFragment.getKnownFragment(field);
             if (rawField) {
@@ -782,19 +788,18 @@ class QueryBuilder {
             if (prop?.embedded) {
                 const name = prop.embeddedPath?.join('.') ?? prop.fieldNames[0];
                 const aliased = this._aliases[a] ? `${a}.${name}` : name;
-                const fieldName = this.helper.mapper(aliased, this.type);
-                ret.push(fieldName);
+                ret.push(getFieldName(aliased));
                 return;
             }
             if (prop?.kind === core_1.ReferenceKind.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 && (childProp.kind !== core_1.ReferenceKind.EMBEDDED || childProp.object) && childProp.persist !== false) {
-                                ret.push(this.helper.mapper(childProp.fieldNames[0], this.type));
+                                ret.push(getFieldName(childProp.fieldNames[0]));
                             }
                             else {
                                 nest(childProp);
@@ -806,10 +811,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 */
@@ -853,6 +858,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);
         }
@@ -871,12 +878,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:
@@ -1080,7 +1087,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

@@ -144,7 +144,7 @@ class QueryBuilderHelper {
         return {
             prop, type, cond, ownerAlias, alias,
             table: this.getTableName(prop.type),
-            schema: this.driver.getSchemaName(prop.targetMeta, { schema }),
+            schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
             joinColumns: prop.referencedColumnNames,
             primaryKeys: prop.fieldNames,
         };
@@ -161,7 +161,7 @@ class QueryBuilderHelper {
                 primaryKeys: prop.referencedColumnNames,
                 cond: {},
                 table: pivotMeta.tableName,
-                schema: this.driver.getSchemaName(pivotMeta, { schema }),
+                schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(pivotMeta, { schema }),
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
             },
         };
@@ -403,7 +403,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));
         }
@@ -412,6 +416,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)}`);
         }