@mikro-orm/core 7.1.4-dev.0 → 7.1.4-dev.10

package/entity/Collection.d.ts

@@ -70,6 +70,8 @@ export declare class Collection<T extends object, O extends object = object> {
     /** Initializes the collection by loading its items from the database. */
     init<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
     private getEntityManager;
+    /** The owning-side property this collection is mapped by (the inverse of `mappedBy`); `undefined` for the owning side of m:n. */
+    private get mappedByProp();
     private createCondition;
     private createManyToManyCondition;
     private createLoadCountCondition;

package/entity/Collection.js

@@ -320,9 +320,14 @@ export class Collection {
         }
         return em;
     }
+    /** The owning-side property this collection is mapped by (the inverse of `mappedBy`); `undefined` for the owning side of m:n. */
+    get mappedByProp() {
+        return this.property.mappedBy ? this.property.targetMeta.properties[this.property.mappedBy] : undefined;
+    }
     createCondition(cond = {}) {
         if (this.property.kind === ReferenceKind.ONE_TO_MANY) {
-            cond[this.property.mappedBy] = helper(this.owner).getPrimaryKey();
+            // the owning FK may reference a non-PK column (`targetKey`), so match on that value when set
+            cond[this.property.mappedBy] = helper(this.owner).getTargetKeyValue(this.mappedByProp?.targetKey);
         }
         else {
             // MANY_TO_MANY
@@ -344,7 +349,12 @@ export class Collection {
     }
     createLoadCountCondition(cond) {
         const wrapped = helper(this.owner);
-        const val = wrapped.__meta.compositePK ? { $in: wrapped.__primaryKeys } : wrapped.getPrimaryKey();
+        const ownerProp = this.mappedByProp;
+        const val = ownerProp?.targetKey
+            ? wrapped.getTargetKeyValue(ownerProp.targetKey)
+            : wrapped.__meta.compositePK
+                ? { $in: wrapped.__primaryKeys }
+                : wrapped.getPrimaryKey();
         const dict = cond;
         if (this.property.kind === ReferenceKind.ONE_TO_MANY) {
             dict[this.property.mappedBy] = val;

package/entity/EntityLoader.js

@@ -281,22 +281,30 @@ export class EntityLoader {
         }
     }
     initializeOneToMany(filtered, children, prop, field, partial, readonly) {
-        const mapToPk = prop.targetMeta.properties[prop.mappedBy].mapToPk;
+        const ownerProp = prop.targetMeta.properties[prop.mappedBy];
+        const targetKey = ownerProp.targetKey;
         const map = {};
+        // when the owning side targets a non-PK column, group by that value on both sides
+        const parentKey = (entity) => helper(entity).getSerializedTargetKey(targetKey);
         for (const entity of filtered) {
-            const key = helper(entity).getSerializedPrimaryKey();
-            map[key] = [];
+            map[parentKey(entity)] = [];
         }
         for (const child of children) {
-            const pk = child.__helper.__data[prop.mappedBy] ?? child[prop.mappedBy];
-            if (pk) {
-                const key = helper(mapToPk ? this.#em.getReference(prop.targetMeta.class, pk) : pk).getSerializedPrimaryKey();
+            const fk = child.__helper.__data[prop.mappedBy] ?? child[prop.mappedBy];
+            if (fk) {
+                let key;
+                if (targetKey) {
+                    // `fk` is the owner reference (resolve its targetKey) unless the relation maps to the raw PK value
+                    key = Utils.isEntity(fk, true) ? helper(fk).getSerializedTargetKey(targetKey) : '' + fk;
+                }
+                else {
+                    key = helper(ownerProp.mapToPk ? this.#em.getReference(prop.targetMeta.class, fk) : fk).getSerializedPrimaryKey();
+                }
                 map[key]?.push(child);
             }
         }
         for (const entity of filtered) {
-            const key = helper(entity).getSerializedPrimaryKey();
-            entity[field].hydrate(map[key], undefined, partial, readonly);
+            entity[field].hydrate(map[parentKey(entity)], undefined, partial, readonly);
         }
     }
     initializeManyToMany(filtered, children, prop, field, customOrder, partial, readonly) {
@@ -326,8 +334,10 @@ export class EntityLoader {
         let schema = options.schema;
         const partial = !Utils.isEmpty(prop.where) || !Utils.isEmpty(options.where);
         let polymorphicOwnerProp;
-        if (prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner)) {
-            const ownerProp = meta.properties[prop.mappedBy];
+        const ownerProp = prop.kind === ReferenceKind.ONE_TO_MANY || (prop.kind === ReferenceKind.MANY_TO_MANY && !prop.owner)
+            ? meta.properties[prop.mappedBy]
+            : undefined;
+        if (ownerProp) {
             if (ownerProp.polymorphic && ownerProp.fieldNames.length >= 2) {
                 const idColumns = ownerProp.fieldNames.slice(1);
                 fk = idColumns.length === 1 ? idColumns[0] : idColumns;
@@ -348,7 +358,9 @@ export class EntityLoader {
         if (!schema && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
             schema = children.find(e => e.__helper.__schema)?.__helper.__schema;
         }
-        const ids = Utils.unique(children.map(e => (prop.targetKey ? e[prop.targetKey] : e.__helper.getPrimaryKey())));
+        // for inverse sides the `targetKey` lives on the owning property, otherwise on the prop itself
+        const targetKey = prop.targetKey ?? ownerProp?.targetKey;
+        const ids = Utils.unique(children.map(e => e.__helper.getTargetKeyValue(targetKey)));
         let where;
         if (polymorphicOwnerProp && Array.isArray(fk)) {
             const conditions = ids.map(id => {
@@ -417,7 +429,7 @@ export class EntityLoader {
         if (prop.targetKey && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind)) {
             const itemsByKey = new Map();
             for (const item of items) {
-                itemsByKey.set('' + item[prop.targetKey], item);
+                itemsByKey.set(helper(item).getSerializedTargetKey(prop.targetKey), item);
             }
             for (const entity of entities) {
                 const ref = entity[prop.name];
@@ -425,8 +437,7 @@ export class EntityLoader {
                 if (!ref) {
                     continue;
                 }
-                // oxfmt-ignore
-                const keyValue = '' + (Reference.isReference(ref) ? ref.unwrap()[prop.targetKey] : ref[prop.targetKey]);
+                const keyValue = helper(ref).getSerializedTargetKey(prop.targetKey);
                 const loadedItem = itemsByKey.get(keyValue);
                 if (loadedItem) {
                     entity[prop.name] = (Reference.isReference(ref) ? Reference.create(loadedItem) : loadedItem);
@@ -437,7 +448,8 @@ export class EntityLoader {
             const nullVal = this.#em.config.get('forceUndefined') ? undefined : null;
             const itemsMap = new Set();
             const childrenMap = new Set();
-            // Use targetKey value if set, otherwise use serialized PK
+            // `e` may be an unresolved reference here, so read the targetKey value directly instead of
+            // resolving it through the entity — that keeps orphaned references (missing target row) intact
             const getKey = (e) => (prop.targetKey ? '' + e[prop.targetKey] : helper(e).getSerializedPrimaryKey());
             for (const item of items) {
                 /* v8 ignore next */

package/entity/WrappedEntity.d.ts

@@ -79,6 +79,10 @@ export declare class WrappedEntity<Entity extends object> {
     setPrimaryKey(id: Primary<Entity> | null): void;
     /** Returns the primary key serialized as a string suitable for identity map lookups. */
     getSerializedPrimaryKey(): string;
+    /** Returns the value a relation references on this entity — the `targetKey` column when set, otherwise the primary key. */
+    getTargetKeyValue(targetKey?: string): Primary<Entity> | null;
+    /** Serialized counterpart of `getTargetKeyValue`, suitable for identity map / grouping keys. */
+    getSerializedTargetKey(targetKey?: string): string;
     get __meta(): EntityMetadata<Entity>;
     get __platform(): Platform;
     get __config(): Configuration;

package/entity/WrappedEntity.js

@@ -159,6 +159,14 @@ export class WrappedEntity {
     getSerializedPrimaryKey() {
         return this.pkSerializer(this.entity);
     }
+    /** Returns the value a relation references on this entity — the `targetKey` column when set, otherwise the primary key. */
+    getTargetKeyValue(targetKey) {
+        return targetKey ? this.entity[targetKey] : this.getPrimaryKey();
+    }
+    /** Serialized counterpart of `getTargetKeyValue`, suitable for identity map / grouping keys. */
+    getSerializedTargetKey(targetKey) {
+        return targetKey ? '' + this.entity[targetKey] : this.getSerializedPrimaryKey();
+    }
     get __meta() {
         return this.entity.__meta;
     }

package/metadata/MetadataDiscovery.js

@@ -1391,7 +1391,9 @@ export class MetadataDiscovery {
                     meta.root.uniques.push({ properties });
                 }
             }
-            newProp.nullable = true;
+            // The primary key column is shared by every subtype, so it stays NOT NULL —
+            // only subtype-specific columns become nullable for the rows of other subtypes.
+            newProp.nullable = !newProp.primary;
             newProp.inherited = !rootProp;
             // For narrowed relation overrides, keep the root's declaration intact so
             // the full target union (e.g. `Food`) is preserved for populates from the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.4-dev.0",
+  "version": "7.1.4-dev.10",
   "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",

package/typings.d.ts

@@ -405,6 +405,8 @@ export interface IWrappedEntityInternal<Entity extends object> extends IWrappedE
     getPrimaryKeys(convertCustomTypes?: boolean): Primary<Entity>[] | null;
     setPrimaryKey(val: Primary<Entity>): void;
     getSerializedPrimaryKey(): string & keyof Entity;
+    getTargetKeyValue(targetKey?: string): Primary<Entity> | null;
+    getSerializedTargetKey(targetKey?: string): string;
     __meta: EntityMetadata<Entity>;
     __data: Dictionary;
     __em?: EntityManager;

package/utils/EntityComparator.js

@@ -393,7 +393,25 @@ export class EntityComparator {
         else {
             mapEntityProperties(meta);
         }
-        lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined) ret[k] = result[k]; }`);
+        // pass through any unmapped columns (e.g. extra selections or virtual props). for embeddables we restrict
+        // this to declared keys, otherwise JSON keys not part of the schema leak into the original data while
+        // hydration drops them from the entity, diverging the snapshot and triggering spurious updates.
+        let knownKeysGuard = '';
+        if (meta.embeddable) {
+            const knownKeys = new Set();
+            for (const m of meta.polymorphs?.length ? meta.polymorphs : [meta]) {
+                for (const prop of m.props) {
+                    knownKeys.add(prop.name);
+                    if (prop.embedded) {
+                        knownKeys.add(prop.embedded[1]);
+                    }
+                    prop.fieldNames?.forEach(field => knownKeys.add(field));
+                }
+            }
+            context.set('knownKeys', knownKeys);
+            knownKeysGuard = ' && knownKeys.has(k)';
+        }
+        lines.push(`  for (let k in result) { if (Object.hasOwn(result, k) && !mapped[k] && ret[k] === undefined${knownKeysGuard}) ret[k] = result[k]; }`);
         const code = `// compiled mapper for entity ${meta.className}\n` +
             `return function(result) {\n  const ret = {};\n${lines.join('\n')}\n  return ret;\n}`;
         const fnKey = `resultMapper-${meta.uniqueName}`;

package/utils/Utils.js

@@ -141,7 +141,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.4-dev.0';
+    static #ORM_VERSION = '7.1.4-dev.10';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */