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

package/entity/Collection.js

@@ -1,20 +1,29 @@
-"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 { Utils } from '../utils/Utils.js';
+import { MetadataError, ValidationError } from '../errors.js';
+import { DataloaderType, ReferenceKind } from '../enums.js';
+import { Reference } from './Reference.js';
+import { helper, wrap } from './wrap.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
+import { inspect } from '../logging/inspect.js';
+export class Collection {
+    owner;
+    items = new Set();
+    initialized = true;
+    dirty = false;
+    partial = false; // mark partially loaded collections, propagation is disabled for those
+    snapshot = []; // used to create a diff of the collection at commit time, undefined marks overridden values so we need to wipe when flushing
     readonly;
+    _count;
+    _property;
     _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.owner = owner;
+        /* v8 ignore next */
+        if (items) {
+            let i = 0;
+            this.items = new Set(items);
+            this.items.forEach(item => this[i++] = item);
+        }
         this.initialized = !!items || initialized;
     }
     /**
@@ -22,7 +31,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);
@@ -36,6 +45,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
     async load(options = {}) {
         if (this.isInitialized(true) && !options.refresh) {
             const em = this.getEntityManager(this.items, false);
+            options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
             await em?.populate(this.items, options.populate, options);
             this.setSerializationContext(options);
         }
@@ -45,7 +55,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],
@@ -56,7 +66,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
      */
     async loadItems(options) {
         await this.load(options);
-        return super.getItems();
+        return this.getItems(false);
     }
     /**
      * Gets the count of collection items from database instead of counting loaded items.
@@ -65,11 +75,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 && this._count != null) {
             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 +94,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);
@@ -107,98 +117,97 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         if (check) {
             this.checkInitialized();
         }
-        return super.getItems();
+        return [...this.items];
     }
     toJSON() {
         if (!this.isInitialized()) {
             return [];
         }
-        return super.toJSON();
+        return this.toArray();
     }
     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);
+        entities = Utils.asArray(entity).concat(entities);
+        const unwrapped = entities.map(i => Reference.unwrapReference(i));
+        this.validateModification(unwrapped);
+        const em = this.getEntityManager(entities, false);
+        let added = 0;
+        for (const item of entities) {
+            const entity = Reference.unwrapReference(item);
+            if (!this.contains(entity, false)) {
+                this.incrementCount(1);
+                this[this.items.size] = entity;
+                this.items.add(entity);
+                added++;
+                this.dirty = true;
+                this.propagate(entity, 'add');
+            }
+        }
+        if (this.property.kind === ReferenceKind.ONE_TO_MANY && em) {
+            em.persist(entities);
+        }
         this.cancelOrphanRemoval(unwrapped);
+        return added;
     }
     /**
-     * @inheritDoc
+     * Remove specified item(s) from the collection. Note that removing item from collection does not necessarily imply deleting the target entity,
+     * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
+     * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
+     * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
      */
     remove(entity, ...entities) {
         if (entity instanceof Function) {
+            let removed = 0;
             for (const item of this.items) {
                 if (entity(item)) {
-                    this.remove(item);
+                    removed += this.remove(item);
                 }
             }
-            return;
+            return removed;
         }
-        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);
+        this.checkInitialized();
+        entities = Utils.asArray(entity).concat(entities);
+        const unwrapped = entities.map(i => Reference.unwrapReference(i));
+        this.validateModification(unwrapped);
+        const em = this.getEntityManager(entities, false);
+        let removed = 0;
+        for (const item of entities) {
+            if (!item) {
+                continue;
+            }
+            const entity = Reference.unwrapReference(item);
+            if (this.items.delete(entity)) {
+                this.incrementCount(-1);
+                delete this[this.items.size]; // remove last item
+                this.propagate(entity, 'remove');
+                removed++;
+                this.dirty = true;
             }
+            if (this.property.orphanRemoval && em) {
+                em.getUnitOfWork().scheduleOrphanRemoval(entity);
+            }
+        }
+        if (this.property.kind === ReferenceKind.ONE_TO_MANY && !this.property.orphanRemoval && em) {
+            em.persist(entities);
+        }
+        if (removed > 0) {
+            Object.assign(this, [...this.items]); // reassign array access
         }
+        return removed;
     }
     contains(item, check = true) {
         if (check) {
             this.checkInitialized();
         }
-        return super.contains(item);
+        const entity = Reference.unwrapReference(item);
+        return this.items.has(entity);
     }
     count() {
         this.checkInitialized();
-        return super.count();
+        return this.items.size;
     }
     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);
+        return this.count() === 0;
     }
     shouldPopulate(populated) {
         if (!this.isInitialized(true)) {
@@ -221,13 +230,21 @@ 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())) {
+        options = { ...options, filters: QueryHelper.mergePropertyFilters(this.property.filters, options.filters) };
+        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
-            const items = await em['colLoader'].load([this, options]);
-            if (!customOrder) {
-                this.reorderItems(items, order);
+            const orderBy = this.createOrderBy(options.orderBy);
+            const customOrder = orderBy.length > 0;
+            const pivotTable = this.property.kind === ReferenceKind.MANY_TO_MANY && em.getPlatform().usesPivotTable();
+            const loader = await em.getDataLoader(pivotTable ? 'm:n' : '1:m');
+            const items = await loader.load([this, { ...options, orderBy }]);
+            if (this.property.kind === ReferenceKind.MANY_TO_MANY) {
+                this.initialized = true;
+                this.dirty = false;
+                if (!customOrder) {
+                    this.reorderItems(items, order);
+                }
+                return this;
             }
             this.items.clear();
             let i = 0;
@@ -243,7 +260,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 +273,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 +298,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 +309,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 {
@@ -314,24 +328,16 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         }
         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`);
+            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));
         }
     }
@@ -344,33 +350,362 @@ class Collection extends ArrayCollection_1.ArrayCollection {
             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;
+            throw ValidationError.cannotModifyReadonlyCollection(this.owner, this.property);
         }
         const check = (item) => {
-            if (!item || (0, wrap_1.helper)(item).__initialized) {
+            if (!item) {
+                return false;
+            }
+            if (!Utils.isEntity(item)) {
+                throw ValidationError.notEntity(this.owner, this.property, item);
+            }
+            // currently we allow persisting to inverse sides only in SQL drivers
+            if (this.property.pivotTable || !this.property.mappedBy) {
                 return false;
             }
-            return !item[this.property.mappedBy] && this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY;
+            if (helper(item).__initialized) {
+                return false;
+            }
+            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);
+        if (items.some(item => check(item))) {
+            throw ValidationError.cannotModifyInverseCollection(this.owner, this.property);
+        }
+    }
+    toArray() {
+        if (this.items.size === 0) {
+            return [];
+        }
+        return this.map(item => wrap(item).toJSON());
+    }
+    getIdentifiers(field) {
+        const items = this.getItems();
+        const targetMeta = this.property.targetMeta;
+        if (items.length === 0) {
+            return [];
+        }
+        field ??= targetMeta.compositePK ? targetMeta.primaryKeys : (targetMeta.serializedPrimaryKey ?? targetMeta.primaryKeys[0]);
+        const cb = (i, f) => {
+            if (Utils.isEntity(i[f], true)) {
+                return wrap(i[f], true).getPrimaryKey();
+            }
+            return i[f];
+        };
+        return items.map(i => {
+            if (Array.isArray(field)) {
+                return field.map(f => cb(i, f));
+            }
+            return cb(i, field);
+        });
+    }
+    /**
+     * @internal
+     */
+    addWithoutPropagation(entity) {
+        if (!this.contains(entity, false)) {
+            this.incrementCount(1);
+            this[this.items.size] = entity;
+            this.items.add(entity);
+            this.dirty = true;
+        }
+    }
+    set(items) {
+        if (!this.initialized) {
+            this.initialized = true;
+            this.snapshot = undefined;
+        }
+        if (this.compare(Utils.asArray(items).map(item => Reference.unwrapReference(item)))) {
+            return;
+        }
+        this.remove(this.items);
+        this.add(items);
+    }
+    compare(items) {
+        if (items.length !== this.items.size) {
+            return false;
+        }
+        let idx = 0;
+        for (const item of this.items) {
+            if (item !== items[idx++]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * @internal
+     */
+    hydrate(items, forcePropagate, partial) {
+        for (let i = 0; i < this.items.size; i++) {
+            delete this[i];
+        }
+        this.initialized = true;
+        this.partial = !!partial;
+        this.items.clear();
+        this._count = 0;
+        this.add(items);
+        this.takeSnapshot(forcePropagate);
+    }
+    /**
+     * Remove all items from the collection. Note that removing items from collection does not necessarily imply deleting the target entity,
+     * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
+     * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
+     * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
+     */
+    removeAll() {
+        if (!this.initialized) {
+            this.initialized = true;
+            this.snapshot = undefined;
+        }
+        this.remove(this.items);
+        this.dirty = true;
+    }
+    /**
+     * @internal
+     */
+    removeWithoutPropagation(entity) {
+        if (!this.items.delete(entity)) {
+            return;
+        }
+        this.incrementCount(-1);
+        delete this[this.items.size];
+        Object.assign(this, [...this.items]);
+        this.dirty = true;
+    }
+    /**
+     * Extracts a slice of the collection items starting at position start to end (exclusive) of the collection.
+     * If end is null it returns all elements from start to the end of the collection.
+     */
+    slice(start = 0, end) {
+        this.checkInitialized();
+        let index = 0;
+        end ??= this.items.size;
+        const items = [];
+        for (const item of this.items) {
+            if (index === end) {
+                break;
+            }
+            if (index >= start && index < end) {
+                items.push(item);
+            }
+            index++;
+        }
+        return items;
+    }
+    /**
+     * Tests for the existence of an element that satisfies the given predicate.
+     */
+    exists(cb) {
+        this.checkInitialized();
+        for (const item of this.items) {
+            if (cb(item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Returns the first element of this collection that satisfies the predicate.
+     */
+    find(cb) {
+        this.checkInitialized();
+        let index = 0;
+        for (const item of this.items) {
+            if (cb(item, index++)) {
+                return item;
+            }
         }
+        return undefined;
+    }
+    /**
+     * Extracts a subset of the collection items.
+     */
+    filter(cb) {
+        this.checkInitialized();
+        const items = [];
+        let index = 0;
+        for (const item of this.items) {
+            if (cb(item, index++)) {
+                items.push(item);
+            }
+        }
+        return items;
+    }
+    /**
+     * Maps the collection items based on your provided mapper function.
+     */
+    map(mapper) {
+        this.checkInitialized();
+        const items = [];
+        let index = 0;
+        for (const item of this.items) {
+            items.push(mapper(item, index++));
+        }
+        return items;
+    }
+    /**
+     * Maps the collection items based on your provided mapper function to a single object.
+     */
+    reduce(cb, initial = {}) {
+        this.checkInitialized();
+        let index = 0;
+        for (const item of this.items) {
+            initial = cb(initial, item, index++);
+        }
+        return initial;
+    }
+    /**
+     * Maps the collection items to a dictionary, indexed by the key you specify.
+     * If there are more items with the same key, only the first one will be present.
+     */
+    indexBy(key, valueKey) {
+        return this.reduce((obj, item) => {
+            obj[item[key]] ??= valueKey ? item[valueKey] : item;
+            return obj;
+        }, {});
+    }
+    isInitialized(fully = false) {
+        if (!this.initialized || !fully) {
+            return this.initialized;
+        }
+        for (const item of this.items) {
+            if (!helper(item).__initialized) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isDirty() {
+        return this.dirty;
+    }
+    isPartial() {
+        return this.partial;
+    }
+    setDirty(dirty = true) {
+        this.dirty = dirty;
+    }
+    get length() {
+        return this.count();
+    }
+    *[Symbol.iterator]() {
+        for (const item of this.getItems()) {
+            yield item;
+        }
+    }
+    /**
+     * @internal
+     */
+    takeSnapshot(forcePropagate) {
+        this.snapshot = [...this.items];
+        this.dirty = false;
+        if (this.property.owner || forcePropagate) {
+            this.items.forEach(item => {
+                this.propagate(item, 'takeSnapshot');
+            });
+        }
+    }
+    /**
+     * @internal
+     */
+    getSnapshot() {
+        return this.snapshot;
+    }
+    /**
+     * @internal
+     */
+    get property() {
+        if (!this._property) {
+            const meta = wrap(this.owner, true).__meta;
+            /* v8 ignore next */
+            if (!meta) {
+                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);
+        }
+        return this._property;
+    }
+    /**
+     * @internal
+     */
+    set property(prop) {
+        this._property = prop;
+    }
+    propagate(item, method) {
+        if (this.property.owner && this.property.inversedBy) {
+            this.propagateToInverseSide(item, method);
+        }
+        else if (!this.property.owner && this.property.mappedBy) {
+            this.propagateToOwningSide(item, method);
+        }
+    }
+    propagateToInverseSide(item, method) {
+        const collection = item[this.property.inversedBy];
+        if (this.shouldPropagateToCollection(collection, method)) {
+            method = method === 'takeSnapshot' ? method : (method + 'WithoutPropagation');
+            collection[method](this.owner);
+        }
+    }
+    propagateToOwningSide(item, method) {
+        const mappedBy = this.property.mappedBy;
+        const collection = item[mappedBy];
+        if (this.property.kind === ReferenceKind.MANY_TO_MANY) {
+            if (this.shouldPropagateToCollection(collection, method)) {
+                collection[method](this.owner);
+            }
+        }
+        else if (this.property.kind === ReferenceKind.ONE_TO_MANY && method !== 'takeSnapshot') {
+            const prop2 = this.property.targetMeta.properties[mappedBy];
+            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
+                helper(item).__pk = helper(item).getPrimaryKey();
+            }
+            if (!prop2.nullable && prop2.deleteRule !== 'cascade' && method === 'remove') {
+                if (!this.property.orphanRemoval) {
+                    throw ValidationError.cannotRemoveFromCollectionWithoutOrphanRemoval(this.owner, this.property);
+                }
+                return;
+            }
+            // skip if already propagated
+            if (Reference.unwrapReference(item[mappedBy]) !== value) {
+                item[mappedBy] = value;
+            }
+        }
+    }
+    shouldPropagateToCollection(collection, method) {
+        if (!collection) {
+            return false;
+        }
+        switch (method) {
+            case 'add':
+                return !collection.contains(this.owner, false);
+            case 'remove':
+                return collection.isInitialized() && collection.contains(this.owner, false);
+            case 'takeSnapshot':
+                return collection.isDirty();
+        }
+    }
+    incrementCount(value) {
+        if (typeof this._count === 'number' && this.initialized) {
+            this._count += value;
+        }
+    }
+    /** @ignore */
+    [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
+        const object = { ...this };
+        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_lazyInitialized', '_em', 'readonly', 'partial'];
+        hidden.forEach(k => delete object[k]);
+        const ret = inspect(object, { depth });
+        const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;
+        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }
 }
-exports.Collection = Collection;
 Object.defineProperties(Collection.prototype, {
     $: { get() { return this; } },
     get: { get() { return () => this; } },
+    __collection: { value: true, enumerable: false, writable: false },
 });