@mikro-orm/core 7.0.0-dev.0 → 7.0.0-dev.2

package/entity/BaseEntity.d.ts

@@ -1,9 +1,9 @@
-import { type Ref } from './Reference';
-import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } from '../typings';
-import { type AssignOptions } from './EntityAssigner';
-import type { EntityLoaderOptions } from './EntityLoader';
-import { type SerializeOptions } from '../serialization/EntitySerializer';
-import type { FindOneOptions } from '../drivers/IDatabaseDriver';
+import { type Ref } from './Reference.js';
+import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import { type AssignOptions } from './EntityAssigner.js';
+import type { EntityLoaderOptions } from './EntityLoader.js';
+import { type SerializeOptions } from '../serialization/EntitySerializer.js';
+import type { FindOneOptions } from '../drivers/IDatabaseDriver.js';
 export declare abstract class BaseEntity {
     isInitialized(): boolean;
     isTouched(): boolean;

package/entity/BaseEntity.js

@@ -1,47 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntity = void 0;
-const Reference_1 = require("./Reference");
-const EntityAssigner_1 = require("./EntityAssigner");
-const EntitySerializer_1 = require("../serialization/EntitySerializer");
-const wrap_1 = require("./wrap");
-class BaseEntity {
+import { Reference } from './Reference.js';
+import { EntityAssigner } from './EntityAssigner.js';
+import { EntitySerializer } from '../serialization/EntitySerializer.js';
+import { helper } from './wrap.js';
+export class BaseEntity {
     isInitialized() {
-        return (0, wrap_1.helper)(this).__initialized;
+        return helper(this).__initialized;
     }
     isTouched() {
-        return (0, wrap_1.helper)(this).__touched;
+        return helper(this).__touched;
     }
     populated(populated = true) {
-        (0, wrap_1.helper)(this).populated(populated);
+        helper(this).populated(populated);
     }
     async populate(populate, options = {}) {
-        return (0, wrap_1.helper)(this).populate(populate, options);
+        return helper(this).populate(populate, options);
     }
     toReference() {
-        return Reference_1.Reference.create(this);
+        return Reference.create(this);
     }
     toObject(ignoreFields) {
-        return (0, wrap_1.helper)(this).toObject(ignoreFields);
+        return helper(this).toObject(ignoreFields);
     }
     toPOJO() {
-        return (0, wrap_1.helper)(this).toPOJO();
+        return helper(this).toPOJO();
     }
     serialize(options) {
-        return EntitySerializer_1.EntitySerializer.serialize(this, options);
+        return EntitySerializer.serialize(this, options);
     }
     assign(data, options = {}) {
-        return EntityAssigner_1.EntityAssigner.assign(this, data, options);
+        return EntityAssigner.assign(this, data, options);
     }
     init(options) {
-        return (0, wrap_1.helper)(this).init(options);
+        return helper(this).init(options);
     }
     getSchema() {
-        return (0, wrap_1.helper)(this).getSchema();
+        return helper(this).getSchema();
     }
     setSchema(schema) {
-        (0, wrap_1.helper)(this).setSchema(schema);
+        helper(this).setSchema(schema);
     }
 }
-exports.BaseEntity = BaseEntity;
 Object.defineProperty(BaseEntity.prototype, '__baseEntity', { value: true, writable: false, enumerable: false });

package/entity/Collection.d.ts

@@ -1,9 +1,9 @@
-import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Populate } from '../typings';
-import { ArrayCollection } from './ArrayCollection';
-import { Reference } from './Reference';
-import type { Transaction } from '../connections/Connection';
-import type { FindOptions, CountOptions } from '../drivers/IDatabaseDriver';
-import type { EntityLoaderOptions } from './EntityLoader';
+import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Populate } from '../typings.js';
+import { ArrayCollection } from './ArrayCollection.js';
+import { Reference } from './Reference.js';
+import type { Transaction } from '../connections/Connection.js';
+import type { FindOptions, CountOptions } from '../drivers/IDatabaseDriver.js';
+import type { EntityLoaderOptions } from './EntityLoader.js';
 export interface MatchingOptions<T extends object, P extends string = never> extends FindOptions<T, P> {
     where?: FilterQuery<T>;
     store?: boolean;

package/entity/Collection.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Collection = void 0;
-const ArrayCollection_1 = require("./ArrayCollection");
-const Utils_1 = require("../utils/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 {
+import { ArrayCollection } from './ArrayCollection.js';
+import { Utils } from '../utils/Utils.js';
+import { ValidationError } from '../errors.js';
+import { ReferenceKind, DataloaderType } from '../enums.js';
+import { Reference } from './Reference.js';
+import { helper } from './wrap.js';
+export class Collection extends ArrayCollection {
     readonly;
     _populated;
     _em;
@@ -22,7 +19,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
      */
     static create(owner, prop, items, initialized) {
         const coll = new Collection(owner, undefined, initialized);
-        coll.property = (0, wrap_1.helper)(owner).__meta.properties[prop];
+        coll.property = helper(owner).__meta.properties[prop];
         owner[prop] = coll;
         if (items) {
             coll.set(items);
@@ -45,7 +42,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         return this;
     }
     setSerializationContext(options) {
-        (0, wrap_1.helper)(this.owner).setSerializationContext({
+        helper(this.owner).setSerializationContext({
             populate: Array.isArray(options.populate)
                 ? options.populate.map(hint => `${this.property.name}.${hint}`)
                 : options.populate ?? [this.property.name],
@@ -65,11 +62,11 @@ class Collection extends ArrayCollection_1.ArrayCollection {
     async loadCount(options = {}) {
         options = typeof options === 'boolean' ? { refresh: options } : options;
         const { refresh, where, ...countOptions } = options;
-        if (!refresh && !where && Utils_1.Utils.isDefined(this._count)) {
+        if (!refresh && !where && 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) {
+        if (!em.getPlatform().usesPivotTable() && this.property.kind === ReferenceKind.MANY_TO_MANY && this.property.owner) {
             return this._count = this.length;
         }
         const cond = this.createLoadCountCondition(where ?? {});
@@ -84,10 +81,10 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         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()) {
+        if (this.property.kind === 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 }));
+            const map = await em.getDriver().loadFromPivotTable(this.property, [helper(this.owner).__primaryKeys], cond, opts.orderBy, ctx, options);
+            items = map[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);
@@ -116,8 +113,8 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         return super.toJSON();
     }
     add(entity, ...entities) {
-        entities = Utils_1.Utils.asArray(entity).concat(entities);
-        const unwrapped = entities.map(i => Reference_1.Reference.unwrapReference(i));
+        entities = Utils.asArray(entity).concat(entities);
+        const unwrapped = entities.map(i => Reference.unwrapReference(i));
         unwrapped.forEach(entity => this.validateItemType(entity));
         this.modify('add', unwrapped);
         this.cancelOrphanRemoval(unwrapped);
@@ -134,8 +131,8 @@ class Collection extends ArrayCollection_1.ArrayCollection {
             }
             return;
         }
-        entities = Utils_1.Utils.asArray(entity).concat(entities);
-        const unwrapped = entities.map(i => Reference_1.Reference.unwrapReference(i));
+        entities = Utils.asArray(entity).concat(entities);
+        const unwrapped = entities.map(i => Reference.unwrapReference(i));
         this.modify('remove', unwrapped);
         const em = this.getEntityManager(unwrapped, false);
         if (this.property.orphanRemoval && em) {
@@ -221,7 +218,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
             return this;
         }
         const em = this.getEntityManager();
-        if (options.dataloader ?? [enums_1.DataloaderType.ALL, enums_1.DataloaderType.COLLECTION].includes(em.config.getDataloaderType())) {
+        if (options.dataloader ?? [DataloaderType.ALL, DataloaderType.COLLECTION].includes(em.config.getDataloaderType())) {
             const order = [...this.items]; // copy order of references
             const customOrder = !!options.orderBy;
             // eslint-disable-next-line dot-notation
@@ -243,7 +240,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
             ? 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
+            ? helper(this.owner).__schema
             : undefined;
         await em.populate(this.owner, populate, {
             refresh: true,
@@ -256,12 +253,12 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         return this;
     }
     getEntityManager(items = [], required = true) {
-        const wrapped = (0, wrap_1.helper)(this.owner);
+        const wrapped = helper(this.owner);
         let em = (this._em ?? wrapped.__em);
         if (!em) {
             for (const i of items) {
-                if (i && (0, wrap_1.helper)(i).__em) {
-                    em = (0, wrap_1.helper)(i).__em;
+                if (i && helper(i).__em) {
+                    em = helper(i).__em;
                     break;
                 }
             }
@@ -270,13 +267,13 @@ class Collection extends ArrayCollection_1.ArrayCollection {
             Object.defineProperty(this, '_em', { value: em });
         }
         if (!em && required) {
-            throw errors_1.ValidationError.entityNotManaged(this.owner);
+            throw 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();
+        if (this.property.kind === ReferenceKind.ONE_TO_MANY) {
+            cond[this.property.mappedBy] = helper(this.owner).getPrimaryKey();
         }
         else { // MANY_TO_MANY
             this.createManyToManyCondition(cond);
@@ -284,10 +281,10 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         return cond;
     }
     createOrderBy(orderBy = []) {
-        if (Utils_1.Utils.isEmpty(orderBy) && this.property.orderBy) {
+        if (Utils.isEmpty(orderBy) && this.property.orderBy) {
             orderBy = this.property.orderBy;
         }
-        return Utils_1.Utils.asArray(orderBy);
+        return Utils.asArray(orderBy);
     }
     createManyToManyCondition(cond) {
         const dict = cond;
@@ -295,17 +292,17 @@ class Collection extends ArrayCollection_1.ArrayCollection {
             // 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()));
+            this.items.forEach(item => dict[pk].$in.push(helper(item).getPrimaryKey()));
         }
         else {
-            dict[this.property.mappedBy] = (0, wrap_1.helper)(this.owner).getPrimaryKey();
+            dict[this.property.mappedBy] = helper(this.owner).getPrimaryKey();
         }
     }
     createLoadCountCondition(cond) {
-        const wrapped = (0, wrap_1.helper)(this.owner);
+        const wrapped = 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) {
+        if (this.property.kind === ReferenceKind.ONE_TO_MANY) {
             dict[this.property.mappedBy] = val;
         }
         else {
@@ -324,14 +321,14 @@ class Collection extends ArrayCollection_1.ArrayCollection {
     }
     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`);
+            throw new Error(`Collection<${this.property.type}> of entity ${this.owner.constructor.name}[${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) {
+        if (this.property.kind === ReferenceKind.MANY_TO_MANY && this.property.owner) {
             items.sort((a, b) => order.indexOf(a) - order.indexOf(b));
         }
     }
@@ -345,31 +342,30 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         }
     }
     validateItemType(item) {
-        if (!Utils_1.Utils.isEntity(item)) {
-            throw errors_1.ValidationError.notEntity(this.owner, this.property, item);
+        if (!Utils.isEntity(item)) {
+            throw ValidationError.notEntity(this.owner, this.property, item);
         }
     }
     validateModification(items) {
         if (this.readonly) {
-            throw errors_1.ValidationError.cannotModifyReadonlyCollection(this.owner, this.property);
+            throw 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) {
+            if (!item || helper(item).__initialized) {
                 return false;
             }
-            return !item[this.property.mappedBy] && this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY;
+            return !item[this.property.mappedBy] && this.property.kind === 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);
+            throw 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

@@ -1,5 +1,5 @@
-import type { EntityManager } from '../EntityManager';
-import type { EntityData, EntityDTO, EntityProperty, FromEntityType, IsSubset, MergeSelected } from '../typings';
+import type { EntityManager } from '../EntityManager.js';
+import type { EntityData, EntityDTO, EntityProperty, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
 export declare class EntityAssigner {
     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;

package/entity/EntityAssigner.js

@@ -1,25 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assign = exports.EntityAssigner = void 0;
-const node_util_1 = require("node: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 {
+import { inspect } from 'node:util';
+import { Collection } from './Collection.js';
+import { Utils } from '../utils/Utils.js';
+import { Reference } from './Reference.js';
+import { ReferenceKind, SCALAR_TYPES } from '../enums.js';
+import { EntityValidator } from './EntityValidator.js';
+import { helper, wrap } from './wrap.js';
+import { EntityHelper } from './EntityHelper.js';
+const validator = new EntityValidator(false);
+export class EntityAssigner {
     static assign(entity, data, options = {}) {
         let opts = options;
         if (opts.visited?.has(entity)) {
             return entity;
         }
-        EntityHelper_1.EntityHelper.ensurePropagation(entity);
+        EntityHelper.ensurePropagation(entity);
         opts.visited ??= new Set();
         opts.visited.add(entity);
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         opts = {
             ...wrapped.__config.get('assign'),
             schema: wrapped.__schema,
@@ -45,37 +42,37 @@ class EntityAssigner {
         }
         const prop = { ...props[propName], name: propName };
         if (prop && options.onlyOwnProperties) {
-            if ([enums_1.ReferenceKind.MANY_TO_MANY, enums_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 return;
             }
-            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-                value = Utils_1.Utils.extractPK(value, 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 ([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 ([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_1.Utils.isCollection(entity[prop.name])) {
+        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 === enums_1.ReferenceKind.SCALAR && !Utils_1.Utils.isEntity(data)) {
+        if (options.convertCustomTypes && customType && prop.kind === ReferenceKind.SCALAR && !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) {
-            if (options.updateNestedEntities && Object.hasOwn(entity, 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 ([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_1.Utils.extractPK(value, prop.targetMeta);
+                    const pk = 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 wrappedChild = helper(ref);
                         const sameTarget = wrappedChild.getSerializedPrimaryKey() === wrapped.getSerializedPrimaryKey();
                         if (wrappedChild.__managed && wrappedChild.isInitialized() && sameTarget) {
                             return EntityAssigner.assign(ref, value, options);
@@ -83,21 +80,21 @@ class EntityAssigner {
                     }
                     return EntityAssigner.assignReference(entity, value, prop, options.em, options);
                 }
-                if (wrapped.__managed && (0, wrap_1.wrap)(unwrappedEntity).isInitialized()) {
+                if (wrapped.__managed && 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)) {
+        if (prop.kind === ReferenceKind.SCALAR && 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)) {
+        if (prop.kind === 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)) {
+        if (options.mergeObjectProperties && Utils.isPlainObject(entity[propName]) && Utils.isPlainObject(value)) {
             entity[propName] ??= {};
-            entity[propName] = Utils_1.Utils.merge({}, entity[propName], value);
+            entity[propName] = Utils.merge({}, entity[propName], value);
         }
         else if (!prop || prop.setter || !prop.getter) {
             entity[propName] = value;
@@ -110,18 +107,18 @@ class EntityAssigner {
      */
     static autoWireOneToOne(prop, entity) {
         const ref = entity[prop.name];
-        if (prop.kind !== enums_1.ReferenceKind.ONE_TO_ONE || !Utils_1.Utils.isEntity(ref)) {
+        if (prop.kind !== ReferenceKind.ONE_TO_ONE || !Utils.isEntity(ref)) {
             return;
         }
-        const meta2 = (0, wrap_1.helper)(ref).__meta;
+        const meta2 = helper(ref).__meta;
         const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
-        /* istanbul ignore next */
+        /* v8 ignore next 7 */
         if (prop2 && !ref[prop2.name]) {
-            if (Reference_1.Reference.isReference(ref)) {
-                ref.unwrap()[prop2.name] = Reference_1.Reference.wrapReference(entity, prop2);
+            if (Reference.isReference(ref)) {
+                ref.unwrap()[prop2.name] = Reference.wrapReference(entity, prop2);
             }
             else {
-                ref[prop2.name] = Reference_1.Reference.wrapReference(entity, prop2);
+                ref[prop2.name] = Reference.wrapReference(entity, prop2);
             }
         }
     }
@@ -132,17 +129,17 @@ class EntityAssigner {
         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);
+        if (Utils.isEntity(value, true)) {
+            entity[prop.name] = 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.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = prop.mapToPk ? value : 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.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = 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 if (Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference.wrapReference(em.create(prop.type, value, options), prop);
         }
         else {
             const name = entity.constructor.name;
@@ -152,32 +149,31 @@ class EntityAssigner {
     }
     static assignCollection(entity, collection, value, prop, em, options) {
         const invalid = [];
-        const items = Utils_1.Utils.asArray(value).map((item, idx) => {
+        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_1.Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
-                item = { ...item, [prop2.name]: Reference_1.Reference.wrapReference(entity, prop2) };
+            if (Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
+                item = { ...item, [prop2.name]: Reference.wrapReference(entity, prop2) };
             }
-            if (options.updateNestedEntities && options.updateByPrimaryKey && Utils_1.Utils.isPlainObject(item)) {
-                const pk = Utils_1.Utils.extractPK(item, prop.targetMeta);
+            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.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()) {
+            /* v8 ignore next 3 */
+            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 new Error(`Invalid collection values provided for '${name}.${prop.name}' in ${name}.assign(): ${(0, node_util_1.inspect)(invalid)}`);
+            throw new Error(`Invalid collection values provided for '${name}.${prop.name}' in ${name}.assign(): ${inspect(invalid)}`);
         }
         if (Array.isArray(value)) {
             collection.set(items);
@@ -197,7 +193,7 @@ class EntityAssigner {
             entity[propName] = [];
         }
         if (prop.array) {
-            return Utils_1.Utils.asArray(value).forEach(item => {
+            return Utils.asArray(value).forEach(item => {
                 const tmp = {};
                 this.assignEmbeddable(tmp, item, { ...prop, array: false }, em, options);
                 entity[propName].push(...Object.values(tmp));
@@ -213,21 +209,20 @@ class EntityAssigner {
         });
     }
     static createCollectionItem(item, em, prop, invalid, options) {
-        if (Utils_1.Utils.isEntity(item)) {
+        if (Utils.isEntity(item)) {
             return item;
         }
-        if (Utils_1.Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
+        if (Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
             return em.getReference(prop.type, item, options);
         }
-        if (Utils_1.Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
+        if (Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
             return em.merge(prop.type, item, options);
         }
-        if (Utils_1.Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
+        if (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;
+export const assign = EntityAssigner.assign;

package/entity/EntityFactory.d.ts

@@ -1,6 +1,6 @@
-import type { EntityData, EntityMetadata, EntityName, New, Primary } from '../typings';
-import type { EntityManager } from '../EntityManager';
-import type { EntityComparator } from '../utils/EntityComparator';
+import type { EntityData, EntityMetadata, EntityName, New, Primary } from '../typings.js';
+import type { EntityManager } from '../EntityManager.js';
+import type { EntityComparator } from '../utils/EntityComparator.js';
 export interface FactoryOptions {
     initialized?: boolean;
     newEntity?: boolean;