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

package/EntityManager.js

@@ -789,7 +789,9 @@ export class EntityManager {
         })) => {
             for (const prop of helper(e).__meta.props) {
                 if (prop.kind === ReferenceKind.SCALAR && !prop.ref) {
-                    data[prop.name] = e[prop.name];
+                    if (helper(e).__initialized || prop.primary) {
+                        data[prop.name] = e[prop.name];
+                    }
                     continue;
                 }
                 if (prop.serializedName && prop.serializedName in data) {

package/drivers/DatabaseDriver.d.ts

@@ -81,6 +81,8 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
      */
     private mapCursorOffset;
     protected createCursorCondition<T extends object>(definition: (readonly [keyof T & string, QueryOrder])[], offsets: Dictionary[], inverse: boolean, meta: EntityMetadata<T>, fromJson?: boolean): FilterQuery<T>;
+    /** @internal Polymorphic embeddable variants can declare same-named properties with different field names. */
+    protected variantProps(prop: EntityProperty, data?: Dictionary): Dictionary<EntityProperty>;
     /** @internal */
     mapDataToFieldNames(data: Dictionary, stringifyJsonArrays: boolean, properties?: Record<string, EntityProperty>, convertCustomTypes?: boolean, object?: boolean): Dictionary;
     protected inlineEmbeddables<T extends object>(meta: EntityMetadata<T>, data: T, where?: boolean): void;

package/drivers/DatabaseDriver.js

@@ -403,6 +403,19 @@ export class DatabaseDriver {
         }
         return { ...atOrPast, ...past };
     }
+    /** @internal Polymorphic embeddable variants can declare same-named properties with different field names. */
+    variantProps(prop, data) {
+        const meta = prop.targetMeta;
+        // eslint-disable-next-line eqeqeq
+        const variant = meta?.polymorphs?.find(m => m.discriminatorValue == data?.[meta.discriminatorColumn]);
+        const props = variant ? { ...prop.embeddedProps } : prop.embeddedProps;
+        for (const p of variant ? Object.values(props) : []) {
+            if (variant.properties[p.embedded[1]] && Utils.isSameKind(variant.properties[p.embedded[1]], p)) {
+                props[p.embedded[1]] = p;
+            }
+        }
+        return props;
+    }
     /** @internal */
     mapDataToFieldNames(data, stringifyJsonArrays, properties, convertCustomTypes, object) {
         if (!properties || data == null) {
@@ -417,17 +430,17 @@ export class DatabaseDriver {
             if (prop.embeddedProps && !prop.object && !object) {
                 const copy = data[k];
                 delete data[k];
-                Object.assign(data, this.mapDataToFieldNames(copy, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes));
+                Object.assign(data, this.mapDataToFieldNames(copy, stringifyJsonArrays, this.variantProps(prop, copy), convertCustomTypes));
                 return;
             }
             if (prop.embeddedProps && (object || prop.object)) {
                 const copy = data[k];
                 delete data[k];
                 if (prop.array) {
-                    data[prop.fieldNames[0]] = copy?.map((item) => this.mapDataToFieldNames(item, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes, true));
+                    data[prop.fieldNames[0]] = copy?.map((item) => this.mapDataToFieldNames(item, stringifyJsonArrays, this.variantProps(prop, item), convertCustomTypes, true));
                 }
                 else {
-                    data[prop.fieldNames[0]] = this.mapDataToFieldNames(copy, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes, true);
+                    data[prop.fieldNames[0]] = this.mapDataToFieldNames(copy, stringifyJsonArrays, this.variantProps(prop, copy), convertCustomTypes, true);
                 }
                 if (stringifyJsonArrays && prop.array && !object) {
                     data[prop.fieldNames[0]] = this.platform.convertJsonToDatabaseValue(data[prop.fieldNames[0]]);

package/entity/EntityAssigner.js

@@ -234,14 +234,26 @@ export class EntityAssigner {
                 entity[propName].push(...Object.values(tmp));
             });
         }
+        const polymorphs = prop.targetMeta?.polymorphs;
+        // eslint-disable-next-line eqeqeq
+        const variant = polymorphs?.find(m => m.discriminatorValue == value[prop.targetMeta.discriminatorColumn]);
         const create = () => EntityAssigner.validateEM(em) &&
-            em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
+            em.getEntityFactory().createEmbeddable((variant ?? prop.targetMeta).class, value, {
                 convertCustomTypes: options.convertCustomTypes,
                 newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
             });
-        entity[propName] = (options.mergeEmbeddedProperties ? entity[propName] || create() : create());
+        // a different polymorphic variant cannot be merged into the current one
+        const merge = options.mergeEmbeddedProperties && (!variant || entity[propName]?.constructor === variant.class);
+        entity[propName] = (merge ? entity[propName] || create() : create());
+        const props = polymorphs ? { ...prop.embeddedProps } : prop.embeddedProps;
+        // polymorphic variants can declare same-named properties of different kinds or relation targets
+        for (const p of polymorphs ? entity[propName].__meta.props : []) {
+            if (props[p.name] && props[p.name].targetMeta?.class !== p.targetMeta?.class) {
+                props[p.name] = { ...p, nullable: prop.nullable || p.nullable };
+            }
+        }
         Object.keys(value).forEach(key => {
-            EntityAssigner.assignProperty(entity[propName], key, prop.embeddedProps, value, options);
+            EntityAssigner.assignProperty(entity[propName], key, props, value, options);
         });
     }
     static createCollectionItem(item, em, prop, invalid, options) {

package/entity/validators.js

@@ -24,7 +24,10 @@ export function validateProperty(prop, givenValue, entity) {
 }
 function getValue(o, prop) {
     if (prop.embedded && prop.embedded[0] in o) {
-        return o[prop.embedded[0]]?.[prop.embedded[1]];
+        const embeddable = o[prop.embedded[0]];
+        const variantProp = embeddable?.__meta?.properties[prop.embedded[1]];
+        // a same-named property of a different kind in another polymorphic variant
+        return variantProp && !Utils.isSameKind(variantProp, prop) ? undefined : embeddable?.[prop.embedded[1]];
     }
     /* v8 ignore next */
     if (prop.ref) {

package/hydration/ObjectHydrator.js

@@ -313,6 +313,10 @@ export class ObjectHydrator extends Hydrator {
                             ? dataKey + this.wrap(childProp.embedded[1])
                             : this.wrap(childProp.name);
                         const prop2 = childMeta.properties[childProp.embedded[1]];
+                        // a same-named property of a different kind in another variant
+                        if (prop2 && !Utils.isSameKind(prop2, childProp)) {
+                            return;
+                        }
                         const prop3 = {
                             ...prop2,
                             name: childProp.name,

package/metadata/MetadataDiscovery.js

@@ -463,7 +463,8 @@ export class MetadataDiscovery {
         }
     }
     initManyToOneFieldName(prop, name) {
-        const meta2 = prop.targetMeta;
+        // STI property renaming runs before `initRelation` populates `targetMeta`
+        const meta2 = prop.targetMeta ?? this.#metadata.getByClassName(prop.type);
         const ret = [];
         // with `targetKey` on a composite PK target, derive the FK field name from that property
         // instead of the PKs (simple PK targets keep the PK based naming for backwards compatibility)
@@ -1280,16 +1281,37 @@ export class MetadataDiscovery {
         // the prefix of the parent cannot be a boolean; it already passed here
         const prefix = this.getPrefix(embeddedProp, parentProperty);
         const glue = object ? '~' : '_';
-        for (const prop of Object.values(embeddable.properties)) {
-            const name = (embeddedProp.embeddedPath?.join(glue) ?? embeddedProp.fieldNames[0] + glue) + prop.name;
+        const props = Object.values(embeddable.properties);
+        // variants can declare a same-named property of a different kind, the virtual entity lacks it when the variants are shared with another union
+        for (const prop of embeddable.polymorphs?.flatMap(m => Object.values(m.properties)) ?? []) {
+            const same = props.find(p => p.name === prop.name && Utils.isSameKind(p, prop));
+            if (!same && !prop.embedded) {
+                props.push({ ...prop }); // a copy, the variant's metadata is shared with its other owners
+            }
+            else if (same && same.kind !== ReferenceKind.SCALAR && same.type !== prop.type) {
+                // a column shared by relations to different targets cannot have a FK constraint
+                same.createForeignKeyConstraint = false;
+            }
+        }
+        for (const prop of props) {
+            const sameName = props.filter(p => p.name === prop.name);
+            // same-kind variants of a conflicting property share one owner property, as they share the column
+            const first = sameName.find(p => Utils.isSameKind(p, prop));
+            const conflict = first !== sameName[0];
+            const name = (embeddedProp.embeddedPath?.join(glue) ?? embeddedProp.fieldNames[0] + glue) +
+                prop.name +
+                (conflict ? `_${props.indexOf(first)}` : '');
             meta.properties[name] = Utils.copy(prop);
             meta.properties[name].name = name;
+            // STI column tracking between the variants does not apply to the owner's columns
+            delete meta.properties[name].stiFieldNames;
             meta.properties[name].embedded = [embeddedProp.name, prop.name];
             meta.propertyOrder.set(name, (order += 0.01));
-            embeddedProp.embeddedProps[prop.name] = meta.properties[name];
+            embeddedProp.embeddedProps[conflict ? name : prop.name] = meta.properties[name];
             meta.properties[name].persist ??= embeddedProp.persist;
             const refInArray = array && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.owner;
-            if (embeddedProp.nullable || refInArray) {
+            // each variant fills only its own column of a conflicting property
+            if (embeddedProp.nullable || refInArray || sameName.some(p => !Utils.isSameKind(p, prop))) {
                 meta.properties[name].nullable = true;
             }
             // polymorphic relations derive their column names from the discriminator, so prefix it too
@@ -1462,6 +1484,13 @@ export class MetadataDiscovery {
                 rootProp.stiFieldNameMap[meta.discriminatorValue] = prop.fieldNames[0];
                 // subtypes that only differ in type share the column
                 rootProp.stiFieldNames = Utils.unique([...rootProp.stiFieldNames, ...prop.fieldNames]);
+                // a column shared by relations to different targets cannot have a FK constraint
+                for (const p of Object.values(meta.root.properties)) {
+                    const shared = p.type !== newProp.type && compareArrays(p.fieldNames ?? [], newProp.fieldNames);
+                    if (shared && p.kind !== ReferenceKind.SCALAR && Utils.isSameKind(p, newProp)) {
+                        p.createForeignKeyConstraint = newProp.createForeignKeyConstraint = false;
+                    }
+                }
                 newProp.nullable = true;
                 newProp.name = name;
                 newProp.hydrate = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.6-dev.0",
+  "version": "7.2.6-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/unit-of-work/ChangeSetComputer.js

@@ -165,7 +165,8 @@ export class ChangeSetComputer {
         const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
         targets.forEach(([rawTarget, idx]) => {
             const target = Reference.unwrapReference(rawTarget);
-            const needsProcessing = target != null && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
+            // a same-named scalar of another polymorphic embeddable variant is not a reference
+            const needsProcessing = Utils.isEntity(target) && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
             if (needsProcessing) {
                 // a reference known only by its `targetKey` has no PK, and is never inserted to generate one
                 if (!prop.targetKey && !target.__helper.__initialized) {

package/utils/EntityComparator.js

@@ -531,11 +531,22 @@ export class EntityComparator {
             }
             return true;
         }
+        // a same-named property of a different kind in another polymorphic variant applies only to its own variants
+        const guard = (childProp, code) => {
+            const variants = prop.targetMeta?.polymorphs?.filter(m => m.properties[childProp.embedded[1]]) ?? [];
+            const owners = variants.filter(m => Utils.isSameKind(m.properties[childProp.embedded[1]], childProp));
+            if (owners.length === variants.length) {
+                return code;
+            }
+            const discriminator = `entity${[...path, prop.targetMeta.discriminatorColumn].map(k => this.wrap(k)).join('')}`;
+            const conds = owners.map(m => `${discriminator} == ${JSON.stringify(m.discriminatorValue)}`);
+            return `${padding}  if (${conds.join(' || ')}) {\n${code}\n${padding}  }`;
+        };
+        const childProps = meta.props.filter(p => p.embedded?.[0] === prop.name &&
+            // object for JSON embeddable
+            (p.object || p.persist !== false));
         ret +=
-            meta.props
-                .filter(p => p.embedded?.[0] === prop.name &&
-                // object for JSON embeddable
-                (p.object || p.persist !== false))
+            childProps
                 .map(childProp => {
                 const childDataKey = meta.embeddable || prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
                 const childEntityKey = [...path, childProp.embedded[1]].map(k => this.wrap(k)).join('');
@@ -558,6 +569,7 @@ export class EntityComparator {
                 }
                 return `${padding}  if (${childCond}) ret${childDataKey} = clone(entity${childEntityKey});`;
             })
+                .map((code, i) => guard(childProps[i], code))
                 .join('\n') + `\n`;
         if (this.shouldSerialize(prop, dataKey)) {
             return `${ret + padding}  ret${dataKey} = cloneEmbeddable(ret${dataKey});\n${padding}}`;

package/utils/Utils.d.ts

@@ -175,6 +175,8 @@ export declare class Utils {
     static getORMVersion(): string;
     static createFunction(context: Map<string, any>, code: string, compiledFunctions?: CompiledFunctions, key?: string): any;
     static callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;
+    /** @internal Same-named properties of polymorphic embeddable variants conflict when their kinds differ, to-one kinds share the column. */
+    static isSameKind(a: EntityProperty, b: EntityProperty): boolean;
     static unwrapProperty<T>(entity: T, meta: EntityMetadata<T>, prop: EntityProperty<T>, payload?: boolean): [unknown, number[]][];
     static setPayloadProperty<T>(entity: EntityDictionary<T>, meta: EntityMetadata<T>, prop: EntityProperty<T>, value: unknown, idx: number[]): void;
     static tryImport<T extends Dictionary = any>({ module, warning, }: {

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.2.6-dev.0';
+    static #ORM_VERSION = '7.2.6-dev.10';
     /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
     static getRlsSettingName(filterName, argName) {
         return `mikro.${filterName}.${argName}`;
@@ -775,6 +775,11 @@ export class Utils {
             throw e;
         }
     }
+    /** @internal Same-named properties of polymorphic embeddable variants conflict when their kinds differ, to-one kinds share the column. */
+    static isSameKind(a, b) {
+        const toOne = (p) => p.kind === ReferenceKind.MANY_TO_ONE || p.kind === ReferenceKind.ONE_TO_ONE;
+        return a.kind === b.kind || (toOne(a) && toOne(b));
+    }
     static unwrapProperty(entity, meta, prop, payload = false) {
         let p = prop;
         const path = [];