@mikro-orm/mongodb 7.3.0-dev.1 → 7.3.0-dev.3

package/MongoDriver.d.ts

@@ -35,6 +35,8 @@ export declare class MongoDriver extends DatabaseDriver<MongoConnection> {
     private buildQueryOptions;
     /** @internal */
     renameFields<T extends object>(entityName: EntityName<T>, data: T, dotPaths?: boolean, object?: boolean, root?: boolean): T;
+    /** Relations are stored as references, so conditions can only compare them by PK, e.g. `{ author: { id } }` becomes `{ author: _id }`. */
+    private inlineRelationPrimaryKey;
     private convertObjectIds;
     private buildFilterById;
     protected buildFields<T extends object, P extends string = never>(entityName: EntityName<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[], exclude?: string[]): string[] | undefined;

package/MongoDriver.js

@@ -1,5 +1,5 @@
 import { ObjectId } from 'mongodb';
-import { DatabaseDriver, EntityManagerType, PolymorphicRef, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { DatabaseDriver, EntityManagerType, GroupOperator, PolymorphicRef, QueryHelper, ReferenceKind, Utils, } from '@mikro-orm/core';
 import { MongoConnection } from './MongoConnection.js';
 import { MongoPlatform } from './MongoPlatform.js';
 import { MongoEntityManager } from './MongoEntityManager.js';
@@ -386,8 +386,10 @@ export class MongoDriver extends DatabaseDriver {
                 }
                 return;
             }
-            if (meta?.properties[k]) {
-                const prop = meta.properties[k];
+            // per-target polymorphic keys like `likeable[Comment]` resolve to the relation, whose conditions need joins
+            const [propName, targetName] = QueryHelper.splitPolymorphicKey(k);
+            const prop = meta?.properties[propName];
+            if (prop && (!targetName || prop.polymorphic)) {
                 let isObjectId = false;
                 if (prop.kind === ReferenceKind.SCALAR) {
                     isObjectId = prop.type === 'ObjectId';
@@ -422,12 +424,31 @@ export class MongoDriver extends DatabaseDriver {
                     else if (value == null) {
                         prop.fieldNames.forEach(f => (copiedData[f] = null));
                     }
+                    else if (k === prop.fieldNames[1] &&
+                        Utils.isPlainObject(value) &&
+                        Object.keys(value).every(o => Utils.isOperator(o))) {
+                        // the FK field is named after the property, e.g. `{ likeable: { $in: ids } }` when loading the inverse side
+                        copiedData[k] = this.convertObjectIds(value);
+                    }
+                    else if (!targetName &&
+                        Utils.isPlainObject(value) &&
+                        Utils.getObjectKeysSize(value) === 1 &&
+                        prop.targetMeta.primaryKeys[0] in value) {
+                        // PK-only condition, e.g. `{ likeable: { _id: { $in: ids } } }`, compares the FK field
+                        copiedData[prop.fieldNames[1]] = this.convertObjectIds(value[prop.targetMeta.primaryKeys[0]]);
+                    }
+                    else {
+                        throw new Error(`Unsupported condition on polymorphic relation ${meta.className}.${prop.name}, use an entity reference or \`null\` instead.`);
+                    }
                     return;
                 }
                 else {
                     const meta2 = this.metadata.find(prop.targetMeta.class);
                     const pk = meta2.properties[meta2.primaryKeys[0]];
                     isObjectId = pk.type === 'ObjectId';
+                    if (dotPaths) {
+                        copiedData[k] = this.inlineRelationPrimaryKey(meta, prop, meta2, copiedData[k]);
+                    }
                 }
                 if (isObjectId) {
                     copiedData[k] = this.convertObjectIds(copiedData[k]);
@@ -442,6 +463,23 @@ export class MongoDriver extends DatabaseDriver {
         });
         return copiedData;
     }
+    /** Relations are stored as references, so conditions can only compare them by PK, e.g. `{ author: { id } }` becomes `{ author: _id }`. */
+    inlineRelationPrimaryKey(meta, prop, meta2, value) {
+        if (prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner)) {
+            throw new Error(`Unsupported condition on inverse side ${meta.className}.${prop.name}, query the owning side ${meta2.className}.${prop.mappedBy} instead.`);
+        }
+        if (!Utils.isPlainObject(value)) {
+            return value;
+        }
+        const keys = Object.keys(value);
+        if (keys.length === 1 && [meta2.primaryKeys[0], meta2.serializedPrimaryKey].includes(keys[0])) {
+            return value[keys[0]];
+        }
+        if (keys.every(k => Utils.isOperator(k) && !(k in GroupOperator) && k !== '$not')) {
+            return value;
+        }
+        throw new Error(`Unsupported condition on relation ${meta.className}.${prop.name}, MongoDB can query relations only by primary key or entity reference.`);
+    }
     convertObjectIds(data) {
         if (data instanceof ObjectId) {
             return data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mongodb",
-  "version": "7.3.0-dev.1",
+  "version": "7.3.0-dev.3",
   "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.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.2.1"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.3.0-dev.1"
+    "@mikro-orm/core": "7.3.0-dev.3"
   },
   "engines": {
     "node": ">= 22.17.0"