@mikro-orm/core 7.0.4 → 7.0.5-dev.1

package/entity/EntityAssigner.d.ts

@@ -2,96 +2,85 @@ import type { EntityManager } from '../EntityManager.js';
 import type { EntityData, EntityDTO, EntityProperty, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
 /** Handles assigning data to entities, resolving relations, and propagating changes. */
 export declare class EntityAssigner {
-  /** Assigns the given data to the entity, resolving relations and handling custom types. */
-  static assign<
-    Entity extends object,
-    Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
-    Convert extends boolean = false,
-    Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> =
-      | EntityData<Naked, Convert>
-      | Partial<EntityDTO<Naked>>,
-  >(
-    entity: Entity,
-    data: Data & IsSubset<EntityData<Naked, Convert>, Data>,
-    options?: AssignOptions<Convert>,
-  ): MergeSelected<Entity, Naked, keyof Data & string>;
-  private static assignProperty;
-  /**
-   * auto-wire 1:1 inverse side with owner as in no-sql drivers it can't be joined
-   * also makes sure the link is bidirectional when creating new entities from nested structures
-   * @internal
-   */
-  static autoWireOneToOne<T extends object, O extends object>(prop: EntityProperty<O, T>, entity: O): void;
-  private static validateEM;
-  private static assignReference;
-  private static assignCollection;
-  private static assignEmbeddable;
-  private static createCollectionItem;
+    /** Assigns the given data to the entity, resolving relations and handling custom types. */
+    static assign<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(entity: Entity, data: Data & IsSubset<EntityData<Naked, Convert>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
+    private static assignProperty;
+    /**
+     * auto-wire 1:1 inverse side with owner as in no-sql drivers it can't be joined
+     * also makes sure the link is bidirectional when creating new entities from nested structures
+     * @internal
+     */
+    static autoWireOneToOne<T extends object, O extends object>(prop: EntityProperty<O, T>, entity: O): void;
+    private static validateEM;
+    private static assignReference;
+    private static assignCollection;
+    private static assignEmbeddable;
+    private static createCollectionItem;
 }
 export declare const assign: typeof EntityAssigner.assign;
 /** Options controlling how data is assigned to an entity via `assign()`. */
 export interface AssignOptions<Convert extends boolean> {
-  /**
-   * Allows disabling processing of nested relations. When disabled, an object payload in place of a relation always
-   * results in an `INSERT` query. To assign a value of the relation, use the foreign key instead of an object.
-   * Defaults to `true`.
-   */
-  updateNestedEntities?: boolean;
-  /**
-   * When assigning to a relation property with object payload and `updateNestedEntities` enabled (default), you can
-   * control how a payload without a primary key is handled. By default, it is considered as a new object, resulting
-   * in an `INSERT` query. Use `updateByPrimaryKey: false` to allow assigning the data on an existing relation instead.
-   * Defaults to `true`.
-   */
-  updateByPrimaryKey?: boolean;
-  /**
-   * When you have some properties in the payload that are not represented by an entity property mapping, you can skip
-   * such unknown properties via `onlyProperties: true`. Defaults to `false`.
-   */
-  onlyProperties?: boolean;
-  /**
-   * With `onlyOwnProperties` enabled, inverse sides of to-many relations are skipped, and payloads of other relations are converted
-   * to foreign keys. Defaults to `false`.
-   */
-  onlyOwnProperties?: boolean;
-  /**
-   * With `ignoreUndefined` enabled, `undefined` properties passed in the payload are skipped. Defaults to `false`.
-   */
-  ignoreUndefined?: boolean;
-  /**
-   * `assign` excepts runtime values for properties using custom types. To be able to assign raw database values, you
-   * can enable the `convertCustomTypes` option. Defaults to `false`.
-   */
-  convertCustomTypes?: Convert;
-  /**
-   * When assigning to a JSON property, the value is replaced. Use `mergeObjectProperties: true` to enable deep merging
-   * of the payload with the existing value. Defaults to `false`.
-   */
-  mergeObjectProperties?: boolean;
-  /**
-   * When assigning to an embedded property, the values are deeply merged with the existing data.
-   * Use `mergeEmbeddedProperties: false` to replace them instead. Defaults to `true`.
-   */
-  mergeEmbeddedProperties?: boolean;
-  /**
-   * When assigning to a relation property, if the value is a POJO and `updateByPrimaryKey` is enabled, we check if
-   * the target exists in the identity map based on its primary key and call `assign` on it recursively. If there is
-   * no primary key provided, or the entity is not present in the context, such an entity is considered as new
-   * (resulting in `INSERT` query), created via `em.create()`. You can use `merge: true` to use `em.merge()` instead,
-   * which means there won't be any query used for persisting the relation. Defaults to `false`.
-   */
-  merge?: boolean;
-  /**
-   * When assigning to a to-many relation properties (`Collection`) with `updateNestedEntities` and `updateByPrimaryKey`
-   * enabled (default), you can use this option to override the relation schema. This is used only when trying to find
-   * the entity reference in the current context. If it is not found, we create the relation entity using the target
-   * entity schema. The value is automatically inferred from the target entity.
-   */
-  schema?: string;
-  /**
-   * When using the static `assign()` helper, you can pass the EntityManager instance explicitly via the `em` option.
-   * This is only needed when you try to assign a relation property. The value is automatically inferred from the target
-   * entity when it is managed, or when you use `em.assign()` instead.
-   */
-  em?: EntityManager;
+    /**
+     * Allows disabling processing of nested relations. When disabled, an object payload in place of a relation always
+     * results in an `INSERT` query. To assign a value of the relation, use the foreign key instead of an object.
+     * Defaults to `true`.
+     */
+    updateNestedEntities?: boolean;
+    /**
+     * When assigning to a relation property with object payload and `updateNestedEntities` enabled (default), you can
+     * control how a payload without a primary key is handled. By default, it is considered as a new object, resulting
+     * in an `INSERT` query. Use `updateByPrimaryKey: false` to allow assigning the data on an existing relation instead.
+     * Defaults to `true`.
+     */
+    updateByPrimaryKey?: boolean;
+    /**
+     * When you have some properties in the payload that are not represented by an entity property mapping, you can skip
+     * such unknown properties via `onlyProperties: true`. Defaults to `false`.
+     */
+    onlyProperties?: boolean;
+    /**
+     * With `onlyOwnProperties` enabled, inverse sides of to-many relations are skipped, and payloads of other relations are converted
+     * to foreign keys. Defaults to `false`.
+     */
+    onlyOwnProperties?: boolean;
+    /**
+     * With `ignoreUndefined` enabled, `undefined` properties passed in the payload are skipped. Defaults to `false`.
+     */
+    ignoreUndefined?: boolean;
+    /**
+     * `assign` excepts runtime values for properties using custom types. To be able to assign raw database values, you
+     * can enable the `convertCustomTypes` option. Defaults to `false`.
+     */
+    convertCustomTypes?: Convert;
+    /**
+     * When assigning to a JSON property, the value is replaced. Use `mergeObjectProperties: true` to enable deep merging
+     * of the payload with the existing value. Defaults to `false`.
+     */
+    mergeObjectProperties?: boolean;
+    /**
+     * When assigning to an embedded property, the values are deeply merged with the existing data.
+     * Use `mergeEmbeddedProperties: false` to replace them instead. Defaults to `true`.
+     */
+    mergeEmbeddedProperties?: boolean;
+    /**
+     * When assigning to a relation property, if the value is a POJO and `updateByPrimaryKey` is enabled, we check if
+     * the target exists in the identity map based on its primary key and call `assign` on it recursively. If there is
+     * no primary key provided, or the entity is not present in the context, such an entity is considered as new
+     * (resulting in `INSERT` query), created via `em.create()`. You can use `merge: true` to use `em.merge()` instead,
+     * which means there won't be any query used for persisting the relation. Defaults to `false`.
+     */
+    merge?: boolean;
+    /**
+     * When assigning to a to-many relation properties (`Collection`) with `updateNestedEntities` and `updateByPrimaryKey`
+     * enabled (default), you can use this option to override the relation schema. This is used only when trying to find
+     * the entity reference in the current context. If it is not found, we create the relation entity using the target
+     * entity schema. The value is automatically inferred from the target entity.
+     */
+    schema?: string;
+    /**
+     * When using the static `assign()` helper, you can pass the EntityManager instance explicitly via the `em` option.
+     * This is only needed when you try to assign a relation property. The value is automatically inferred from the target
+     * entity when it is managed, or when you use `em.assign()` instead.
+     */
+    em?: EntityManager;
 }

package/entity/EntityAssigner.js

@@ -8,244 +8,243 @@ import { EntityHelper } from './EntityHelper.js';
 import { ValidationError } from '../errors.js';
 /** Handles assigning data to entities, resolving relations, and propagating changes. */
 export class EntityAssigner {
-  /** Assigns the given data to the entity, resolving relations and handling custom types. */
-  static assign(entity, data, options = {}) {
-    let opts = options;
-    if (opts.visited?.has(entity)) {
-      return entity;
-    }
-    EntityHelper.ensurePropagation(entity);
-    opts.visited ??= new Set();
-    opts.visited.add(entity);
-    const wrapped = helper(entity);
-    opts = {
-      ...wrapped.__config.get('assign'),
-      schema: wrapped.__schema,
-      ...opts, // allow overriding the defaults
-    };
-    const meta = wrapped.__meta;
-    const props = meta.properties;
-    Object.keys(data).forEach(prop => {
-      return EntityAssigner.assignProperty(entity, prop, props, data, {
-        ...opts,
-        em: opts.em || wrapped.__em,
-        platform: wrapped.__platform,
-      });
-    });
-    return entity;
-  }
-  static assignProperty(entity, propName, props, data, options) {
-    let value = data[propName];
-    const onlyProperties = options.onlyProperties && !(propName in props);
-    const ignoreUndefined = options.ignoreUndefined === true && value === undefined;
-    if (onlyProperties || ignoreUndefined) {
-      return;
-    }
-    const prop = { ...props[propName], name: propName };
-    if (prop && options.onlyOwnProperties) {
-      if ([ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
-        return;
-      }
-      if ([ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
-        if (!prop.owner) {
-          return;
-        } else if (value?.map) {
-          value = value.map(v => Utils.extractPK(v, prop.targetMeta));
-        }
-      }
-      if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-        value = Utils.extractPK(value, prop.targetMeta);
-      }
-    }
-    if (propName in props && !prop.nullable && value == null) {
-      throw new Error(
-        `You must pass a non-${value} value to the property ${propName} of entity ${entity.constructor.name}.`,
-      );
-    }
-    // create collection instance if its missing so old items can be deleted with orphan removal
-    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop?.kind) && entity[prop.name] == null) {
-      entity[prop.name] = Collection.create(entity, prop.name, undefined, helper(entity).isInitialized());
-    }
-    if (prop && Utils.isCollection(entity[prop.name])) {
-      return EntityAssigner.assignCollection(entity, entity[prop.name], value, prop, options.em, options);
-    }
-    const customType = prop?.customType;
-    if (options.convertCustomTypes && customType && prop.kind === ReferenceKind.SCALAR && !Utils.isEntity(data)) {
-      value = customType.convertToJSValue(value, options.platform);
-    }
-    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
-      if (
-        options.updateNestedEntities &&
-        Object.hasOwn(entity, propName) &&
-        Utils.isEntity(entity[propName], true) &&
-        Utils.isPlainObject(value)
-      ) {
-        const unwrappedEntity = Reference.unwrapReference(entity[propName]);
-        const wrapped = helper(unwrappedEntity);
-        if (options.updateByPrimaryKey) {
-          const pk = Utils.extractPK(value, prop.targetMeta);
-          if (pk) {
-            const ref = options.em.getReference(prop.targetMeta.class, pk, options);
-            // if the PK differs, we want to change the target entity, not update it
-            const wrappedChild = helper(ref);
-            const sameTarget = wrappedChild.getSerializedPrimaryKey() === wrapped.getSerializedPrimaryKey();
-            if (wrappedChild.__managed && wrappedChild.isInitialized() && sameTarget) {
-              return EntityAssigner.assign(ref, value, options);
+    /** Assigns the given data to the entity, resolving relations and handling custom types. */
+    static assign(entity, data, options = {}) {
+        let opts = options;
+        if (opts.visited?.has(entity)) {
+            return entity;
+        }
+        EntityHelper.ensurePropagation(entity);
+        opts.visited ??= new Set();
+        opts.visited.add(entity);
+        const wrapped = helper(entity);
+        opts = {
+            ...wrapped.__config.get('assign'),
+            schema: wrapped.__schema,
+            ...opts, // allow overriding the defaults
+        };
+        const meta = wrapped.__meta;
+        const props = meta.properties;
+        Object.keys(data).forEach(prop => {
+            return EntityAssigner.assignProperty(entity, prop, props, data, {
+                ...opts,
+                em: opts.em || wrapped.__em,
+                platform: wrapped.__platform,
+            });
+        });
+        return entity;
+    }
+    static assignProperty(entity, propName, props, data, options) {
+        let value = data[propName];
+        const onlyProperties = options.onlyProperties && !(propName in props);
+        const ignoreUndefined = options.ignoreUndefined === true && value === undefined;
+        if (onlyProperties || ignoreUndefined) {
+            return;
+        }
+        const prop = { ...props[propName], name: propName };
+        if (prop && options.onlyOwnProperties) {
+            if ([ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+                return;
+            }
+            if ([ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                if (!prop.owner) {
+                    return;
+                }
+                else if (value?.map) {
+                    value = value.map((v) => Utils.extractPK(v, prop.targetMeta));
+                }
+            }
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                value = Utils.extractPK(value, prop.targetMeta);
             }
-          }
-          return EntityAssigner.assignReference(entity, value, prop, options.em, options);
         }
-        if (wrapped.__managed && wrap(unwrappedEntity).isInitialized()) {
-          return EntityAssigner.assign(unwrappedEntity, value, options);
+        if (propName in props && !prop.nullable && value == null) {
+            throw new Error(`You must pass a non-${value} value to the property ${propName} of entity ${entity.constructor.name}.`);
+        }
+        // create collection instance if its missing so old items can be deleted with orphan removal
+        if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop?.kind) && entity[prop.name] == null) {
+            entity[prop.name] = Collection.create(entity, prop.name, undefined, helper(entity).isInitialized());
+        }
+        if (prop && Utils.isCollection(entity[prop.name])) {
+            return EntityAssigner.assignCollection(entity, entity[prop.name], value, prop, options.em, options);
+        }
+        const customType = prop?.customType;
+        if (options.convertCustomTypes && customType && prop.kind === ReferenceKind.SCALAR && !Utils.isEntity(data)) {
+            value = customType.convertToJSValue(value, options.platform);
+        }
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
+            if (options.updateNestedEntities &&
+                Object.hasOwn(entity, propName) &&
+                Utils.isEntity(entity[propName], true) &&
+                Utils.isPlainObject(value)) {
+                const unwrappedEntity = Reference.unwrapReference(entity[propName]);
+                const wrapped = helper(unwrappedEntity);
+                if (options.updateByPrimaryKey) {
+                    const pk = Utils.extractPK(value, prop.targetMeta);
+                    if (pk) {
+                        const ref = options.em.getReference(prop.targetMeta.class, pk, options);
+                        // if the PK differs, we want to change the target entity, not update it
+                        const wrappedChild = helper(ref);
+                        const sameTarget = wrappedChild.getSerializedPrimaryKey() === wrapped.getSerializedPrimaryKey();
+                        if (wrappedChild.__managed && wrappedChild.isInitialized() && sameTarget) {
+                            return EntityAssigner.assign(ref, value, options);
+                        }
+                    }
+                    return EntityAssigner.assignReference(entity, value, prop, options.em, options);
+                }
+                if (wrapped.__managed && wrap(unwrappedEntity).isInitialized()) {
+                    return EntityAssigner.assign(unwrappedEntity, value, options);
+                }
+            }
+            return EntityAssigner.assignReference(entity, value, prop, options.em, options);
+        }
+        if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && (prop.setter || !prop.getter)) {
+            validateProperty(prop, value, entity);
+            return (entity[prop.name] = value);
+        }
+        if (prop.kind === ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
+            return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);
+        }
+        if (options.mergeObjectProperties &&
+            Utils.isPlainObject(entity[propName]) &&
+            Utils.isPlainObject(value)) {
+            entity[propName] ??= {};
+            entity[propName] = Utils.merge({}, entity[propName], value);
+        }
+        else if (!prop || prop.setter || !prop.getter) {
+            entity[propName] = value;
         }
-      }
-      return EntityAssigner.assignReference(entity, value, prop, options.em, options);
-    }
-    if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && (prop.setter || !prop.getter)) {
-      validateProperty(prop, value, entity);
-      return (entity[prop.name] = value);
-    }
-    if (prop.kind === ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
-      return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);
-    }
-    if (options.mergeObjectProperties && Utils.isPlainObject(entity[propName]) && Utils.isPlainObject(value)) {
-      entity[propName] ??= {};
-      entity[propName] = Utils.merge({}, entity[propName], value);
-    } else if (!prop || prop.setter || !prop.getter) {
-      entity[propName] = value;
-    }
-  }
-  /**
-   * auto-wire 1:1 inverse side with owner as in no-sql drivers it can't be joined
-   * also makes sure the link is bidirectional when creating new entities from nested structures
-   * @internal
-   */
-  static autoWireOneToOne(prop, entity) {
-    const ref = entity[prop.name];
-    if (prop.kind !== ReferenceKind.ONE_TO_ONE || !Utils.isEntity(ref)) {
-      return;
-    }
-    const meta2 = helper(ref).__meta;
-    const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
-    /* v8 ignore next */
-    if (prop2 && !ref[prop2.name]) {
-      if (Reference.isReference(ref)) {
-        ref.unwrap()[prop2.name] = Reference.wrapReference(entity, prop2);
-      } else {
-        ref[prop2.name] = Reference.wrapReference(entity, prop2);
-      }
-    }
-  }
-  static validateEM(em) {
-    if (!em) {
-      throw new Error(
-        `To use assign() on not managed entities, explicitly provide EM instance: wrap(entity).assign(data, { em: orm.em })`,
-      );
-    }
-    return true;
-  }
-  static assignReference(entity, value, prop, em, options) {
-    if (Utils.isEntity(value, true)) {
-      entity[prop.name] = Reference.wrapReference(value, prop);
-    } else if (Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
-      entity[prop.name] = prop.mapToPk
-        ? value
-        : Reference.wrapReference(em.getReference(prop.targetMeta.class, value, options), prop);
-    } else if (Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
-      entity[prop.name] = Reference.wrapReference(em.merge(prop.targetMeta.class, value, options), prop);
-    } else if (Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
-      entity[prop.name] = Reference.wrapReference(em.create(prop.targetMeta.class, value, options), prop);
-    } else {
-      const name = entity.constructor.name;
-      throw new Error(
-        `Invalid reference value provided for '${name}.${prop.name}' in ${name}.assign(): ${JSON.stringify(value)}`,
-      );
-    }
-    EntityAssigner.autoWireOneToOne(prop, entity);
-  }
-  static assignCollection(entity, collection, value, prop, em, options) {
-    const invalid = [];
-    const items = Utils.asArray(value).map((item, idx) => {
-      // try to propagate missing owning side reference to the payload first
-      const prop2 = prop.targetMeta?.properties[prop.mappedBy];
-      if (Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
-        item = { ...item, [prop2.name]: Reference.wrapReference(entity, prop2) };
-      }
-      if (options.updateNestedEntities && options.updateByPrimaryKey && Utils.isPlainObject(item)) {
-        const pk = Utils.extractPK(item, prop.targetMeta);
-        if (pk && EntityAssigner.validateEM(em)) {
-          const ref = em.getUnitOfWork().getById(prop.targetMeta.class, pk, options.schema);
-          if (ref) {
-            return EntityAssigner.assign(ref, item, options);
-          }
-        }
-        return this.createCollectionItem(item, em, prop, invalid, options);
-      }
-      /* v8 ignore next */
-      if (
-        options.updateNestedEntities &&
-        !options.updateByPrimaryKey &&
-        collection[idx] &&
-        helper(collection[idx])?.isInitialized()
-      ) {
-        return EntityAssigner.assign(collection[idx], item, options);
-      }
-      return this.createCollectionItem(item, em, prop, invalid, options);
-    });
-    if (invalid.length > 0) {
-      const name = entity.constructor.name;
-      throw ValidationError.invalidCollectionValues(name, prop.name, invalid);
-    }
-    if (Array.isArray(value)) {
-      collection.set(items);
-    } else {
-      // append to the collection in case of assigning a single value instead of array
-      collection.add(items);
-    }
-  }
-  static assignEmbeddable(entity, value, prop, em, options) {
-    const propName = prop.embedded ? prop.embedded[1] : prop.name;
-    if (value == null) {
-      entity[propName] = value;
-      return;
-    }
-    // if the value is not an array, we just push, otherwise we replace the array
-    if (prop.array && (Array.isArray(value) || entity[propName] == null)) {
-      entity[propName] = [];
-    }
-    if (prop.array) {
-      return Utils.asArray(value).forEach(item => {
-        const tmp = {};
-        this.assignEmbeddable(tmp, item, { ...prop, array: false }, em, options);
-        entity[propName].push(...Object.values(tmp));
-      });
     }
-    const create = () =>
-      EntityAssigner.validateEM(em) &&
-      em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
-        convertCustomTypes: options.convertCustomTypes,
-        newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
-      });
-    entity[propName] = options.mergeEmbeddedProperties ? entity[propName] || create() : create();
-    Object.keys(value).forEach(key => {
-      EntityAssigner.assignProperty(entity[propName], key, prop.embeddedProps, value, options);
-    });
-  }
-  static createCollectionItem(item, em, prop, invalid, options) {
-    if (Utils.isEntity(item)) {
-      return item;
+    /**
+     * auto-wire 1:1 inverse side with owner as in no-sql drivers it can't be joined
+     * also makes sure the link is bidirectional when creating new entities from nested structures
+     * @internal
+     */
+    static autoWireOneToOne(prop, entity) {
+        const ref = entity[prop.name];
+        if (prop.kind !== ReferenceKind.ONE_TO_ONE || !Utils.isEntity(ref)) {
+            return;
+        }
+        const meta2 = helper(ref).__meta;
+        const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
+        /* v8 ignore next */
+        if (prop2 && !ref[prop2.name]) {
+            if (Reference.isReference(ref)) {
+                ref.unwrap()[prop2.name] = Reference.wrapReference(entity, prop2);
+            }
+            else {
+                ref[prop2.name] = Reference.wrapReference(entity, prop2);
+            }
+        }
     }
-    if (Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
-      return em.getReference(prop.targetMeta.class, item, options);
+    static validateEM(em) {
+        if (!em) {
+            throw new Error(`To use assign() on not managed entities, explicitly provide EM instance: wrap(entity).assign(data, { em: orm.em })`);
+        }
+        return true;
     }
-    if (Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
-      return em.merge(prop.targetMeta.class, item, options);
+    static assignReference(entity, value, prop, em, options) {
+        if (Utils.isEntity(value, true)) {
+            entity[prop.name] = Reference.wrapReference(value, prop);
+        }
+        else if (Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = prop.mapToPk
+                ? value
+                : Reference.wrapReference(em.getReference(prop.targetMeta.class, value, options), prop);
+        }
+        else if (Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference.wrapReference(em.merge(prop.targetMeta.class, value, options), prop);
+        }
+        else if (Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference.wrapReference(em.create(prop.targetMeta.class, value, options), prop);
+        }
+        else {
+            const name = entity.constructor.name;
+            throw new Error(`Invalid reference value provided for '${name}.${prop.name}' in ${name}.assign(): ${JSON.stringify(value)}`);
+        }
+        EntityAssigner.autoWireOneToOne(prop, entity);
+    }
+    static assignCollection(entity, collection, value, prop, em, options) {
+        const invalid = [];
+        const items = Utils.asArray(value).map((item, idx) => {
+            // try to propagate missing owning side reference to the payload first
+            const prop2 = prop.targetMeta?.properties[prop.mappedBy];
+            if (Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
+                item = { ...item, [prop2.name]: Reference.wrapReference(entity, prop2) };
+            }
+            if (options.updateNestedEntities && options.updateByPrimaryKey && Utils.isPlainObject(item)) {
+                const pk = Utils.extractPK(item, prop.targetMeta);
+                if (pk && EntityAssigner.validateEM(em)) {
+                    const ref = em.getUnitOfWork().getById(prop.targetMeta.class, pk, options.schema);
+                    if (ref) {
+                        return EntityAssigner.assign(ref, item, options);
+                    }
+                }
+                return this.createCollectionItem(item, em, prop, invalid, options);
+            }
+            /* v8 ignore next */
+            if (options.updateNestedEntities &&
+                !options.updateByPrimaryKey &&
+                collection[idx] &&
+                helper(collection[idx])?.isInitialized()) {
+                return EntityAssigner.assign(collection[idx], item, options);
+            }
+            return this.createCollectionItem(item, em, prop, invalid, options);
+        });
+        if (invalid.length > 0) {
+            const name = entity.constructor.name;
+            throw ValidationError.invalidCollectionValues(name, prop.name, invalid);
+        }
+        if (Array.isArray(value)) {
+            collection.set(items);
+        }
+        else {
+            // append to the collection in case of assigning a single value instead of array
+            collection.add(items);
+        }
     }
-    if (Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
-      return em.create(prop.targetMeta.class, item, options);
+    static assignEmbeddable(entity, value, prop, em, options) {
+        const propName = prop.embedded ? prop.embedded[1] : prop.name;
+        if (value == null) {
+            entity[propName] = value;
+            return;
+        }
+        // if the value is not an array, we just push, otherwise we replace the array
+        if (prop.array && (Array.isArray(value) || entity[propName] == null)) {
+            entity[propName] = [];
+        }
+        if (prop.array) {
+            return Utils.asArray(value).forEach(item => {
+                const tmp = {};
+                this.assignEmbeddable(tmp, item, { ...prop, array: false }, em, options);
+                entity[propName].push(...Object.values(tmp));
+            });
+        }
+        const create = () => EntityAssigner.validateEM(em) &&
+            em.getEntityFactory().createEmbeddable(prop.targetMeta.class, value, {
+                convertCustomTypes: options.convertCustomTypes,
+                newEntity: options.mergeEmbeddedProperties ? !('propName' in entity) : true,
+            });
+        entity[propName] = (options.mergeEmbeddedProperties ? entity[propName] || create() : create());
+        Object.keys(value).forEach(key => {
+            EntityAssigner.assignProperty(entity[propName], key, prop.embeddedProps, value, options);
+        });
+    }
+    static createCollectionItem(item, em, prop, invalid, options) {
+        if (Utils.isEntity(item)) {
+            return item;
+        }
+        if (Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
+            return em.getReference(prop.targetMeta.class, item, options);
+        }
+        if (Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
+            return em.merge(prop.targetMeta.class, item, options);
+        }
+        if (Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
+            return em.create(prop.targetMeta.class, item, options);
+        }
+        invalid.push(item);
+        return item;
     }
-    invalid.push(item);
-    return item;
-  }
 }
 export const assign = EntityAssigner.assign;