@mikro-orm/knex 6.0.0-dev.110 → 6.0.0-dev.112

package/AbstractSqlDriver.d.ts

@@ -29,7 +29,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     syncCollection<T extends object, O extends object>(coll: Collection<T, O>, options?: DriverMethodOptions): Promise<void>;
-    loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any>): Promise<Dictionary<T[]>>;
+    loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     private getPivotOrderBy;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<T>;
     /**
@@ -61,5 +61,5 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected buildJoinedPropsOrderBy<T extends object>(entityName: string, qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], parentPath?: string): QueryOrderMap<T>[];
     protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];
     protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[], populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>): void;
-    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, fields?: Field<T>[]): Field<T>[];
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, alias: string, fields?: Field<T>[]): Field<T>[];
 }

package/AbstractSqlDriver.js

@@ -30,7 +30,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const populate = this.autoJoinOneToOneOwner(meta, options.populate, options.fields);
         const joinedProps = this.joinedProps(meta, populate);
         const qb = this.createQueryBuilder(entityName, options.ctx, options.connectionType, false, options.logging);
-        const fields = this.buildFields(meta, populate, joinedProps, qb, options.fields);
+        const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options.fields);
         const joinedPropsOrderBy = this.buildJoinedPropsOrderBy(entityName, qb, meta, joinedProps);
         const orderBy = [...core_1.Utils.asArray(options.orderBy), ...joinedPropsOrderBy];
         if (core_1.Utils.isPrimaryKey(where, meta.compositePK)) {
@@ -290,7 +290,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     async nativeInsertMany(entityName, data, options = {}) {
         options.processCollections ??= true;
         options.convertCustomTypes ??= true;
-        const meta = this.metadata.find(entityName);
+        const meta = this.metadata.find(entityName)?.root;
         const collections = options.processCollections ? data.map(d => this.extractManyToMany(entityName, d)) : [];
         const pks = this.getPrimaryKeyFields(entityName);
         const set = new Set();
@@ -322,24 +322,31 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
             sql += data.map(row => {
                 const keys = [];
+                const usedDups = [];
                 props.forEach(prop => {
                     if (prop.fieldNames.length > 1) {
                         const param = core_1.Utils.flatten([...row[prop.name] ?? prop.fieldNames.map(() => null)]);
                         const key = param.map(() => '?');
                         prop.fieldNames.forEach((field, idx) => {
-                            if (!duplicates.includes(field)) {
+                            if (!duplicates.includes(field) || !usedDups.includes(field)) {
                                 params.push(param[idx]);
                                 keys.push(key[idx]);
+                                usedDups.push(field);
                             }
                         });
                     }
-                    else if (prop.customType && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(row[prop.name])) {
-                        keys.push(prop.customType.convertToDatabaseValueSQL('?', this.platform));
-                        addParams(prop, row);
-                    }
                     else {
-                        addParams(prop, row);
-                        keys.push('?');
+                        const field = prop.fieldNames[0];
+                        if (!duplicates.includes(field) || !usedDups.includes(field)) {
+                            if (prop.customType && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(row[prop.name])) {
+                                keys.push(prop.customType.convertToDatabaseValueSQL('?', this.platform));
+                            }
+                            else {
+                                keys.push('?');
+                            }
+                            addParams(prop, row);
+                            usedDups.push(field);
+                        }
                     }
                 });
                 return '(' + (keys.join(', ') || 'default') + ')';
@@ -568,18 +575,18 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         return this.rethrow(this.updateCollectionDiff(meta, coll.property, pks, deleteDiff, insertDiff, options));
     }
-    async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options) {
-        const pivotProp2 = this.getPivotInverseProperty(prop);
-        const prop2 = prop.targetMeta.properties[prop.mappedBy ?? prop.inversedBy];
-        const ownerMeta = this.metadata.find(pivotProp2.type);
+    async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options, pivotJoin) {
         const pivotMeta = this.metadata.find(prop.pivotEntity);
+        const pivotProp1 = pivotMeta.relations[prop.owner ? 1 : 0];
+        const pivotProp2 = pivotMeta.relations[prop.owner ? 0 : 1];
+        const ownerMeta = this.metadata.find(pivotProp2.type);
         options = { ...options };
-        const qb = this.createQueryBuilder(prop.type, ctx, options.connectionType)
-            .withSchema(this.getSchemaName(prop.targetMeta, options))
+        const qb = this.createQueryBuilder(prop.pivotEntity, ctx, options.connectionType)
+            .withSchema(this.getSchemaName(pivotMeta, options))
             .indexHint(options.indexHint)
             .comment(options.comments)
             .hintComment(options.hintComments);
-        const pivotAlias = qb.getNextAlias(pivotMeta.tableName);
+        const pivotAlias = qb.alias;
         const pivotKey = pivotProp2.joinColumns.map(column => `${pivotAlias}.${column}`).join(core_1.Utils.PK_SEPARATOR);
         const cond = {
             [pivotKey]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) },
@@ -591,9 +598,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         else {
             where = { ...where, ...cond };
         }
-        orderBy = this.getPivotOrderBy(prop, pivotAlias, orderBy);
+        orderBy = this.getPivotOrderBy(prop, pivotProp1, pivotAlias, orderBy);
         const populate = this.autoJoinOneToOneOwner(prop.targetMeta, []);
-        const fields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, options.fields);
+        const fields = [];
         const k1 = !prop.owner ? 'joinColumns' : 'inverseJoinColumns';
         const k2 = prop.owner ? 'joinColumns' : 'inverseJoinColumns';
         const cols = [
@@ -601,25 +608,36 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             ...prop[k2].map(col => `${pivotAlias}.${col} as fk__${col}`),
         ];
         fields.push(...cols);
+        if (!pivotJoin) {
+            const targetAlias = qb.getNextAlias(prop.targetMeta.tableName);
+            const targetSchema = this.getSchemaName(prop.targetMeta, options) ?? this.platform.getDefaultSchemaName();
+            qb.innerJoin(pivotProp1.name, targetAlias, {}, targetSchema);
+            const targetFields = this.buildFields(prop.targetMeta, (options.populate ?? []), [], qb, targetAlias, options.fields);
+            for (const field of targetFields) {
+                const f = field.toString();
+                fields.unshift(f.includes('.') ? field : `${targetAlias}.${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 => {
+                const alias = qb.getNextAlias(prop.targetMeta.tableName);
+                qb.leftJoin(`${targetAlias}.${hint.field}`, alias);
+                // eslint-disable-next-line dot-notation
+                Object.values(qb['_joins']).forEach(join => {
+                    if (join.alias === alias && join.prop.name === hint.field) {
+                        fields.push(...qb.helper.mapJoinColumns(qb.type, join));
+                    }
+                });
+            });
+        }
         qb.select(fields)
-            .join(prop2.name, pivotAlias, {}, 'pivotJoin', undefined, options.schema)
-            .populate(populate)
-            .where(where)
+            .where({ [pivotProp1.name]: where })
             .orderBy(orderBy)
             .setLockMode(options.lockMode, options.lockTableAliases);
         if (owners.length === 1 && (options.offset != null || options.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
-        const schema = this.config.get('schema');
-        if (prop.targetMeta.schema !== '*' && pivotMeta.schema === '*' && options.schema) {
-            // eslint-disable-next-line dot-notation
-            qb['finalize']();
-            // eslint-disable-next-line dot-notation
-            Object.values(qb['_joins']).forEach(join => {
-                join.schema = schema;
-            });
-        }
-        const items = owners.length ? await this.rethrow(qb.execute('all')) : [];
+        const res = owners.length ? await this.rethrow(qb.execute('all', false)) : [];
+        const items = res.map((row) => super.mapResult(row, prop.targetMeta));
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
         owners.forEach(owner => {
@@ -636,16 +654,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }));
             map[key].push(item);
             prop.joinColumns.forEach(col => delete item[`fk__${col}`]);
-            prop.inverseJoinColumns.forEach(col => delete item[`fk__${col}`]);
+            prop.inverseJoinColumns.forEach((col, idx) => {
+                core_1.Utils.renameKey(item, `fk__${col}`, prop.targetMeta.primaryKeys[idx]);
+            });
         });
         return map;
     }
-    getPivotOrderBy(prop, pivotAlias, orderBy) {
+    getPivotOrderBy(prop, pivotProp, pivotAlias, orderBy) {
+        // FIXME this is ignoring the rest of the array items
         if (!core_1.Utils.isEmpty(orderBy)) {
-            return orderBy;
+            return [{ [pivotProp.name]: core_1.Utils.asArray(orderBy)[0] }];
         }
         if (!core_1.Utils.isEmpty(prop.orderBy)) {
-            return core_1.Utils.asArray(prop.orderBy);
+            return [{ [pivotProp.name]: core_1.Utils.asArray(prop.orderBy)[0] }];
         }
         if (prop.fixedOrder) {
             return [{ [`${pivotAlias}.${prop.fixedOrderColumn}`]: core_1.QueryOrder.ASC }];
@@ -721,7 +742,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .filter(prop => shouldHaveColumn(prop, populate, explicitFields))
             .forEach(prop => fields.push(...this.mapPropToFieldNames(qb, prop, parentTableAlias)));
         joinedProps.forEach(relation => {
-            const prop = meta.properties[relation.field];
+            const [propName] = relation.field.split(':', 2);
+            const prop = meta.properties[propName];
             const meta2 = this.metadata.find(prop.type);
             const tableAlias = qb.getNextAlias(prop.name);
             const field = parentTableAlias ? `${parentTableAlias}.${prop.name}` : prop.name;
@@ -851,7 +873,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const orderBy = [];
         const joinedProps = this.joinedProps(meta, populate);
         joinedProps.forEach(relation => {
-            const prop = meta.properties[relation.field];
+            const [propName] = relation.field.split(':', 2);
+            const prop = meta.properties[propName];
             const propOrderBy = prop.orderBy;
             const path = `${parentPath ? parentPath : entityName}.${relation.field}`;
             const propAlias = qb.getAliasForJoinPath(path);
@@ -902,7 +925,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         ret.push(prop.name);
     }
-    buildFields(meta, populate, joinedProps, qb, fields) {
+    buildFields(meta, populate, joinedProps, qb, alias, fields) {
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));
         const hasLazyFormulas = meta.props.some(p => p.lazy && p.formula);
         const requiresSQLConversion = meta.props.some(p => p.customType?.convertToJSValueSQL);
@@ -944,9 +967,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             meta.props
                 .filter(prop => prop.formula && !lazyProps.includes(prop))
                 .forEach(prop => {
-                const alias = this.connection.getKnex().ref(qb.alias).toString();
+                const a = this.connection.getKnex().ref(alias).toString();
                 const aliased = this.connection.getKnex().ref(prop.fieldNames[0]).toString();
-                ret.push((0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`));
+                ret.push((0, core_1.raw)(`${prop.formula(a)} as ${aliased}`));
             });
             meta.props
                 .filter(prop => prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.110",
+  "version": "6.0.0-dev.112",
   "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": "^5.8.5"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-dev.110"
+    "@mikro-orm/core": "6.0.0-dev.112"
   }
 }

package/query/QueryBuilder.js

@@ -274,6 +274,7 @@ class QueryBuilder {
                 aliasMap: this.getAliasMap(),
                 aliased: !this.type || [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(this.type),
                 convertCustomTypes: false,
+                type: 'orderBy',
             });
             this._orderBy.push(CriteriaNodeFactory_1.CriteriaNodeFactory.createNode(this.metadata, this.mainAlias.entityName, processed).process(this));
         });

package/query/QueryBuilderHelper.d.ts

@@ -26,7 +26,7 @@ export declare class QueryBuilderHelper {
     private processJoinClause;
     private wrapQueryGroup;
     mapJoinColumns(type: QueryType, join: JoinOptions): (string | Knex.Raw)[];
-    isOneToOneInverse(field: string): boolean;
+    isOneToOneInverse(field: string, meta?: EntityMetadata): boolean;
     getTableName(entityName: string): string;
     /**
      * Checks whether the RE can be rewritten to simple LIKE query

package/query/QueryBuilderHelper.js

@@ -157,6 +157,8 @@ class QueryBuilderHelper {
         const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
         ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond, schema);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
+        const tmp = prop2.referencedTableName.split('.');
+        ret[`${pivotAlias}.${prop2.name}#${alias}`].schema ??= tmp.length > 1 ? tmp[0] : undefined;
         return ret;
     }
     processJoins(qb, joins, schema) {
@@ -177,7 +179,7 @@ class QueryBuilderHelper {
                         conditions.push(`${left} = ${this.knex.ref(right)}`);
                         return;
                     }
-                    const left = join.prop.kind === core_1.ReferenceKind.SCALAR && join.prop.persist === false ? primaryKey : `${join.ownerAlias}.${primaryKey}`;
+                    const left = `${join.ownerAlias}.${primaryKey}`;
                     conditions.push(`${this.knex.ref(left)} = ${this.knex.ref(right)}`);
                 });
             }
@@ -282,8 +284,8 @@ class QueryBuilderHelper {
             ...join.inverseJoinColumns.map(col => this.mapper(`${join.alias}.${col}`, type, undefined, `fk__${col}`)),
         ];
     }
-    isOneToOneInverse(field) {
-        const meta = this.metadata.find(this.entityName);
+    isOneToOneInverse(field, meta) {
+        meta ??= this.metadata.find(this.entityName);
         const prop = meta.properties[field];
         return prop && prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
     }
@@ -474,7 +476,12 @@ class QueryBuilderHelper {
                 if (core_1.Utils.isRawSql(colPart)) {
                     colPart = this.platform.formatQuery(colPart.sql, colPart.params);
                 }
-                ret.push(`${colPart} ${order.toLowerCase()}`);
+                if (Array.isArray(order)) {
+                    order.forEach(part => ret.push(this.getQueryOrderFromObject(type, part, populate)));
+                }
+                else {
+                    ret.push(`${colPart} ${order.toLowerCase()}`);
+                }
             });
         });
         return ret.join(', ');

package/schema/DatabaseTable.js

@@ -33,7 +33,7 @@ class DatabaseTable {
         delete this.columns[name];
     }
     getIndexes() {
-        return this.indexes;
+        return core_1.Utils.removeDuplicates(this.indexes);
     }
     getChecks() {
         return this.checks;