@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.11

package/entity/ArrayCollection.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayCollection = void 0;
-const node_util_1 = require("node:util");
-const Reference_1 = require("./Reference");
-const wrap_1 = require("./wrap");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
-const Utils_1 = require("../utils/Utils");
-class ArrayCollection {
+import { inspect } from 'node:util';
+import { Reference } from './Reference.js';
+import { helper, wrap } from './wrap.js';
+import { MetadataError, ValidationError } from '../errors.js';
+import { ReferenceKind } from '../enums.js';
+import { Utils } from '../utils/Utils.js';
+export class ArrayCollection {
     owner;
     items = new Set();
     initialized = true;
@@ -17,7 +14,7 @@ class ArrayCollection {
     _property;
     constructor(owner, items) {
         this.owner = owner;
-        /* istanbul ignore next */
+        /* v8 ignore next 5 */
         if (items) {
             let i = 0;
             this.items = new Set(items);
@@ -36,28 +33,35 @@ class ArrayCollection {
         }
         const meta = this.property.targetMeta;
         const args = meta.toJsonParams.map(() => undefined);
-        return this.map(item => (0, wrap_1.wrap)(item).toJSON(...args));
+        return this.map(item => wrap(item).toJSON(...args));
     }
     toJSON() {
         return this.toArray();
     }
     getIdentifiers(field) {
         const items = this.getItems();
+        const targetMeta = this.property.targetMeta;
         if (items.length === 0) {
             return [];
         }
-        field ??= this.property.targetMeta.serializedPrimaryKey;
+        field ??= targetMeta.compositePK ? targetMeta.primaryKeys : targetMeta.serializedPrimaryKey;
+        const cb = (i, f) => {
+            if (Utils.isEntity(i[f], true)) {
+                return wrap(i[f], true).getPrimaryKey();
+            }
+            return i[f];
+        };
         return items.map(i => {
-            if (Utils_1.Utils.isEntity(i[field], true)) {
-                return (0, wrap_1.wrap)(i[field], true).getPrimaryKey();
+            if (Array.isArray(field)) {
+                return field.map(f => cb(i, f));
             }
-            return i[field];
+            return cb(i, field);
         });
     }
     add(entity, ...entities) {
-        entities = Utils_1.Utils.asArray(entity).concat(entities);
+        entities = Utils.asArray(entity).concat(entities);
         for (const item of entities) {
-            const entity = Reference_1.Reference.unwrapReference(item);
+            const entity = Reference.unwrapReference(item);
             if (!this.contains(entity, false)) {
                 this.incrementCount(1);
                 this[this.items.size] = entity;
@@ -82,7 +86,7 @@ class ArrayCollection {
             this.initialized = true;
             this.snapshot = undefined;
         }
-        if (this.compare(Utils_1.Utils.asArray(items).map(item => Reference_1.Reference.unwrapReference(item)))) {
+        if (this.compare(Utils.asArray(items).map(item => Reference.unwrapReference(item)))) {
             return;
         }
         this.remove(this.items);
@@ -120,13 +124,13 @@ class ArrayCollection {
      * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
      */
     remove(entity, ...entities) {
-        entities = Utils_1.Utils.asArray(entity).concat(entities);
+        entities = Utils.asArray(entity).concat(entities);
         let modified = false;
         for (const item of entities) {
             if (!item) {
                 continue;
             }
-            const entity = Reference_1.Reference.unwrapReference(item);
+            const entity = Reference.unwrapReference(item);
             if (this.items.delete(entity)) {
                 this.incrementCount(-1);
                 delete this[this.items.size]; // remove last item
@@ -164,7 +168,7 @@ class ArrayCollection {
         this.dirty = true;
     }
     contains(item, check) {
-        const entity = Reference_1.Reference.unwrapReference(item);
+        const entity = Reference.unwrapReference(item);
         return this.items.has(entity);
     }
     /**
@@ -261,7 +265,7 @@ class ArrayCollection {
             return this.initialized;
         }
         for (const item of this.items) {
-            if (!(0, wrap_1.helper)(item).__initialized) {
+            if (!helper(item).__initialized) {
                 return false;
             }
         }
@@ -307,10 +311,10 @@ class ArrayCollection {
      */
     get property() {
         if (!this._property) {
-            const meta = (0, wrap_1.wrap)(this.owner, true).__meta;
-            /* istanbul ignore if */
+            const meta = wrap(this.owner, true).__meta;
+            /* v8 ignore next 3 */
             if (!meta) {
-                throw errors_1.MetadataError.fromUnknownEntity(this.owner.constructor.name, 'Collection.property getter, maybe you just forgot to initialize the ORM?');
+                throw MetadataError.fromUnknownEntity(this.owner.constructor.name, 'Collection.property getter, maybe you just forgot to initialize the ORM?');
             }
             this._property = meta.relations.find(prop => this.owner[prop.name] === this);
         }
@@ -340,27 +344,27 @@ class ArrayCollection {
     propagateToOwningSide(item, method) {
         const mappedBy = this.property.mappedBy;
         const collection = item[mappedBy];
-        if (this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+        if (this.property.kind === ReferenceKind.MANY_TO_MANY) {
             if (this.shouldPropagateToCollection(collection, method)) {
                 collection[method](this.owner);
             }
         }
-        else if (this.property.kind === enums_1.ReferenceKind.ONE_TO_MANY && method !== 'takeSnapshot') {
+        else if (this.property.kind === ReferenceKind.ONE_TO_MANY && method !== 'takeSnapshot') {
             const prop2 = this.property.targetMeta.properties[mappedBy];
-            const owner = prop2.mapToPk ? (0, wrap_1.helper)(this.owner).getPrimaryKey() : this.owner;
+            const owner = prop2.mapToPk ? helper(this.owner).getPrimaryKey() : this.owner;
             const value = method === 'add' ? owner : null;
             if (this.property.orphanRemoval && method === 'remove') {
                 // cache the PK before we propagate, as its value might be needed when flushing
-                (0, wrap_1.helper)(item).__pk = (0, wrap_1.helper)(item).getPrimaryKey();
+                helper(item).__pk = helper(item).getPrimaryKey();
             }
             if (!prop2.nullable && prop2.deleteRule !== 'cascade' && method === 'remove') {
                 if (!this.property.orphanRemoval) {
-                    throw errors_1.ValidationError.cannotRemoveFromCollectionWithoutOrphanRemoval(this.owner, this.property);
+                    throw ValidationError.cannotRemoveFromCollectionWithoutOrphanRemoval(this.owner, this.property);
                 }
                 return;
             }
             // skip if already propagated
-            if (Reference_1.Reference.unwrapReference(item[mappedBy]) !== value) {
+            if (Reference.unwrapReference(item[mappedBy]) !== value) {
                 item[mappedBy] = value;
             }
         }
@@ -384,16 +388,15 @@ class ArrayCollection {
         }
     }
     /** @ignore */
-    [node_util_1.inspect.custom](depth = 2) {
+    [inspect.custom](depth = 2) {
         const object = { ...this };
         const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly'];
         hidden.forEach(k => delete object[k]);
-        const ret = (0, node_util_1.inspect)(object, { depth });
+        const ret = inspect(object, { depth });
         const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }
 }
-exports.ArrayCollection = ArrayCollection;
 Object.defineProperties(ArrayCollection.prototype, {
     __collection: { value: true, enumerable: false, writable: false },
 });

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;
@@ -12,7 +12,6 @@ export interface MatchingOptions<T extends object, P extends string = never> ext
 export declare class Collection<T extends object, O extends object = object> extends ArrayCollection<T, O> {
     private readonly?;
     private _populated?;
-    private _em?;
     private _snapshot?;
     constructor(owner: O, items?: T[], initialized?: boolean);
     /**

package/entity/Collection.js

@@ -1,16 +1,12 @@
-"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;
     // 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) {
@@ -22,7 +18,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 +41,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 +61,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 +80,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 +112,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 +130,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,11 +217,15 @@ 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;
+            const orderBy = this.createOrderBy(options.orderBy);
+            const customOrder = orderBy.length > 0;
             // eslint-disable-next-line dot-notation
-            const items = await em['colLoader'].load([this, options]);
+            const items = await em['colLoader'].load([
+                this,
+                { ...options, orderBy },
+            ]);
             if (!customOrder) {
                 this.reorderItems(items, order);
             }
@@ -243,7 +243,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,27 +256,24 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         return this;
     }
     getEntityManager(items = [], required = true) {
-        const wrapped = (0, wrap_1.helper)(this.owner);
-        let em = (this._em ?? wrapped.__em);
+        const wrapped = helper(this.owner);
+        let 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;
                 }
             }
         }
-        if (em) {
-            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;