@mikro-orm/core 6.6.9-dev.2 → 6.6.9-dev.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.6.9-dev.2",
+  "version": "6.6.9-dev.4",
   "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",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.3",
     "globby": "11.1.0",
-    "mikro-orm": "6.6.9-dev.2",
+    "mikro-orm": "6.6.9-dev.4",
     "reflect-metadata": "0.2.2"
   }
 }

package/utils/QueryHelper.d.ts

@@ -22,6 +22,22 @@ export declare class QueryHelper {
     private static processJsonCondition;
     private static getValueType;
     static findProperty<T>(fieldName: string, options: ProcessWhereOptions<T>): EntityProperty<T> | undefined;
+    /**
+     * Converts entity references for composite FK properties into flat arrays
+     * of correctly-ordered join column values, before processParams flattens them
+     * incorrectly due to shared FK columns.
+     */
+    private static convertCompositeEntityRefs;
+    /**
+     * Extracts values for a FK's join columns from an entity by traversing the FK chain.
+     * Handles shared FK columns (e.g., tenant_id referenced by multiple FKs) correctly.
+     */
+    private static extractJoinColumnValues;
+    /**
+     * Extracts the value for a specific column from an entity by finding which PK property
+     * owns that column and recursively traversing FK references.
+     */
+    private static extractColumnValue;
 }
 interface ProcessWhereOptions<T> {
     where: FilterQuery<T>;

package/utils/QueryHelper.js

@@ -117,6 +117,9 @@ class QueryHelper {
             QueryHelper.liftGroupOperators(where, meta, metadata);
             QueryHelper.inlinePrimaryKeyObjects(where, meta, metadata);
         }
+        if (meta) {
+            QueryHelper.convertCompositeEntityRefs(where, meta);
+        }
         if (options.platform.getConfig().get('ignoreUndefinedInQuery') && where && typeof where === 'object') {
             Utils_1.Utils.dropUndefinedProperties(where);
         }
@@ -293,5 +296,70 @@ class QueryHelper {
         const meta = entityName ? options.metadata.find(entityName) : undefined;
         return meta?.properties[propName];
     }
+    /**
+     * Converts entity references for composite FK properties into flat arrays
+     * of correctly-ordered join column values, before processParams flattens them
+     * incorrectly due to shared FK columns.
+     */
+    static convertCompositeEntityRefs(where, meta) {
+        if (!Utils_1.Utils.isPlainObject(where)) {
+            return;
+        }
+        for (const k of Object.keys(where)) {
+            if (k in enums_1.GroupOperator) {
+                if (Array.isArray(where[k])) {
+                    where[k].forEach((sub) => this.convertCompositeEntityRefs(sub, meta));
+                }
+                continue;
+            }
+            if (k === '$not') {
+                this.convertCompositeEntityRefs(where[k], meta);
+                continue;
+            }
+            const prop = meta.properties[k];
+            if (!prop?.joinColumns || prop.joinColumns.length <= 1) {
+                continue;
+            }
+            const w = where[k];
+            if (Utils_1.Utils.isEntity(w)) {
+                where[k] = this.extractJoinColumnValues(w, prop);
+            }
+            else if (Utils_1.Utils.isPlainObject(w)) {
+                for (const op of Object.keys(w)) {
+                    if (Utils_1.Utils.isOperator(op, false) && Array.isArray(w[op])) {
+                        w[op] = w[op].map((item) => Utils_1.Utils.isEntity(item) ? this.extractJoinColumnValues(item, prop) : item);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Extracts values for a FK's join columns from an entity by traversing the FK chain.
+     * Handles shared FK columns (e.g., tenant_id referenced by multiple FKs) correctly.
+     */
+    static extractJoinColumnValues(entity, prop) {
+        return prop.referencedColumnNames.map(refCol => {
+            return this.extractColumnValue(entity, prop.targetMeta, refCol);
+        });
+    }
+    /**
+     * Extracts the value for a specific column from an entity by finding which PK property
+     * owns that column and recursively traversing FK references.
+     */
+    static extractColumnValue(entity, meta, columnName) {
+        for (const pk of meta.primaryKeys) {
+            const pkProp = meta.properties[pk];
+            const colIdx = pkProp.fieldNames.indexOf(columnName);
+            if (colIdx !== -1) {
+                const value = entity[pk];
+                if (pkProp.targetMeta && Utils_1.Utils.isEntity(value, true)) {
+                    const refCol = pkProp.referencedColumnNames[colIdx];
+                    return this.extractColumnValue(value, pkProp.targetMeta, refCol);
+                }
+                return value;
+            }
+        }
+        return null;
+    }
 }
 exports.QueryHelper = QueryHelper;