joist-core 2.0.3-next.2 → 2.0.3-next.21

package/build/relations/OneToManyCollection.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OneToManyCollection = void 0;
 exports.hasMany = hasMany;
-const oneToManyDataLoader_1 = require("../dataloaders/oneToManyDataLoader");
+const oneToManyBatchLoader_1 = require("../batchloaders/oneToManyBatchLoader");
 const oneToManyFindDataLoader_1 = require("../dataloaders/oneToManyFindDataLoader");
 const index_1 = require("../index");
 const newEntity_1 = require("../newEntity");
@@ -18,83 +18,76 @@ function hasMany() {
 }
 class OneToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
     #field;
-    // We can track both value-and-isLoaded with a single `#loaded` b/c `[]` is always our empty value
-    #loaded;
+    #state;
+    #loadPromise;
     // Constantly filtering+sorting our `.get` values can be surprisingly expensive if called
     // when processing many entities/writing code that calls it repeatedly, so we cache it
     // both the "without deleted" default (`getSorted`) and "all deleted" (`allSorted`).
     #getSorted;
     #allSorted;
-    // We _used_ to not track `#removed`, because if a child is removed in our unloaded state,
-    // when we load and get back the `child X has parent_id = our id` rows from the db, `loaderForCollection`
-    // groups the hydrated rows by their _current parent m2o field value_, which for a removed child will no
-    // longer be us, so it will effectively not show up in our post-load `loaded` array.
-    // However, now with join preloading, the getPreloadedRelation might still have pre-load removed children.
-    #added;
-    #removed;
-    #hasBeenSet = false;
     constructor(entity, field) {
         super(entity);
         this.#field = field;
         if ((0, index_1.getInstanceData)(entity).isOrWasNew) {
-            this.#loaded = [];
+            this.#state = new O2MLoadedState(this, [], false);
+        }
+        else {
+            const { em } = entity;
+            // If any m2o.set(ourId) were made before our entity was loaded, pull in those changes
+            const pending = (0, index_1.getEmInternalApi)(em).pendingPercolate.get(entity.idTagged)?.get(this.fieldName);
+            if (pending) {
+                this.#state = new O2MUnloadedAddedRemovedState(this, pending.adds, pending.removes);
+                (0, index_1.getEmInternalApi)(em).pendingPercolate.get(entity.idTagged)?.delete(this.fieldName);
+            }
+            else {
+                this.#state = new O2MUnloadedPristineState(this);
+            }
         }
     }
     // opts is an internal parameter
     async load(opts = {}) {
         (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        if (this.#loaded === undefined || (opts.forceReload && !this.entity.isNewEntity)) {
-            // If forceReload=true, the `.load` might return a cached array, which one would think is stale
-            // (i.e. it doesn't have our WIP adds & removes applied to it), _but_ because we've been mutating
-            // our `this.loaded`, really `.load` is a noop, and just gives us back the same list we had before.
-            //
-            // ...although if we'd:
-            // a) created an array in the DL cache
-            // b) em.flushed & reset the dataloaders
-            // c) make WIP changes to our existing array
-            // d) called `forceReload: true`
-            // e) we'll ask the dataloader for a new array, and will be missing our WIP changes
-            const dl = (0, oneToManyDataLoader_1.oneToManyDataLoader)(this.entity.em, this);
-            this.#loaded =
-                this.getPreloaded() ??
-                    (await dl.load(this.entity.idTagged).catch(function load(err) {
-                        throw (0, index_1.appendStack)(err, new Error());
-                    }));
-            // If we're reloading (i.e. `forceReload: true`), then we need to clear our caches
+        if (!this.#state.isLoaded || (opts.forceReload && !this.entity.isNewEntity)) {
+            const maybePreloaded = this.getPreloaded();
+            if (maybePreloaded) {
+                this.#state = this.#state.applyLoad(maybePreloaded);
+            }
+            else {
+                await (this.#loadPromise ??= (0, oneToManyBatchLoader_1.oneToManyBatchLoader)(this.entity.em, this).load(this.entity.idTagged))
+                    .then(() => this.preload())
+                    .catch(function load(err) {
+                    throw (0, index_1.appendStack)(err, new Error());
+                })
+                    .finally(() => {
+                    this.#loadPromise = undefined;
+                });
+            }
             this.#getSorted = undefined;
             this.#allSorted = undefined;
-            this.maybeAppendAddedBeforeLoaded();
         }
         return opts?.withDeleted ? this.getWithDeleted : this.get;
     }
     async find(id) {
         (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        if (this.#loaded !== undefined) {
-            return this.#loaded.find((other) => !other.isNewEntity && other.id === id);
-        }
-        else {
-            const added = this.#added?.find((u) => !u.isNewEntity && u.id === id);
-            if (added)
-                return added;
-            // Make a cacheable tuple to look up this specific o2m row
-            const key = `id=${id},${this.#field.otherColumnName}=${this.entity.id}`;
-            return (0, oneToManyFindDataLoader_1.oneToManyFindDataLoader)(this.entity.em, this)
-                .load(key)
-                .catch(function find(err) {
-                throw (0, index_1.appendStack)(err, new Error());
-            });
-        }
+        const inMemory = this.#state.find(id);
+        if (inMemory)
+            return inMemory;
+        if (this.#state.isLoaded)
+            return undefined;
+        const key = `id=${id},${this.#field.otherColumnName}=${this.entity.id}`;
+        return (0, oneToManyFindDataLoader_1.oneToManyFindDataLoader)(this.entity.em, this)
+            .load(key)
+            .catch(function find(err) {
+            throw (0, index_1.appendStack)(err, new Error());
+        });
     }
     async includes(other) {
         return (0, index_1.sameEntity)(this.entity, this.getOtherRelation(other).current());
     }
     get isLoaded() {
-        return this.#loaded !== undefined;
+        return this.#state.isLoaded;
     }
     resetIsLoaded() {
-        // Invalidate our .get cache on any mutation; in theory we could do this only if this
-        // mutation was from an `other`, i.e. when entities are deleted or something in our
-        // `orderBy` changes (although we some RF `orderBy`s, which might be a pain to track).
         this.#getSorted = undefined;
         this.#allSorted = undefined;
     }
@@ -102,21 +95,16 @@ class OneToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
         return !!this.getPreloaded();
     }
     preload() {
-        this.#loaded = this.getPreloaded();
-        this.maybeAppendAddedBeforeLoaded();
-    }
-    import(other, findEntity) {
-        function map(v) {
-            if (v === undefined)
-                return undefined;
-            const result = new Array(v.length);
-            for (let i = 0; i < v.length; i++)
-                result[i] = findEntity(v[i]);
-            return result;
+        const preloaded = this.getPreloaded();
+        if (preloaded) {
+            this.#state = this.#state.applyLoad(preloaded);
+            this.#getSorted = undefined;
+            this.#allSorted = undefined;
         }
-        this.#loaded = map(other.#loaded);
-        this.#added = map(other.#added);
-        this.#removed = map(other.#removed);
+    }
+    /** Copy another em's `source` collection into our state. */
+    import(source, findEntity) {
+        this.#state = source.#state.import(this, findEntity);
         this.#getSorted = undefined;
         this.#allSorted = undefined;
     }
@@ -125,7 +113,7 @@ class OneToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
         (0, index_1.ensureNotDeleted)(this.entity, "pending");
         if (this.#getSorted !== undefined)
             return this.#getSorted;
-        this.#getSorted = Object.freeze(this.filterDeleted(this.doGet(), { withDeleted: false }));
+        this.#getSorted = Object.freeze(this.filterDeleted(this.#state.doGet(), { withDeleted: false }));
         (0, index_1.getEmInternalApi)(this.entity.em).isLoadedCache.addNaive(this);
         return this.#getSorted;
     }
@@ -133,101 +121,64 @@ class OneToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
         (0, index_1.ensureNotDeleted)(this.entity, "pending");
         if (this.#allSorted !== undefined)
             return this.#allSorted;
-        this.#allSorted = Object.freeze(this.filterDeleted(this.doGet(), { withDeleted: true }));
+        this.#allSorted = Object.freeze(this.filterDeleted(this.#state.doGet(), { withDeleted: true }));
         (0, index_1.getEmInternalApi)(this.entity.em).isLoadedCache.addNaive(this);
         return this.#allSorted;
     }
-    doGet() {
-        // This should only be callable in the type system if we've already resolved this to an instance
-        if (this.#loaded === undefined) {
-            throw new Error("get was called when not loaded");
-        }
-        return this.#loaded;
-    }
     set(values) {
         (0, index_1.ensureNotDeleted)(this.entity);
-        if (this.#loaded === undefined) {
-            throw new Error("set was called when not loaded");
-        }
-        this.#hasBeenSet = true;
-        // If we're changing `a1.books = [b1, b2]` to `a1.books = [b2]`, then implicitly delete the old book
-        const otherCannotChange = this.otherMeta.allFields[this.otherFieldName].immutable;
-        if (this.isCascadeDelete && otherCannotChange) {
-            const implicitlyDeleted = this.#loaded.filter((e) => !values.includes(e));
-            // The `em.delete` will internally invalidate our `#getSorted` / `#allSorted` caches, which will be dirty now
-            implicitlyDeleted.forEach((e) => this.entity.em.delete(e));
-            // Keep the implicitlyDeleted values for `getWithDeleted` to return
-            values = [...values, ...implicitlyDeleted];
-        }
-        // Make a copy for safe iteration
-        const loaded = [...this.#loaded];
-        // Remove old values
-        for (const other of loaded) {
-            if (!values.includes(other)) {
-                this.remove(other);
-            }
-        }
-        for (const other of values) {
-            if (!loaded.includes(other)) {
-                this.add(other);
-            }
-        }
+        this.#state = this.#state.set(values);
+        this.registerAsMutated();
+        this.#getSorted = undefined;
+        this.#allSorted = undefined;
     }
     add(other) {
         (0, index_1.ensureNotDeleted)(this.entity);
-        this.#added ??= [];
-        (0, utils_1.maybeAdd)(this.#added, other);
-        (0, utils_1.maybeRemove)(this.#removed, other);
-        if (this.#loaded !== undefined) {
-            (0, utils_1.maybeAdd)(this.#loaded, other);
-            this.#getSorted = undefined;
-            this.#allSorted = undefined;
-        }
+        this.#state = this.#state.add(other);
+        this.percolateAdd(other);
         this.registerAsMutated();
-        // This will no-op and mark other dirty if necessary
-        this.getOtherRelation(other).set(this.entity);
+        this.#getSorted = undefined;
+        this.#allSorted = undefined;
     }
-    // We're not supported remove(other) because that might leave other.otherFieldName as undefined,
-    // which we don't know if that's valid or not, i.e. depending on whether the field is nullable.
     remove(other, opts = { requireLoaded: true }) {
         (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        if (this.#loaded === undefined && opts.requireLoaded) {
-            throw new Error("remove was called when not loaded");
-        }
-        this.#removed ??= [];
-        (0, utils_1.maybeAdd)(this.#removed, other);
-        (0, utils_1.maybeRemove)(this.#added, other);
-        if (this.#loaded !== undefined) {
-            (0, utils_1.remove)(this.#loaded, other);
-            this.#getSorted = undefined;
-            this.#allSorted = undefined;
-        }
+        this.#state = this.#state.remove(other, opts);
+        this.percolateRemove(other);
         this.registerAsMutated();
-        // This will no-op and mark other dirty if necessary
-        this.getOtherRelation(other).set(undefined);
+        this.#getSorted = undefined;
+        this.#allSorted = undefined;
     }
     removeAll() {
         (0, index_1.ensureNotDeleted)(this.entity);
-        if (this.#loaded === undefined) {
+        if (!this.#state.isLoaded) {
             throw new Error("removeAll was called when not loaded");
         }
-        for (const other of [...this.#loaded]) {
+        for (const other of [...this.#state.doGet()]) {
             this.remove(other);
         }
     }
     // internal impl
+    /** @internal */
+    percolateAdd(other) {
+        this.getOtherRelation(other).set(this.entity);
+    }
+    /** @internal */
+    percolateRemove(other) {
+        this.getOtherRelation(other).set(undefined);
+    }
+    /** @internal */
+    registerAsMutated() {
+        (0, index_1.getEmInternalApi)(this.entity.em).mutatedCollections.add(this);
+    }
     setFromOpts(others) {
-        this.#loaded = [];
+        this.#state = new O2MLoadedState(this, [], false);
         others.forEach((o) => this.add(o));
     }
     removeIfLoaded(other) {
-        this.#removed ??= [];
-        (0, utils_1.maybeRemove)(this.#added, other);
-        (0, utils_1.maybeAdd)(this.#removed, other);
-        if (this.#loaded !== undefined) {
-            (0, utils_1.remove)(this.#loaded, other);
-        }
+        this.#state = this.#state.removeIfLoaded(other);
         this.registerAsMutated();
+        this.#getSorted = undefined;
+        this.#allSorted = undefined;
     }
     maybeCascadeDelete() {
         if (this.isCascadeDelete) {
@@ -243,43 +194,13 @@ class OneToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
         current.forEach((other) => {
             const m2o = this.getOtherRelation(other);
             if ((0, index_1.maybeResolveReferenceToId)(m2o.current({ withDeleted: true })) === this.entity.idMaybe) {
-                // TODO What if other.otherFieldName is required/not-null?
                 m2o.set(undefined);
             }
         });
-        this.#loaded = [];
-        this.#added = [];
-        this.#removed = [];
+        this.#state = new O2MLoadedState(this, [], false);
         this.#getSorted = undefined;
         this.#allSorted = undefined;
     }
-    maybeAppendAddedBeforeLoaded() {
-        // If our entity is not new, then entities in the EM might have been mutated to point
-        // to our foreign key (instead of our loaded instance), which means they should be in
-        // `addedBeforeLoaded` but are not.
-        //
-        // (Note that we don't have to handle the case for "removed before loaded" here because
-        // the oneToManyDataLoader already handles that; although maybe arguably that logic should
-        // be handled here?)
-        if (!this.entity.isNewEntity) {
-            const { em } = this.entity;
-            const pending = (0, index_1.getEmInternalApi)(em).pendingChildren.get(this.entity.idTagged)?.get(this.fieldName);
-            if (pending) {
-                (this.#added ??= []).push(...pending.adds);
-                (this.#removed ??= []).push(...pending.removes);
-                (0, utils_1.clear)(pending.adds);
-                (0, utils_1.clear)(pending.removes);
-            }
-        }
-        if (this.#added) {
-            const newEntities = this.#added.filter((e) => !this.#loaded?.includes(e));
-            // Push on the end to better match the db order of "newer things come last"
-            this.#loaded.push(...newEntities);
-        }
-        if (this.#removed) {
-            this.#removed.forEach((e) => (0, utils_1.remove)(this.#loaded, e));
-        }
-    }
     // These are public to our internal implementation but not exposed in the Collection API
     get fieldName() {
         return this.#field.fieldName;
@@ -288,7 +209,7 @@ class OneToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
         return this.#field.otherFieldName;
     }
     current(opts) {
-        return this.filterDeleted(this.#loaded ?? this.#added ?? [], opts);
+        return this.filterDeleted(this.#state.current(), opts);
     }
     get meta() {
         return (0, index_1.getMetadata)(this.entity);
@@ -297,15 +218,14 @@ class OneToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
         return (0, index_1.getMetadata)(this.entity).allFields[this.fieldName].otherMetadata();
     }
     get hasBeenSet() {
-        return this.#hasBeenSet;
+        return this.#state.hasBeenSet;
     }
     toString() {
         return `OneToManyCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, otherType: ${this.otherMeta.type}, otherFieldName: ${this.otherFieldName})`;
     }
     /** Called after `em.flush` to reset our dirty tracking. */
     resetAddedRemoved() {
-        this.#added = undefined;
-        this.#removed = undefined;
+        this.#state.resetAddedRemoved();
     }
     /** Removes pending-hard-delete or soft-deleted entities, unless explicitly asked for. */
     filterDeleted(entities, opts) {
@@ -330,18 +250,340 @@ class OneToManyCollection extends AbstractRelationImpl_1.AbstractRelationImpl {
             return undefined;
         return (0, index_1.getEmInternalApi)(this.entity.em).getPreloadedRelation(this.entity.idTagged, this.fieldName);
     }
-    registerAsMutated() {
-        (0, index_1.getEmInternalApi)(this.entity.em).mutatedCollections.add(this);
-    }
     // Exposed for changes
     added() {
-        return this.#added ?? [];
+        return this.#state.added();
     }
     removed() {
-        return this.#removed ?? [];
+        return this.#state.removed();
     }
     [Relation_1.RelationT] = null;
     [Relation_1.RelationU] = null;
 }
 exports.OneToManyCollection = OneToManyCollection;
+/** Initial state for existing entities - no data loaded yet. */
+class O2MUnloadedPristineState {
+    isLoaded = false;
+    hasBeenSet = false;
+    #o2m;
+    constructor(o2m) {
+        this.#o2m = o2m;
+    }
+    add(other) {
+        return new O2MUnloadedAddedRemovedState(this.#o2m, [other], []);
+    }
+    remove(_other, opts) {
+        if (opts.requireLoaded) {
+            throw new Error("remove was called when not loaded");
+        }
+        return new O2MUnloadedAddedRemovedState(this.#o2m, [], [_other]);
+    }
+    removeIfLoaded(other) {
+        return new O2MUnloadedAddedRemovedState(this.#o2m, [], [other]);
+    }
+    set(values) {
+        return new O2MPendingSetState(this.#o2m, values);
+    }
+    doGet() {
+        throw new Error("get was called when not loaded");
+    }
+    find(_id) {
+        return undefined;
+    }
+    applyLoad(dbEntities) {
+        return new O2MLoadedState(this.#o2m, dbEntities, false);
+    }
+    current() {
+        return [];
+    }
+    import(target, _findEntity) {
+        return new O2MUnloadedPristineState(target);
+    }
+    added() {
+        return [];
+    }
+    removed() {
+        return [];
+    }
+    resetAddedRemoved() { }
+}
+/** State when add/remove called before load - tracks changes to merge later. */
+class O2MUnloadedAddedRemovedState {
+    isLoaded = false;
+    hasBeenSet = false;
+    #o2m;
+    #added;
+    #removed;
+    constructor(o2m, added, removed) {
+        this.#o2m = o2m;
+        this.#added = new Set(added);
+        this.#removed = new Set(removed);
+    }
+    add(other) {
+        this.#added.add(other);
+        this.#removed.delete(other);
+        return this;
+    }
+    remove(other, opts) {
+        if (opts.requireLoaded) {
+            throw new Error("remove was called when not loaded");
+        }
+        this.#removed.add(other);
+        this.#added.delete(other);
+        return this;
+    }
+    removeIfLoaded(other) {
+        this.#added.delete(other);
+        this.#removed.add(other);
+        return this;
+    }
+    set(values) {
+        // We should do the implicit deletion check?
+        // Should we keep #added/#removed?
+        return new O2MPendingSetState(this.#o2m, values);
+    }
+    doGet() {
+        throw new Error("get was called when not loaded");
+    }
+    find(id) {
+        for (const u of this.#added) {
+            if (!u.isNewEntity && u.id === id)
+                return u;
+        }
+        return undefined;
+    }
+    applyLoad(dbEntities) {
+        // Push added entities on the end to better match the db order of "newer things come last"
+        const loaded = new Set([...dbEntities]);
+        for (const e of this.#added)
+            loaded.add(e);
+        for (const e of this.#removed)
+            loaded.delete(e);
+        return new O2MLoadedState(this.#o2m, [...loaded], false, [...this.#added], [...this.#removed]);
+    }
+    current() {
+        return [...this.#added];
+    }
+    import(target, findEntity) {
+        return new O2MUnloadedAddedRemovedState(target, mapEntities([...this.#added], findEntity), mapEntities([...this.#removed], findEntity));
+    }
+    added() {
+        return [...this.#added];
+    }
+    removed() {
+        return [...this.#removed];
+    }
+    resetAddedRemoved() {
+        // This is called after em.flush, so these changes have been pushed into the db; we don't
+        // need to track them anymore b/c any future `o2m.load` will see up.
+        this.#added = new Set();
+        this.#removed = new Set();
+    }
+}
+/** State when set() called before load - holds pending values to diff on load. */
+class O2MPendingSetState {
+    isLoaded = false;
+    hasBeenSet = true;
+    #o2m;
+    #pendingValues;
+    constructor(o2m, pendingValues, skipPercolate = false) {
+        this.#o2m = o2m;
+        this.#pendingValues = new Set(pendingValues);
+        // We percolate on normal set() calls to immediately update the other side's m2o references.
+        // We skip percolation on import() because those entities already have correct references
+        // in the cloned EntityManager.
+        if (!skipPercolate)
+            this.#percolate();
+        (0, index_1.getEmInternalApi)(o2m.entity.em).pendingLoads.add(o2m);
+    }
+    add(other) {
+        this.#pendingValues.add(other);
+        return this;
+    }
+    remove(other, _opts) {
+        this.#pendingValues.delete(other);
+        return this;
+    }
+    removeIfLoaded(other) {
+        this.#pendingValues.delete(other);
+        return this;
+    }
+    set(values) {
+        this.#pendingValues = new Set(values);
+        this.#percolate();
+        return this;
+    }
+    doGet() {
+        return [...this.#pendingValues];
+    }
+    find(id) {
+        for (const u of this.#pendingValues) {
+            if (!u.isNewEntity && u.id === id)
+                return u;
+        }
+        return undefined;
+    }
+    applyLoad(dbEntities) {
+        const o2m = this.#o2m;
+        const entity = o2m.entity;
+        // Handle cascade delete + immutable: entities removed from the collection that
+        // cannot have their FK changed should be deleted instead
+        const otherCannotChange = o2m.otherMeta.allFields[o2m.otherFieldName].immutable;
+        const isCascade = (0, AbstractRelationImpl_1.isCascadeDelete)(o2m, o2m.fieldName);
+        // Calc our added/removed so that `.changes` in the new loaded state are correct
+        const dbSet = new Set(dbEntities);
+        const added = [];
+        for (const other of this.#pendingValues) {
+            if (!dbSet.has(other))
+                added.push(other);
+        }
+        const removed = [];
+        for (const other of dbEntities) {
+            if (!this.#pendingValues.has(other)) {
+                removed.push(other);
+                if (isCascade && otherCannotChange) {
+                    entity.em.delete(other);
+                }
+                else {
+                    o2m.percolateRemove(other);
+                }
+            }
+        }
+        return new O2MLoadedState(o2m, [...this.#pendingValues], true, added, removed);
+    }
+    current() {
+        return [...this.#pendingValues];
+    }
+    import(target, findEntity) {
+        return new O2MPendingSetState(target, mapEntities([...this.#pendingValues], findEntity), true);
+    }
+    added() {
+        return [...this.#pendingValues];
+    }
+    removed() {
+        return [];
+    }
+    resetAddedRemoved() { }
+    #percolate() {
+        const o2m = this.#o2m;
+        // All new values, we immediately tell them we're their new parent
+        for (const other of this.#pendingValues) {
+            o2m.percolateAdd(other);
+        }
+        // If we're an existing entity, we can scan for any in-memory entities that were previously
+        // pointing to us, but now should not
+        if (!o2m.entity.isNewEntity) {
+            for (const other of o2m.entity.em.getEntities(o2m.otherMeta.cstr)) {
+                if (this.#pendingValues.has(other))
+                    continue;
+                if ((0, index_1.sameEntity)(other[o2m.otherFieldName].current(), o2m.entity)) {
+                    o2m.percolateRemove(other);
+                }
+            }
+        }
+    }
+}
+/** State when collection is loaded - all operations work directly on loaded array. */
+class O2MLoadedState {
+    isLoaded = true;
+    #o2m;
+    #loaded;
+    #added;
+    #removed;
+    #hasBeenSet;
+    constructor(o2m, loaded, hasBeenSet, added = [], removed = []) {
+        this.#o2m = o2m;
+        this.#loaded = new Set(loaded);
+        this.#added = new Set(added);
+        this.#removed = new Set(removed);
+        this.#hasBeenSet = hasBeenSet;
+    }
+    get hasBeenSet() {
+        return this.#hasBeenSet;
+    }
+    add(other) {
+        this.#added.add(other);
+        this.#removed.delete(other);
+        this.#loaded.add(other);
+        return this;
+    }
+    remove(other, _opts) {
+        this.#removed.add(other);
+        this.#added.delete(other);
+        this.#loaded.delete(other);
+        return this;
+    }
+    removeIfLoaded(other) {
+        this.#added.delete(other);
+        this.#removed.add(other);
+        this.#loaded.delete(other);
+        return this;
+    }
+    set(values) {
+        this.#hasBeenSet = true;
+        let valuesSet = new Set(values);
+        const o2m = this.#o2m;
+        const otherCannotChange = o2m.otherMeta.allFields[o2m.otherFieldName].immutable;
+        const isCascade = (0, AbstractRelationImpl_1.isCascadeDelete)(o2m, o2m.fieldName);
+        if (isCascade && otherCannotChange) {
+            const implicitlyDeleted = [...this.#loaded].filter((e) => !valuesSet.has(e));
+            implicitlyDeleted.forEach((e) => o2m.entity.em.delete(e));
+            // ...we restore the implicitlyDeleted for getWithDeleted
+            values = [...values, ...implicitlyDeleted];
+            valuesSet = new Set(values);
+        }
+        const loaded = new Set(this.#loaded);
+        for (const other of loaded) {
+            if (!valuesSet.has(other))
+                o2m.remove(other);
+        }
+        for (const other of values) {
+            if (!loaded.has(other))
+                o2m.add(other);
+        }
+        return this;
+    }
+    doGet() {
+        return [...this.#loaded];
+    }
+    find(id) {
+        for (const other of this.#loaded) {
+            if (!other.isNewEntity && other.id === id)
+                return other;
+        }
+        return undefined;
+    }
+    applyLoad(dbEntities) {
+        // On forceReload, replace loaded but preserve pending adds/removes
+        const loaded = new Set(dbEntities);
+        for (const e of this.#added)
+            loaded.add(e);
+        for (const e of this.#removed)
+            loaded.delete(e);
+        this.#loaded = loaded;
+        return this;
+    }
+    current() {
+        return [...this.#loaded];
+    }
+    import(target, findEntity) {
+        return new O2MLoadedState(target, mapEntities([...this.#loaded], findEntity), this.#hasBeenSet, mapEntities([...this.#added], findEntity), mapEntities([...this.#removed], findEntity));
+    }
+    added() {
+        return [...this.#added];
+    }
+    removed() {
+        return [...this.#removed];
+    }
+    resetAddedRemoved() {
+        this.#added = new Set();
+        this.#removed = new Set();
+    }
+}
+function mapEntities(entities, findEntity) {
+    const result = new Array(entities.length);
+    for (let i = 0; i < entities.length; i++)
+        result[i] = findEntity(entities[i]);
+    return result;
+}
 //# sourceMappingURL=OneToManyCollection.js.map