@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/entity/Collection.js

@@ -0,0 +1,373 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+const ArrayCollection_1 = require("./ArrayCollection");
+const utils_1 = require("../utils");
+const errors_1 = require("../errors");
+const enums_1 = require("../enums");
+const Reference_1 = require("./Reference");
+const wrap_1 = require("./wrap");
+class Collection extends ArrayCollection_1.ArrayCollection {
+    readonly;
+    _populated;
+    _em;
+    // this is for some reason needed for TS, otherwise it can fail with `Type instantiation is excessively deep and possibly infinite.`
+    _snapshot;
+    constructor(owner, items, initialized = true) {
+        super(owner, items);
+        this.initialized = !!items || initialized;
+    }
+    /**
+     * Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)
+     */
+    static create(owner, prop, items, initialized) {
+        const coll = new Collection(owner, undefined, initialized);
+        coll.property = (0, wrap_1.helper)(owner).__meta.properties[prop];
+        owner[prop] = coll;
+        if (items) {
+            coll.set(items);
+        }
+        return coll;
+    }
+    /**
+     * Ensures the collection is loaded first (without reloading it if it already is loaded).
+     * Returns the Collection instance (itself), works the same as `Reference.load()`.
+     */
+    async load(options = {}) {
+        if (this.isInitialized(true) && !options.refresh) {
+            const em = this.getEntityManager(this.items, false);
+            await em?.populate(this.items, options.populate, options);
+        }
+        else {
+            await this.init(options);
+        }
+        return this;
+    }
+    /**
+     * Initializes the collection and returns the items
+     */
+    async loadItems(options) {
+        await this.load(options);
+        return super.getItems();
+    }
+    /**
+     * Gets the count of collection items from database instead of counting loaded items.
+     * The value is cached (unless you use the `where` option), use `refresh: true` to force reload it.
+     */
+    async loadCount(options = {}) {
+        options = typeof options === 'boolean' ? { refresh: options } : options;
+        const { refresh, where, ...countOptions } = options;
+        if (!refresh && !where && utils_1.Utils.isDefined(this._count)) {
+            return this._count;
+        }
+        const em = this.getEntityManager();
+        if (!em.getPlatform().usesPivotTable() && this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY && this.property.owner) {
+            return this._count = this.length;
+        }
+        const cond = this.createLoadCountCondition(where ?? {});
+        const count = await em.count(this.property.type, cond, countOptions);
+        if (!where) {
+            this._count = count;
+        }
+        return count;
+    }
+    async matching(options) {
+        const em = this.getEntityManager();
+        const { where, ctx, ...opts } = options;
+        opts.orderBy = this.createOrderBy(opts.orderBy);
+        let items;
+        if (this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable()) {
+            const cond = await em.applyFilters(this.property.type, where, options.filters ?? {}, 'read');
+            const map = await em.getDriver().loadFromPivotTable(this.property, [(0, wrap_1.helper)(this.owner).__primaryKeys], cond, opts.orderBy, ctx, options);
+            items = map[(0, wrap_1.helper)(this.owner).getSerializedPrimaryKey()].map((item) => em.merge(this.property.type, item, { convertCustomTypes: true }));
+        }
+        else {
+            items = await em.find(this.property.type, this.createCondition(where), opts);
+        }
+        if (options.store) {
+            this.hydrate(items, true);
+            this.populated();
+            this.readonly = true;
+        }
+        return items;
+    }
+    /**
+     * Returns the items (the collection must be initialized)
+     */
+    getItems(check = true) {
+        if (check) {
+            this.checkInitialized();
+        }
+        return super.getItems();
+    }
+    toJSON() {
+        if (!this.isInitialized()) {
+            return [];
+        }
+        return super.toJSON();
+    }
+    add(entity, ...entities) {
+        entities = utils_1.Utils.asArray(entity).concat(entities);
+        const unwrapped = entities.map(i => Reference_1.Reference.unwrapReference(i));
+        unwrapped.forEach(entity => this.validateItemType(entity));
+        this.modify('add', unwrapped);
+        this.cancelOrphanRemoval(unwrapped);
+    }
+    /**
+     * @inheritDoc
+     */
+    remove(entity, ...entities) {
+        if (entity instanceof Function) {
+            for (const item of this.items) {
+                if (entity(item)) {
+                    this.remove(item);
+                }
+            }
+            return;
+        }
+        entities = utils_1.Utils.asArray(entity).concat(entities);
+        const unwrapped = entities.map(i => Reference_1.Reference.unwrapReference(i));
+        this.modify('remove', unwrapped);
+        const em = this.getEntityManager(unwrapped, false);
+        if (this.property.orphanRemoval && em) {
+            for (const item of unwrapped) {
+                em.getUnitOfWork().scheduleOrphanRemoval(item);
+            }
+        }
+    }
+    contains(item, check = true) {
+        if (check) {
+            this.checkInitialized();
+        }
+        return super.contains(item);
+    }
+    count() {
+        this.checkInitialized();
+        return super.count();
+    }
+    isEmpty() {
+        this.checkInitialized();
+        return super.isEmpty();
+    }
+    /**
+     * @inheritDoc
+     */
+    slice(start, end) {
+        this.checkInitialized();
+        return super.slice(start, end);
+    }
+    /**
+     * @inheritDoc
+     */
+    exists(cb) {
+        this.checkInitialized();
+        return super.exists(cb);
+    }
+    /**
+     * @inheritDoc
+     */
+    find(cb) {
+        this.checkInitialized();
+        return super.find(cb);
+    }
+    /**
+     * @inheritDoc
+     */
+    filter(cb) {
+        this.checkInitialized();
+        return super.filter(cb);
+    }
+    /**
+     * @inheritDoc
+     */
+    map(mapper) {
+        this.checkInitialized();
+        return super.map(mapper);
+    }
+    /**
+     * @inheritDoc
+     */
+    indexBy(key, valueKey) {
+        this.checkInitialized();
+        return super.indexBy(key, valueKey);
+    }
+    shouldPopulate(populated) {
+        if (!this.isInitialized(true)) {
+            return false;
+        }
+        if (this._populated != null) {
+            return this._populated;
+        }
+        return !!populated;
+    }
+    populated(populated = true) {
+        this._populated = populated;
+    }
+    async init(options = {}) {
+        if (this.dirty) {
+            const items = [...this.items];
+            this.dirty = false;
+            await this.init(options);
+            items.forEach(i => this.add(i));
+            return this;
+        }
+        const em = this.getEntityManager();
+        if (options.dataloader ?? [enums_1.DataloaderType.ALL, enums_1.DataloaderType.COLLECTION].includes(utils_1.DataloaderUtils.getDataloaderType(em.config.get('dataloader')))) {
+            const order = [...this.items]; // copy order of references
+            const customOrder = !!options.orderBy;
+            // eslint-disable-next-line dot-notation
+            const items = await em['colLoader'].load([this, options]);
+            if (!customOrder) {
+                this.reorderItems(items, order);
+            }
+            this.items.clear();
+            let i = 0;
+            for (const item of items) {
+                this.items.add(item);
+                this[i++] = item;
+            }
+            this.initialized = true;
+            this.dirty = false;
+            return this;
+        }
+        const populate = Array.isArray(options.populate)
+            ? options.populate.map(f => f === '*' ? f : `${this.property.name}.${f}`)
+            : [`${this.property.name}${options.ref ? ':ref' : ''}`];
+        const schema = this.property.targetMeta.schema === '*'
+            ? (0, wrap_1.helper)(this.owner).__schema
+            : undefined;
+        await em.populate(this.owner, populate, {
+            ...options,
+            refresh: true,
+            connectionType: options.connectionType,
+            schema,
+            where: { [this.property.name]: options.where },
+            orderBy: { [this.property.name]: options.orderBy },
+        });
+        return this;
+    }
+    getEntityManager(items = [], required = true) {
+        const wrapped = (0, wrap_1.helper)(this.owner);
+        let em = (this._em ?? wrapped.__em);
+        if (!em) {
+            for (const i of this.items) {
+                if (i && (0, wrap_1.helper)(i).__em) {
+                    em = (0, wrap_1.helper)(i).__em;
+                    break;
+                }
+            }
+            for (const i of items) {
+                if (i && (0, wrap_1.helper)(i).__em) {
+                    em = (0, wrap_1.helper)(i).__em;
+                    break;
+                }
+            }
+        }
+        if (em) {
+            Object.defineProperty(this, '_em', { value: em });
+        }
+        if (!em && required) {
+            throw errors_1.ValidationError.entityNotManaged(this.owner);
+        }
+        return em;
+    }
+    createCondition(cond = {}) {
+        if (this.property.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
+            cond[this.property.mappedBy] = (0, wrap_1.helper)(this.owner).getPrimaryKey();
+        }
+        else { // MANY_TO_MANY
+            this.createManyToManyCondition(cond);
+        }
+        return cond;
+    }
+    createOrderBy(orderBy = []) {
+        if (utils_1.Utils.isEmpty(orderBy) && this.property.orderBy) {
+            orderBy = this.property.orderBy;
+        }
+        return utils_1.Utils.asArray(orderBy);
+    }
+    createManyToManyCondition(cond) {
+        const dict = cond;
+        if (this.property.owner || this.property.pivotTable) {
+            // we know there is at least one item as it was checked in load method
+            const pk = this.property.targetMeta.primaryKeys[0];
+            dict[pk] = { $in: [] };
+            this.items.forEach(item => dict[pk].$in.push((0, wrap_1.helper)(item).getPrimaryKey()));
+        }
+        else {
+            dict[this.property.mappedBy] = (0, wrap_1.helper)(this.owner).getPrimaryKey();
+        }
+    }
+    createLoadCountCondition(cond) {
+        const wrapped = (0, wrap_1.helper)(this.owner);
+        const val = wrapped.__meta.compositePK ? { $in: wrapped.__primaryKeys } : wrapped.getPrimaryKey();
+        const dict = cond;
+        if (this.property.kind === enums_1.ReferenceKind.ONE_TO_MANY) {
+            dict[this.property.mappedBy] = val;
+        }
+        else {
+            const key = this.property.owner ? this.property.inversedBy : this.property.mappedBy;
+            dict[key] = val;
+        }
+        return cond;
+    }
+    modify(method, items) {
+        if (method === 'remove') {
+            this.checkInitialized();
+        }
+        this.validateModification(items);
+        super[method](items);
+        this.setDirty();
+    }
+    checkInitialized() {
+        if (!this.isInitialized()) {
+            throw new Error(`Collection<${this.property.type}> of entity ${this.owner.constructor.name}[${(0, wrap_1.helper)(this.owner).getSerializedPrimaryKey()}] not initialized`);
+        }
+    }
+    /**
+     * re-orders items after searching with `$in` operator
+     */
+    reorderItems(items, order) {
+        if (this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY && this.property.owner) {
+            items.sort((a, b) => order.indexOf(a) - order.indexOf(b));
+        }
+    }
+    cancelOrphanRemoval(items) {
+        const em = this.getEntityManager(items, false);
+        if (!em) {
+            return;
+        }
+        for (const item of items) {
+            em.getUnitOfWork().cancelOrphanRemoval(item);
+        }
+    }
+    validateItemType(item) {
+        if (!utils_1.Utils.isEntity(item)) {
+            throw errors_1.ValidationError.notEntity(this.owner, this.property, item);
+        }
+    }
+    validateModification(items) {
+        if (this.readonly) {
+            throw errors_1.ValidationError.cannotModifyReadonlyCollection(this.owner, this.property);
+        }
+        // currently we allow persisting to inverse sides only in SQL drivers
+        if (this.property.pivotTable || !this.property.mappedBy) {
+            return;
+        }
+        const check = (item) => {
+            if (!item || (0, wrap_1.helper)(item).__initialized) {
+                return false;
+            }
+            return !item[this.property.mappedBy] && this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY;
+        };
+        // throw if we are modifying inverse side of M:N collection when owning side is initialized (would be ignored when persisting)
+        if (items.find(item => check(item))) {
+            throw errors_1.ValidationError.cannotModifyInverseCollection(this.owner, this.property);
+        }
+    }
+}
+exports.Collection = Collection;
+Object.defineProperties(Collection.prototype, {
+    $: { get() { return this; } },
+    get: { get() { return () => this; } },
+});

package/entity/EntityAssigner.d.ts

@@ -0,0 +1,28 @@
+import type { EntityManager } from '../EntityManager';
+import type { EntityData, EntityDTO, EntityProperty, IsSubset, FromEntityType, MergeSelected } from '../typings';
+export declare class EntityAssigner {
+    static assign<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Data extends EntityData<Naked> | Partial<EntityDTO<Naked>> = EntityData<Naked> | Partial<EntityDTO<Naked>>>(entity: Entity, data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions): 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;
+export interface AssignOptions {
+    updateNestedEntities?: boolean;
+    updateByPrimaryKey?: boolean;
+    onlyProperties?: boolean;
+    convertCustomTypes?: boolean;
+    mergeObjectProperties?: boolean;
+    merge?: boolean;
+    schema?: string;
+    em?: EntityManager;
+}

package/entity/EntityAssigner.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assign = exports.EntityAssigner = void 0;
+const util_1 = require("util");
+const Collection_1 = require("./Collection");
+const Utils_1 = require("../utils/Utils");
+const Reference_1 = require("./Reference");
+const enums_1 = require("../enums");
+const EntityValidator_1 = require("./EntityValidator");
+const wrap_1 = require("./wrap");
+const EntityHelper_1 = require("./EntityHelper");
+const validator = new EntityValidator_1.EntityValidator(false);
+class EntityAssigner {
+    static assign(entity, data, options = {}) {
+        let opts = options;
+        if (opts.visited?.has(entity)) {
+            return entity;
+        }
+        EntityHelper_1.EntityHelper.ensurePropagation(entity);
+        opts.visited ??= new Set();
+        opts.visited.add(entity);
+        const wrapped = (0, wrap_1.helper)(entity);
+        opts = {
+            updateNestedEntities: true,
+            updateByPrimaryKey: true,
+            mergeObjectProperties: true,
+            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) {
+        if (options.onlyProperties && !(propName in props)) {
+            return;
+        }
+        let value = data[propName];
+        const prop = { ...props[propName], name: propName };
+        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 ([enums_1.ReferenceKind.MANY_TO_MANY, enums_1.ReferenceKind.ONE_TO_MANY].includes(prop?.kind) && entity[prop.name] == null) {
+            entity[prop.name] = Collection_1.Collection.create(entity, prop.name, undefined, (0, wrap_1.helper)(entity).isInitialized());
+        }
+        if (prop && Utils_1.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 === enums_1.ReferenceKind.SCALAR && !Utils_1.Utils.isEntity(data)) {
+            value = customType.convertToJSValue(value, options.platform);
+        }
+        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
+            // eslint-disable-next-line no-prototype-builtins
+            if (options.updateNestedEntities && entity.hasOwnProperty(propName) && Utils_1.Utils.isEntity(entity[propName], true) && Utils_1.Utils.isPlainObject(value)) {
+                const unwrappedEntity = Reference_1.Reference.unwrapReference(entity[propName]);
+                const wrapped = (0, wrap_1.helper)(unwrappedEntity);
+                if (options.updateByPrimaryKey) {
+                    const pk = Utils_1.Utils.extractPK(value, prop.targetMeta);
+                    if (pk) {
+                        const ref = options.em.getReference(prop.type, pk, options);
+                        // if the PK differs, we want to change the target entity, not update it
+                        const wrappedChild = (0, wrap_1.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 && (0, wrap_1.wrap)(unwrappedEntity).isInitialized()) {
+                    return EntityAssigner.assign(unwrappedEntity, value, options);
+                }
+            }
+            return EntityAssigner.assignReference(entity, value, prop, options.em, options);
+        }
+        if (prop.kind === enums_1.ReferenceKind.SCALAR && enums_1.SCALAR_TYPES.includes(prop.runtimeType) && (prop.setter || !prop.getter)) {
+            return entity[prop.name] = validator.validateProperty(prop, value, entity);
+        }
+        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
+            return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);
+        }
+        if (options.mergeObjectProperties && Utils_1.Utils.isPlainObject(entity[propName]) && Utils_1.Utils.isPlainObject(value)) {
+            entity[propName] ??= {};
+            entity[propName] = Utils_1.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 !== enums_1.ReferenceKind.ONE_TO_ONE || !Utils_1.Utils.isEntity(ref)) {
+            return;
+        }
+        const meta2 = (0, wrap_1.helper)(ref).__meta;
+        const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
+        /* istanbul ignore next */
+        if (prop2 && !ref[prop2.name]) {
+            if (Reference_1.Reference.isReference(ref)) {
+                ref.unwrap()[prop2.name] = Reference_1.Reference.wrapReference(entity, prop2);
+            }
+            else {
+                ref[prop2.name] = Reference_1.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_1.Utils.isEntity(value, true)) {
+            entity[prop.name] = Reference_1.Reference.wrapReference(value, prop);
+        }
+        else if (Utils_1.Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = prop.mapToPk ? value : Reference_1.Reference.wrapReference(em.getReference(prop.type, value, options), prop);
+        }
+        else if (Utils_1.Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference_1.Reference.wrapReference(em.merge(prop.type, value, options), prop);
+        }
+        else if (Utils_1.Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference_1.Reference.wrapReference(em.create(prop.type, 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_1.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_1.Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
+                item = { ...item, [prop2.name]: Reference_1.Reference.wrapReference(entity, prop2) };
+            }
+            if (options.updateNestedEntities && options.updateByPrimaryKey && Utils_1.Utils.isPlainObject(item)) {
+                const pk = Utils_1.Utils.extractPK(item, prop.targetMeta);
+                if (pk && EntityAssigner.validateEM(em)) {
+                    const ref = em.getUnitOfWork().getById(prop.type, pk, options.schema);
+                    /* istanbul ignore else */
+                    if (ref) {
+                        return EntityAssigner.assign(ref, item, options);
+                    }
+                }
+                return this.createCollectionItem(item, em, prop, invalid, options);
+            }
+            /* istanbul ignore next */
+            if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && (0, wrap_1.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 new Error(`Invalid collection values provided for '${name}.${prop.name}' in ${name}.assign(): ${(0, util_1.inspect)(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_1.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.type, value, {
+            convertCustomTypes: options.convertCustomTypes,
+            newEntity: options.mergeObjectProperties ? !('propName' in entity) : true,
+        });
+        entity[propName] = (options.mergeObjectProperties ? (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_1.Utils.isEntity(item)) {
+            return item;
+        }
+        if (Utils_1.Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
+            return em.getReference(prop.type, item, options);
+        }
+        if (Utils_1.Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
+            return em.merge(prop.type, item, options);
+        }
+        if (Utils_1.Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
+            return em.create(prop.type, item, options);
+        }
+        invalid.push(item);
+        return item;
+    }
+}
+exports.EntityAssigner = EntityAssigner;
+exports.assign = EntityAssigner.assign;

package/entity/EntityFactory.d.ts

@@ -0,0 +1,41 @@
+import type { EntityData, EntityMetadata, EntityName, New, Primary } from '../typings';
+import type { EntityManager } from '../EntityManager';
+import type { EntityComparator } from '../utils/EntityComparator';
+export interface FactoryOptions {
+    initialized?: boolean;
+    newEntity?: boolean;
+    merge?: boolean;
+    refresh?: boolean;
+    convertCustomTypes?: boolean;
+    recomputeSnapshot?: boolean;
+    schema?: string;
+}
+export declare class EntityFactory {
+    private readonly em;
+    private readonly driver;
+    private readonly platform;
+    private readonly config;
+    private readonly metadata;
+    private readonly hydrator;
+    private readonly eventManager;
+    private readonly comparator;
+    constructor(em: EntityManager);
+    create<T extends object, P extends string = string>(entityName: EntityName<T>, data: EntityData<T>, options?: FactoryOptions): New<T, P>;
+    mergeData<T extends object>(meta: EntityMetadata<T>, entity: T, data: EntityData<T>, options?: FactoryOptions): void;
+    createReference<T extends object>(entityName: EntityName<T>, id: Primary<T> | Primary<T>[] | Record<string, Primary<T>>, options?: Pick<FactoryOptions, 'merge' | 'convertCustomTypes' | 'schema'>): T;
+    createEmbeddable<T extends object>(entityName: EntityName<T>, data: EntityData<T>, options?: Pick<FactoryOptions, 'newEntity' | 'convertCustomTypes'>): T;
+    getComparator(): EntityComparator;
+    private createEntity;
+    private hydrate;
+    private findEntity;
+    private processDiscriminatorColumn;
+    /**
+     * denormalize PK to value required by driver (e.g. ObjectId)
+     */
+    private denormalizePrimaryKey;
+    /**
+     * returns parameters for entity constructor, creating references from plain ids
+     */
+    private extractConstructorParams;
+    private get unitOfWork();
+}