@mikro-orm/knex 6.4.17-dev.65 → 6.4.17-dev.67

package/AbstractSqlDriver.js

@@ -758,80 +758,39 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
     }
     async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options, pivotJoin) {
+        if (owners.length === 0) {
+            return {};
+        }
         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.pivotEntity, ctx, options.connectionType, undefined, options?.logging)
-            .withSchema(this.getSchemaName(pivotMeta, options))
-            .indexHint(options.indexHint)
-            .comment(options.comments)
-            .hintComment(options.hintComments);
-        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]) },
+            [pivotProp2.name]: { $in: ownerMeta.compositePK ? owners : owners.map(o => o[0]) },
         };
-        /* istanbul ignore if */
-        if (!core_1.Utils.isEmpty(where) && Object.keys(where).every(k => core_1.Utils.isOperator(k, false))) {
-            where = cond;
-        }
-        else {
-            where = { ...where, ...cond };
-        }
-        orderBy = this.getPivotOrderBy(prop, pivotProp1, pivotAlias, orderBy);
-        const populate = this.autoJoinOneToOneOwner(prop.targetMeta, []);
-        const fields = [];
-        const k1 = !prop.owner ? 'joinColumns' : 'inverseJoinColumns';
-        const k2 = prop.owner ? 'joinColumns' : 'inverseJoinColumns';
-        const cols = [
-            ...prop[k1].map(col => `${pivotAlias}.${col} as fk__${col}`),
-            ...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);
-            const additionalFields = [];
-            for (const field of targetFields) {
-                const f = field.toString();
-                additionalFields.push(f.includes('.') ? field : `${targetAlias}.${f}`);
-                if (core_1.RawQueryFragment.isKnownFragment(field)) {
-                    qb.rawFragments.add(f);
-                }
-            }
-            fields.unshift(...additionalFields);
-            // 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
-                for (const join of Object.values(qb['_joins'])) {
-                    const [propName] = hint.field.split(':', 2);
-                    if (join.alias === alias && join.prop.name === propName) {
-                        fields.push(...qb.helper.mapJoinColumns(qb.type, join));
-                    }
-                }
-            });
-        }
-        qb.select(fields)
-            .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 res = owners.length ? await this.rethrow(qb.execute('all', { mergeResults: false, mapResults: false })) : [];
-        const tmp = {};
-        const items = res.map((row) => {
-            const root = super.mapResult(row, prop.targetMeta);
-            this.mapJoinedProps(root, prop.targetMeta, populate, qb, root, tmp, pivotMeta.className + '.' + pivotProp1.name);
-            return root;
+        if (!core_1.Utils.isEmpty(where)) {
+            cond[pivotProp1.name] = { ...where };
+        }
+        where = cond;
+        const populateField = pivotJoin ? `${pivotProp1.name}:ref` : pivotProp1.name;
+        const populate = this.autoJoinOneToOneOwner(prop.targetMeta, options?.populate ?? [], options?.fields);
+        const childFields = !core_1.Utils.isEmpty(options?.fields) ? options.fields.map(f => `${pivotProp1.name}.${f}`) : [];
+        const childExclude = !core_1.Utils.isEmpty(options?.exclude) ? options.exclude.map(f => `${pivotProp1.name}.${f}`) : [];
+        const fields = pivotJoin
+            ? [pivotProp1.name, pivotProp2.name]
+            : [pivotProp1.name, pivotProp2.name, ...childFields];
+        const res = await this.find(pivotMeta.className, where, {
+            ctx,
+            ...options,
+            fields,
+            exclude: childExclude,
+            orderBy: this.getPivotOrderBy(prop, pivotProp1, orderBy, options?.orderBy),
+            populate: [{ field: populateField, strategy: core_1.LoadStrategy.JOINED, joinType: query_1.JoinType.innerJoin, children: populate }],
+            populateWhere: undefined,
+            // @ts-ignore
+            _populateWhere: 'infer',
+            populateFilter: !core_1.Utils.isEmpty(options?.populateFilter) ? { [pivotProp2.name]: options?.populateFilter } : undefined,
         });
-        qb.clearRawFragmentsCache();
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
         for (const owner of owners) {
@@ -841,29 +800,26 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }));
             map[key] = [];
         }
-        for (const item of items) {
-            const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((col, idx) => {
-                const pkProp = pkProps[idx];
-                return pkProp.customType ? pkProp.customType.convertToJSValue(item[`fk__${col}`], this.platform) : item[`fk__${col}`];
-            }));
-            map[key].push(item);
-            prop.joinColumns.forEach(col => delete item[`fk__${col}`]);
-            prop.inverseJoinColumns.forEach((col, idx) => {
-                core_1.Utils.renameKey(item, `fk__${col}`, prop.targetMeta.primaryKeys[idx]);
-            });
+        for (const item of res) {
+            const key = core_1.Utils.getPrimaryKeyHash(core_1.Utils.asArray(item[pivotProp2.name]));
+            map[key].push(item[pivotProp1.name]);
         }
         return map;
     }
-    getPivotOrderBy(prop, pivotProp, pivotAlias, orderBy) {
-        // FIXME this is ignoring the rest of the array items
+    getPivotOrderBy(prop, pivotProp, orderBy, parentOrderBy) {
         if (!core_1.Utils.isEmpty(orderBy)) {
-            return [{ [pivotProp.name]: core_1.Utils.asArray(orderBy)[0] }];
+            return core_1.Utils.asArray(orderBy).map(o => ({ [pivotProp.name]: o }));
+        }
+        if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && core_1.Utils.asArray(parentOrderBy).some(o => o[prop.name])) {
+            return core_1.Utils.asArray(parentOrderBy)
+                .filter(o => o[prop.name])
+                .map(o => ({ [pivotProp.name]: o[prop.name] }));
         }
         if (!core_1.Utils.isEmpty(prop.orderBy)) {
-            return [{ [pivotProp.name]: core_1.Utils.asArray(prop.orderBy)[0] }];
+            return core_1.Utils.asArray(prop.orderBy).map(o => ({ [pivotProp.name]: o }));
         }
         if (prop.fixedOrder) {
-            return [{ [`${pivotAlias}.${prop.fixedOrderColumn}`]: core_1.QueryOrder.ASC }];
+            return [{ [prop.fixedOrderColumn]: core_1.QueryOrder.ASC }];
         }
         return [];
     }
@@ -881,7 +837,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const toPopulate = meta.relations
             .filter(prop => prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner && !prop.lazy && !relationsToPopulate.includes(prop.name))
             .filter(prop => fields.length === 0 || fields.some(f => prop.name === f || prop.name.startsWith(`${String(f)}.`)))
-            .map(prop => ({ field: `${prop.name}:ref`, strategy: prop.strategy }));
+            .map(prop => ({ field: `${prop.name}:ref`, strategy: prop.strategy ?? core_1.LoadStrategy.JOINED }));
         return [...populate, ...toPopulate];
     }
     /**
@@ -889,16 +845,17 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      */
     joinedProps(meta, populate, options) {
         return populate.filter(hint => {
-            const [propName, ref] = hint.field.split(':', 2);
+            const [propName] = hint.field.split(':', 2);
             const prop = meta.properties[propName] || {};
-            if (hint.filter && hint.strategy === core_1.LoadStrategy.JOINED) {
+            const strategy = (0, core_1.getLoadingStrategy)(hint.strategy || options?.strategy || prop.strategy || this.config.get('loadStrategy'), prop.kind);
+            if (hint.filter && (0, core_1.getLoadingStrategy)(hint.strategy, prop.kind) === core_1.LoadStrategy.JOINED) {
                 return true;
             }
             // skip redundant joins for 1:1 owner population hints when using `mapToPk`
             if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.mapToPk && prop.owner) {
                 return false;
             }
-            if ((options?.strategy || hint.strategy || prop.strategy || this.config.get('loadStrategy')) !== core_1.LoadStrategy.JOINED) {
+            if (strategy !== core_1.LoadStrategy.JOINED) {
                 // force joined strategy for explicit 1:1 owner populate hint as it would require a join anyway
                 return prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner;
             }
@@ -967,7 +924,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const [propName, ref] = hint.field.split(':', 2);
             const prop = meta.properties[propName];
             // ignore ref joins of known FKs unless it's a filter hint
-            if (ref && !hint.filter && (prop.kind === core_1.ReferenceKind.MANY_TO_ONE || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.owner))) {
+            if (ref && !hint.filter && (prop.kind === core_1.ReferenceKind.MANY_TO_ONE || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.owner))) {
                 continue;
             }
             if (count && (!options?.populateFilter || !options.populateFilter[prop.name])) {
@@ -983,9 +940,11 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             }
             const joinType = pivotRefJoin
                 ? query_1.JoinType.pivotJoin
-                : hint.filter && !prop.nullable
-                    ? query_1.JoinType.innerJoin
-                    : query_1.JoinType.leftJoin;
+                : hint.joinType
+                    ? hint.joinType
+                    : hint.filter && !prop.nullable
+                        ? query_1.JoinType.innerJoin
+                        : query_1.JoinType.leftJoin;
             qb.join(field, tableAlias, {}, joinType, path);
             if (pivotRefJoin) {
                 fields.push(...prop.joinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)), ...prop.inverseJoinColumns.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
@@ -1003,7 +962,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             if (!ref && !prop.mapToPk) {
                 fields.push(...this.getFieldsForJoinedLoad(qb, meta2, childExplicitFields.length === 0 ? undefined : childExplicitFields, childExclude, hint.children, options, tableAlias, path, count));
             }
-            else if (hint.filter || prop.mapToPk) {
+            else if (hint.filter || prop.mapToPk || (ref && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind))) {
                 fields.push(...prop.referencedColumnNames.map(col => qb.helper.mapper(`${tableAlias}.${col}`, qb.type, undefined, `${tableAlias}__${col}`)));
             }
         }
@@ -1148,7 +1107,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 let path = parentPath;
                 const meta2 = this.metadata.find(prop.type);
                 const childOrder = orderHint[prop.name];
-                if (![core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || core_1.Utils.isPlainObject(childOrder)) {
+                if (prop.kind !== core_1.ReferenceKind.SCALAR && (![core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || core_1.Utils.isPlainObject(childOrder))) {
                     path += `.${propName}`;
                 }
                 if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
@@ -1156,7 +1115,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 }
                 const join = qb.getJoinForPath(path, { matchPopulateJoins: true });
                 const propAlias = qb.getAliasForJoinPath(join ?? path, { matchPopulateJoins: true }) ?? parentAlias;
-                if (!join && parentAlias === qb.alias) {
+                if (!join) {
                     continue;
                 }
                 if (join && ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind) && typeof childOrder === 'object') {

package/index.mjs

@@ -221,6 +221,8 @@ export const createSqlFunction = mod.createSqlFunction;
 export const defineConfig = mod.defineConfig;
 export const defineEntity = mod.defineEntity;
 export const equals = mod.equals;
+export const expandDotPaths = mod.expandDotPaths;
+export const getLoadingStrategy = mod.getLoadingStrategy;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.4.17-dev.65",
+  "version": "6.4.17-dev.67",
   "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.4.16"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.17-dev.65",
+    "@mikro-orm/core": "6.4.17-dev.67",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/CriteriaNode.js

@@ -69,7 +69,7 @@ class CriteriaNode {
         }
     }
     renameFieldToPK(qb) {
-        let joinAlias = qb.getAliasForJoinPath(this.getPath());
+        let joinAlias = qb.getAliasForJoinPath(this.getPath(), { matchPopulateJoins: true });
         if (!joinAlias && this.parent && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind) && this.prop.owner) {
             joinAlias = qb.getAliasForJoinPath(this.parent.getPath());
             return core_1.Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${joinAlias ?? qb.alias}.${col}`));

package/query/ObjectCriteriaNode.js

@@ -9,7 +9,8 @@ const enums_1 = require("./enums");
  */
 class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
     process(qb, options) {
-        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), options);
+        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins });
         const ownerAlias = options?.alias || qb.alias;
         const keys = Object.keys(this.payload);
         let alias = options?.alias;

package/query/ScalarCriteriaNode.d.ts

@@ -1,10 +1,10 @@
 import { CriteriaNode } from './CriteriaNode';
-import type { IQueryBuilder, ICriteriaNodeProcessOptions } from '../typings';
+import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings';
 /**
  * @internal
  */
 export declare class ScalarCriteriaNode<T extends object> extends CriteriaNode<T> {
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
-    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
-    shouldJoin(): boolean;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
+    private shouldJoin;
 }

package/query/ScalarCriteriaNode.js

@@ -9,7 +9,9 @@ const enums_1 = require("./enums");
  */
 class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
     process(qb, options) {
-        if (this.shouldJoin()) {
+        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins });
+        if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
             const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
@@ -30,10 +32,10 @@ class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
         return this.payload;
     }
     willAutoJoin(qb, alias, options) {
-        return this.shouldJoin();
+        return this.shouldJoin(qb, alias);
     }
-    shouldJoin() {
-        if (!this.parent || !this.prop) {
+    shouldJoin(qb, nestedAlias) {
+        if (!this.parent || !this.prop || (nestedAlias && [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(qb.type ?? enums_1.QueryType.SELECT))) {
             return false;
         }
         switch (this.prop.kind) {