@mikro-orm/core 7.1.15-dev.1 → 7.1.15-dev.10

package/entity/EntityLoader.js

@@ -229,9 +229,10 @@ export class EntityLoader {
                 }
                 toPopulate.push(entity);
             }
-            else if (refValue == null && !helper(entity).__loadedProperties.has(prop.name)) {
+            else if (refValue == null && !prop.object && !helper(entity).__loadedProperties.has(prop.name)) {
                 // FK columns weren't loaded (partial loading) — need to re-fetch them.
                 // If the property IS in __loadedProperties, the FK was loaded and is genuinely null.
+                // Object-embedded virtual props are skipped — they are populated via the embeddable instance.
                 needsFkLoad.push(entity);
             }
         }

package/entity/defineEntity.d.ts

@@ -112,7 +112,7 @@ export interface PropertyChain<Value, Options> {
     getter(getter?: boolean): PropertyChain<Value, Options>;
     getterName(getterName: string): PropertyChain<Value, Options>;
     serializedPrimaryKey(serializedPrimaryKey?: boolean): PropertyChain<Value, Options>;
-    serializer(serializer: (value: Value, options?: SerializeOptions<any>) => any): PropertyChain<Value, Options>;
+    serializer(serializer: (value: SerializerValue<Value, Options>, options?: SerializeOptions<any>) => any): PropertyChain<Value, Options>;
     serializedName(serializedName: string): PropertyChain<Value, Options>;
     groups(...groups: string[]): PropertyChain<Value, Options>;
     customOrder(...customOrder: string[] | number[] | boolean[]): PropertyChain<Value, Options>;
@@ -795,6 +795,8 @@ type InferBuilderValue<Builder> = Builder extends {
 type MaybeArray<Value, Options> = Options extends {
     array: true;
 } ? Value[] : Value;
+/** The runtime value passed to a custom serializer — the property value as stored on the entity (e.g. `Collection`/`Ref` for relations). Skips `MaybeMapToPk`, as its `Primary<Value>` branch is too costly for the type checker. */
+type SerializerValue<Value, Options> = MaybeNullable<MaybeRelationRef<MaybeArray<Value, Options>, Options>, Options>;
 type MaybeMapToPk<Value, Options> = Options extends {
     mapToPk: true;
 } ? Primary<Value> : Value;

package/entity/defineEntity.js

@@ -475,7 +475,7 @@ export class UniversalPropertyOptionsBuilder {
 export class OneToManyOptionsBuilderOnlyMappedBy extends UniversalPropertyOptionsBuilder {
     /** Point to the owning side property name. */
     mappedBy(mappedBy) {
-        return new UniversalPropertyOptionsBuilder({ ...this['~options'], mappedBy });
+        return this.assignOptions({ mappedBy });
     }
 }
 function createPropertyBuilders(options) {

package/metadata/MetadataDiscovery.js

@@ -441,7 +441,18 @@ export class MetadataDiscovery {
         if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
             prop.fieldNames = [this.#namingStrategy.propertyToColumnName(prop.name, object)];
         }
-        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
+        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.polymorphic) {
+            if (prop.targetMeta) {
+                // same layout as `initManyToOneFields` builds later: `[discriminatorColumn, ...fkIdColumns]`
+                const pkFields = prop.targetMeta.getPrimaryProps().flatMap(pk => {
+                    this.initFieldName(pk);
+                    return pk.fieldNames;
+                });
+                const idColumns = pkFields.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, pkFields.length > 1));
+                prop.fieldNames = [prop.discriminatorColumn, ...idColumns];
+            }
+        }
+        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             prop.fieldNames = this.initManyToOneFieldName(prop, prop.name);
         }
         else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
@@ -1246,8 +1257,17 @@ export class MetadataDiscovery {
             if (embeddedProp.nullable || refInArray) {
                 meta.properties[name].nullable = true;
             }
+            // polymorphic relations derive their column names from the discriminator, so prefix it too
+            if (meta.properties[name].polymorphic && !object) {
+                meta.properties[name].discriminator = prefix + meta.properties[name].discriminator;
+                meta.properties[name].discriminatorColumn = prefix + meta.properties[name].discriminatorColumn;
+            }
             if (meta.properties[name].fieldNames) {
-                meta.properties[name].fieldNames[0] = prefix + meta.properties[name].fieldNames[0];
+                const { fieldNames, polymorphic } = meta.properties[name];
+                // polymorphic `fieldNames` hold `[discriminatorColumn, ...fkIdColumns]`, so prefix all of them
+                for (let i = 0; i < (polymorphic ? fieldNames.length : 1); i++) {
+                    fieldNames[i] = prefix + fieldNames[i];
+                }
             }
             else {
                 const name2 = meta.properties[name].name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.15-dev.1",
+  "version": "7.1.15-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/utils/EntityComparator.js

@@ -587,7 +587,7 @@ export class EntityComparator {
                 }
             }
             else if (prop.polymorphic) {
-                const discriminatorMapKey = `discriminatorMapReverse_${prop.name}`;
+                const discriminatorMapKey = `discriminatorMapReverse_${this.safeKey(prop.name)}`;
                 const reverseMap = new Map();
                 for (const [key, value] of Object.entries(prop.discriminatorMap)) {
                     reverseMap.set(value, key);

package/utils/Utils.js

@@ -153,7 +153,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.15-dev.1';
+    static #ORM_VERSION = '7.1.15-dev.10';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */