joist-core 2.3.0 → 2.4.0

package/build/relations/RecursiveCollection.js

@@ -1,439 +1,379 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecursiveM2mCollectionImpl = exports.RecursiveChildrenCollectionImpl = exports.RecursiveParentsCollectionImpl = exports.RecursiveCycleError = void 0;
-exports.hasRecursiveParents = hasRecursiveParents;
-exports.hasRecursiveChildren = hasRecursiveChildren;
-exports.hasRecursiveM2m = hasRecursiveM2m;
-const recursiveChildrenBatchLoader_1 = require("../batchloaders/recursiveChildrenBatchLoader");
-const recursiveM2mBatchLoader_1 = require("../batchloaders/recursiveM2mBatchLoader");
-const recursiveParentsBatchLoader_1 = require("../batchloaders/recursiveParentsBatchLoader");
-const index_1 = require("../index");
-const newEntity_1 = require("../newEntity");
-const AbstractRelationImpl_1 = require("./AbstractRelationImpl");
-const RecursiveCycleError_1 = require("./RecursiveCycleError");
-Object.defineProperty(exports, "RecursiveCycleError", { enumerable: true, get: function () { return RecursiveCycleError_1.RecursiveCycleError; } });
-const Relation_1 = require("./Relation");
+import { isCollection, isLoadedCollection } from "./Collection.js";
+import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
+import { RelationT, RelationU } from "./RelationSymbols.js";
+import { recursiveChildrenBatchLoader } from "../batchloaders/recursiveChildrenBatchLoader.js";
+import { recursiveM2mBatchLoader } from "../batchloaders/recursiveM2mBatchLoader.js";
+import { recursiveParentsBatchLoader } from "../batchloaders/recursiveParentsBatchLoader.js";
+import "./ReadOnlyCollection.js";
+import { RecursiveCycleError } from "./RecursiveCycleError.js";
+import { isLoadedReference, isReference } from "./Reference.js";
+import { isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.js";
+import { fail } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
+import { ensureNotDeleted } from "../index.js";
+import { appendStack, getEmInternalApi } from "../EntityManager.js";
+//#region src/relations/RecursiveCollection.ts
 /**
- * An alias for creating `RecursiveParentsCollectionImpl`s.
- *
- * I.e. for `Author.mentor` (m2o fk), we can return `Author.mentorsRecursive` recursively looking up.
- */
-function hasRecursiveParents(m2oName, // i.e. `author.mentor`
-otherFieldName) {
-    return (0, newEntity_1.lazyField)((entity, fieldName) => {
-        return new RecursiveParentsCollectionImpl(entity, fieldName, m2oName, otherFieldName);
-    });
+* An alias for creating `RecursiveParentsCollectionImpl`s.
+*
+* I.e. for `Author.mentor` (m2o fk), we can return `Author.mentorsRecursive` recursively looking up.
+*/
+function hasRecursiveParents(m2oName, otherFieldName) {
+	return lazyField((entity, fieldName) => {
+		return new RecursiveParentsCollectionImpl(entity, fieldName, m2oName, otherFieldName);
+	});
 }
 /**
- * An alias for creating `RecursiveChildrenCollectionImpl`s.
- *
- * I.e. for `Author.mentees` (o2m), we can return `Author.menteesRecursive` recursively looking down.
- */
-function hasRecursiveChildren(o2mName, // i.e. `author.mentees`
-otherFieldName) {
-    return (0, newEntity_1.lazyField)((entity, fieldName) => {
-        return new RecursiveChildrenCollectionImpl(entity, fieldName, o2mName, otherFieldName);
-    });
+* An alias for creating `RecursiveChildrenCollectionImpl`s.
+*
+* I.e. for `Author.mentees` (o2m), we can return `Author.menteesRecursive` recursively looking down.
+*/
+function hasRecursiveChildren(o2mName, otherFieldName) {
+	return lazyField((entity, fieldName) => {
+		return new RecursiveChildrenCollectionImpl(entity, fieldName, o2mName, otherFieldName);
+	});
 }
 /**
- * An alias for creating `RecursiveM2mCollectionImpl`s.
- *
- * I.e. for `User.parents` (m2m), we can return `User.parentsRecursive` recursively looking up through the m2m.
- * Or for `User.children` (m2m), we can return `User.childrenRecursive` recursively looking down.
- */
-function hasRecursiveM2m(m2mName, // i.e. `user.parents` or `user.children`
-otherFieldName) {
-    return (0, newEntity_1.lazyField)((entity, fieldName) => {
-        return new RecursiveM2mCollectionImpl(entity, fieldName, m2mName, otherFieldName);
-    });
+* An alias for creating `RecursiveM2mCollectionImpl`s.
+*
+* I.e. for `User.parents` (m2m), we can return `User.parentsRecursive` recursively looking up through the m2m.
+* Or for `User.children` (m2m), we can return `User.childrenRecursive` recursively looking down.
+*/
+function hasRecursiveM2m(m2mName, otherFieldName) {
+	return lazyField((entity, fieldName) => {
+		return new RecursiveM2mCollectionImpl(entity, fieldName, m2mName, otherFieldName);
+	});
 }
 /**
- * A base class for the common methods between the parent & children recursive collections.
- *
- * We could probably move some of this into AbstractRelationImpl?
- */
-class AbstractRecursiveCollectionImpl extends AbstractRelationImpl_1.AbstractRelationImpl {
-    get get() {
-        return this.filterDeleted(this.doGet(), { withDeleted: false });
-    }
-    get getWithDeleted() {
-        return this.filterDeleted(this.doGet(), { withDeleted: true });
-    }
-    setFromOpts() {
-        throw new Error("Method not implemented.");
-    }
-    set() {
-        throw new Error("Method not implemented.");
-    }
-    get isPreloaded() {
-        return false;
-    }
-    preload() {
-        throw new Error("Method not implemented.");
-    }
-    cleanupOnEntityDeleted() {
-        return Promise.resolve();
-    }
-    maybeCascadeDelete() { }
-    get meta() {
-        return (0, index_1.getMetadata)(this.entity);
-    }
-    /** Removes pending-hard-delete or soft-deleted entities, unless explicitly asked for. */
-    filterDeleted(entities, opts) {
-        return opts?.withDeleted === true
-            ? [...entities]
-            : entities.filter((e) => !e.isDeletedEntity && !e.isSoftDeletedEntity);
-    }
-    [Relation_1.RelationT] = null;
-    [Relation_1.RelationU] = null;
-}
-class RecursiveParentsCollectionImpl extends AbstractRecursiveCollectionImpl {
-    #fieldName;
-    #m2oName;
-    #otherFieldName;
-    #loaded = undefined;
-    #loadPromise;
-    constructor(entity, fieldName, m2oName, otherFieldName) {
-        super(entity);
-        this.#fieldName = fieldName;
-        this.#m2oName = m2oName;
-        this.#otherFieldName = otherFieldName;
-    }
-    // opts is an internal parameter
-    async load(opts = {}) {
-        (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        if (!this.isLoaded || opts.forceReload) {
-            if (opts.forceReload) {
-                this.#loaded = undefined;
-            }
-            // If we have `[grandchild, newlyCreatedParent, existingGrandparent, ...more...]`, skip up to the
-            // `existingGrandparent`, because if we `.load(entity)` (i.e. where we are the `grandchild`) then
-            // recursiveParentsBatchLoader will try CTE query up from `grandchild[parent]`, but since that will
-            // be `newlyCreatedParent`, it doesn't have an id yet.
-            const entityToLoad = opts.forceReload ? this.entity : this.findUnloadedReference()?.entity;
-            if (entityToLoad && !entityToLoad.isNewEntity) {
-                await (this.#loadPromise ??= (0, recursiveParentsBatchLoader_1.recursiveParentsBatchLoader)(this.entity.em, this)
-                    .load(entityToLoad)
-                    .catch(function load(err) {
-                    throw (0, index_1.appendStack)(err, new Error());
-                })
-                    .finally(() => {
-                    this.#loadPromise = undefined;
-                }));
-                // See if there are any WIP changes, i.e. new parents, that the ^ SQL query didn't know to load.
-                // We don't have to `while` loop this, because if parent itself has WIP changes above it, then
-                // its own `RecursiveParentsCollectionImpl.load` will load it, before returning to this method.
-                const unloadedParent = this.findUnloadedReference();
-                if (unloadedParent) {
-                    await (0, recursiveParentsBatchLoader_1.recursiveParentsBatchLoader)(this.entity.em, this)
-                        .load(unloadedParent.entity)
-                        .catch(function load(err) {
-                        throw (0, index_1.appendStack)(err, new Error());
-                    });
-                }
-            }
-            this.#loaded = true;
-        }
-        return this.filterDeleted(this.doGet(), opts);
-    }
-    get isLoaded() {
-        if (this.#loaded !== undefined)
-            return this.#loaded;
-        this.#loaded = this.findUnloadedReference() === undefined;
-        (0, index_1.getEmInternalApi)(this.entity.em).isLoadedCache.addNaive(this);
-        return this.#loaded;
-    }
-    resetIsLoaded() {
-        this.#loaded = undefined;
-    }
-    get fieldName() {
-        return this.#fieldName;
-    }
-    get m2oFieldName() {
-        return this.#m2oName;
-    }
-    get otherFieldName() {
-        return this.#otherFieldName;
-    }
-    get hasBeenSet() {
-        return false;
-    }
-    toString() {
-        return `RecursiveParentsCollectionImpl(entity: ${this.entity}, fieldName: ${this.fieldName})`;
-    }
-    doGet() {
-        (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        const unloaded = this.findUnloadedReference();
-        if (unloaded) {
-            throw new Error(this.toString() + `.get was called but ${unloaded} was not loaded`);
-        }
-        const parents = [];
-        const visited = new Set();
-        for (let current = getLoadedReference(this.entity[this.#m2oName]); current !== undefined; current = getLoadedReference(current[this.#m2oName])) {
-            parents.push(current);
-            if (visited.has(current))
-                throw new RecursiveCycleError_1.RecursiveCycleError(this, [...visited, current]);
-            visited.add(current);
-        }
-        return parents;
-    }
-    findUnloadedReference() {
-        const visited = new Set();
-        for (let current = this.entity; current !== undefined; current = getLoadedReference(current[this.#m2oName])) {
-            const relation = current[this.#m2oName];
-            if ((0, index_1.isReference)(relation) && !(0, index_1.isLoadedReference)(relation))
-                return relation;
-            if (visited.has(current))
-                throw new RecursiveCycleError_1.RecursiveCycleError(this, [...visited, current]);
-            visited.add(current);
-        }
-        return undefined;
-    }
-}
-exports.RecursiveParentsCollectionImpl = RecursiveParentsCollectionImpl;
-class RecursiveChildrenCollectionImpl extends AbstractRecursiveCollectionImpl {
-    #fieldName;
-    #o2mName;
-    #otherFieldName;
-    #loaded = undefined;
-    #loadPromise;
-    constructor(entity, fieldName, o2mName, otherFieldName) {
-        super(entity);
-        this.#fieldName = fieldName;
-        this.#o2mName = o2mName;
-        this.#otherFieldName = otherFieldName;
-    }
-    // opts is an internal parameter
-    async load(opts = {}) {
-        (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        if (!this.isLoaded || opts.forceReload) {
-            if (opts.forceReload) {
-                this.#loaded = undefined;
-            }
-            if (!this.entity.isNewEntity) {
-                await (this.#loadPromise ??= (0, recursiveChildrenBatchLoader_1.recursiveChildrenBatchLoader)(this.entity.em, this)
-                    .load(this.entity)
-                    .catch(function load(err) {
-                    throw (0, index_1.appendStack)(err, new Error());
-                })
-                    .finally(() => {
-                    this.#loadPromise = undefined;
-                }));
-            }
-            const unloaded = this.findUnloadedCollections();
-            if (unloaded.length > 0) {
-                // Go through the entities own `fooRecursive` collection so that it's marked as loaded.
-                // We don't have to `while` loop this, because if they children themselves have any WIP
-                // changes, then their own `RecursiveChildrenCollectionImpl.load` will load them.
-                await Promise.all(unloaded.map((r) => r.entity[this.fieldName].load(opts)));
-            }
-            this.#loaded = true;
-        }
-        return this.filterDeleted(this.doGet(), opts);
-    }
-    get isLoaded() {
-        if (this.#loaded !== undefined)
-            return this.#loaded;
-        this.#loaded = this.findUnloadedCollections().length === 0;
-        (0, index_1.getEmInternalApi)(this.entity.em).isLoadedCache.addNaive(this);
-        return this.#loaded;
-    }
-    resetIsLoaded() {
-        this.#loaded = undefined;
-    }
-    get fieldName() {
-        return this.#fieldName;
-    }
-    get o2mFieldName() {
-        return this.#o2mName;
-    }
-    get otherFieldName() {
-        return this.#otherFieldName;
-    }
-    get hasBeenSet() {
-        return false;
-    }
-    toString() {
-        return `RecursiveChildrenCollectionImpl(entity: ${this.entity}, fieldName: ${this.fieldName})`;
-    }
-    doGet() {
-        (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        if (!this.isLoaded) {
-            throw new Error(this.toString() + `.get was called but when not loaded`);
-        }
-        const children = [];
-        const visited = new Set();
-        // Use a node+path combo to know which path caused the cycle
-        const todo = [{ relation: this.entity[this.#o2mName], path: [this.entity] }];
-        while (todo.length > 0) {
-            const { relation, path } = todo.pop();
-            if (visited.has(relation))
-                throw new RecursiveCycleError_1.RecursiveCycleError(this, path);
-            visited.add(relation);
-            for (const child of getLoadedCollection(relation)) {
-                children.push(child);
-                todo.push({ relation: child[this.#o2mName], path: [...path, child] });
-            }
-        }
-        return children;
-    }
-    /** Finds any children/downstream o2m collections or o2o references. */
-    findUnloadedCollections() {
-        const visited = new Set();
-        const unloaded = [];
-        const todo = [{ relation: this.entity[this.#o2mName], path: [this.entity] }];
-        while (todo.length > 0) {
-            const { relation, path } = todo.pop();
-            if (visited.has(relation))
-                throw new RecursiveCycleError_1.RecursiveCycleError(this, path);
-            visited.add(relation);
-            if ((0, index_1.isCollection)(relation) && !(0, index_1.isLoadedCollection)(relation)) {
-                unloaded.push(relation);
-            }
-            else if ((0, index_1.isOneToOneReference)(relation) && !(0, index_1.isLoadedOneToOneReference)(relation)) {
-                unloaded.push(relation);
-            }
-            else {
-                for (const child of getLoadedCollection(relation)) {
-                    todo.push({ relation: child[this.#o2mName], path: [...path, child] });
-                }
-            }
-        }
-        return unloaded;
-    }
-}
-exports.RecursiveChildrenCollectionImpl = RecursiveChildrenCollectionImpl;
-class RecursiveM2mCollectionImpl extends AbstractRecursiveCollectionImpl {
-    #fieldName;
-    #m2mName;
-    #otherFieldName;
-    #loaded = undefined;
-    #loadPromise;
-    constructor(entity, fieldName, m2mName, otherFieldName) {
-        super(entity);
-        this.#fieldName = fieldName;
-        this.#m2mName = m2mName;
-        this.#otherFieldName = otherFieldName;
-    }
-    // opts is an internal parameter
-    async load(opts = {}) {
-        (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        if (!this.isLoaded || opts.forceReload) {
-            if (opts.forceReload) {
-                this.#loaded = undefined;
-            }
-            if (!this.entity.isNewEntity) {
-                await (this.#loadPromise ??= (0, recursiveM2mBatchLoader_1.recursiveM2mBatchLoader)(this.entity.em, this)
-                    .load(this.entity)
-                    .catch(function load(err) {
-                    throw (0, index_1.appendStack)(err, new Error());
-                })
-                    .finally(() => {
-                    this.#loadPromise = undefined;
-                }));
-            }
-            const unloaded = this.findUnloadedCollections();
-            if (unloaded.length > 0) {
-                // Go through the entity's own `fooRecursive` collection so that it's marked as loaded.
-                await Promise.all(unloaded.map((r) => r.entity[this.fieldName].load(opts)));
-            }
-            this.#loaded = true;
-        }
-        return this.filterDeleted(this.doGet(), opts);
-    }
-    get isLoaded() {
-        if (this.#loaded !== undefined)
-            return this.#loaded;
-        this.#loaded = this.findUnloadedCollections().length === 0;
-        (0, index_1.getEmInternalApi)(this.entity.em).isLoadedCache.addNaive(this);
-        return this.#loaded;
-    }
-    resetIsLoaded() {
-        this.#loaded = undefined;
-    }
-    get fieldName() {
-        return this.#fieldName;
-    }
-    get m2mFieldName() {
-        return this.#m2mName;
-    }
-    get otherFieldName() {
-        return this.#otherFieldName;
-    }
-    get m2mField() {
-        return this.meta.allFields[this.#m2mName];
-    }
-    get hasBeenSet() {
-        return false;
-    }
-    toString() {
-        return `RecursiveM2mCollectionImpl(entity: ${this.entity}, fieldName: ${this.fieldName})`;
-    }
-    doGet() {
-        (0, index_1.ensureNotDeleted)(this.entity, "pending");
-        if (!this.isLoaded) {
-            throw new Error(this.toString() + `.get was called but when not loaded`);
-        }
-        const results = [];
-        // Track by entity to handle diamonds (same entity reachable via multiple paths)
-        const visited = new Set();
-        visited.add(this.entity);
-        const todo = [{ entity: this.entity, path: [this.entity] }];
-        while (todo.length > 0) {
-            const { entity: current, path } = todo.pop();
-            for (const other of getLoadedCollection(current[this.#m2mName])) {
-                if (visited.has(other)) {
-                    // If we're reaching an entity we've already visited, and it's this.entity, that's a cycle
-                    if (other === this.entity)
-                        throw new RecursiveCycleError_1.RecursiveCycleError(this, [...path, other]);
-                    // Otherwise it's a diamond (reachable via multiple paths) — skip
-                    continue;
-                }
-                visited.add(other);
-                results.push(other);
-                todo.push({ entity: other, path: [...path, other] });
-            }
-        }
-        return results;
-    }
-    /** Finds any m2m collections that are not yet loaded in the recursive tree. */
-    findUnloadedCollections() {
-        const visited = new Set();
-        visited.add(this.entity);
-        const unloaded = [];
-        const todo = [{ entity: this.entity, path: [this.entity] }];
-        while (todo.length > 0) {
-            const { entity: current, path } = todo.pop();
-            const relation = current[this.#m2mName];
-            if ((0, index_1.isCollection)(relation) && !(0, index_1.isLoadedCollection)(relation)) {
-                unloaded.push(relation);
-            }
-            else {
-                for (const other of getLoadedCollection(relation)) {
-                    if (visited.has(other)) {
-                        if (other === this.entity)
-                            throw new RecursiveCycleError_1.RecursiveCycleError(this, [...path, other]);
-                        continue;
-                    }
-                    visited.add(other);
-                    todo.push({ entity: other, path: [...path, other] });
-                }
-            }
-        }
-        return unloaded;
-    }
-}
-exports.RecursiveM2mCollectionImpl = RecursiveM2mCollectionImpl;
+* A base class for the common methods between the parent & children recursive collections.
+*
+* We could probably move some of this into AbstractRelationImpl?
+*/
+var AbstractRecursiveCollectionImpl = class extends AbstractRelationImpl {
+	get get() {
+		return this.filterDeleted(this.doGet(), { withDeleted: false });
+	}
+	get getWithDeleted() {
+		return this.filterDeleted(this.doGet(), { withDeleted: true });
+	}
+	setFromOpts() {
+		throw new Error("Method not implemented.");
+	}
+	set() {
+		throw new Error("Method not implemented.");
+	}
+	get isPreloaded() {
+		return false;
+	}
+	preload() {
+		throw new Error("Method not implemented.");
+	}
+	cleanupOnEntityDeleted() {
+		return Promise.resolve();
+	}
+	maybeCascadeDelete() {}
+	get meta() {
+		return getMetadata(this.entity);
+	}
+	/** Removes pending-hard-delete or soft-deleted entities, unless explicitly asked for. */
+	filterDeleted(entities, opts) {
+		return opts?.withDeleted === true ? [...entities] : entities.filter((e) => !e.isDeletedEntity && !e.isSoftDeletedEntity);
+	}
+	[RelationT] = null;
+	[RelationU] = null;
+};
+var RecursiveParentsCollectionImpl = class extends AbstractRecursiveCollectionImpl {
+	#fieldName;
+	#m2oName;
+	#otherFieldName;
+	#loaded = void 0;
+	#loadPromise;
+	constructor(entity, fieldName, m2oName, otherFieldName) {
+		super(entity);
+		this.#fieldName = fieldName;
+		this.#m2oName = m2oName;
+		this.#otherFieldName = otherFieldName;
+	}
+	async load(opts = {}) {
+		ensureNotDeleted(this.entity, "pending");
+		if (!this.isLoaded || opts.forceReload) {
+			if (opts.forceReload) this.#loaded = void 0;
+			const entityToLoad = opts.forceReload ? this.entity : this.findUnloadedReference()?.entity;
+			if (entityToLoad && !entityToLoad.isNewEntity) {
+				await (this.#loadPromise ??= recursiveParentsBatchLoader(this.entity.em, this).load(entityToLoad).catch(function load(err) {
+					throw appendStack(err, /* @__PURE__ */ new Error());
+				}).finally(() => {
+					this.#loadPromise = void 0;
+				}));
+				const unloadedParent = this.findUnloadedReference();
+				if (unloadedParent) await recursiveParentsBatchLoader(this.entity.em, this).load(unloadedParent.entity).catch(function load(err) {
+					throw appendStack(err, /* @__PURE__ */ new Error());
+				});
+			}
+			this.#loaded = true;
+		}
+		return this.filterDeleted(this.doGet(), opts);
+	}
+	get isLoaded() {
+		if (this.#loaded !== void 0) return this.#loaded;
+		this.#loaded = this.findUnloadedReference() === void 0;
+		getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);
+		return this.#loaded;
+	}
+	resetIsLoaded() {
+		this.#loaded = void 0;
+	}
+	get fieldName() {
+		return this.#fieldName;
+	}
+	get m2oFieldName() {
+		return this.#m2oName;
+	}
+	get otherFieldName() {
+		return this.#otherFieldName;
+	}
+	get hasBeenSet() {
+		return false;
+	}
+	toString() {
+		return `RecursiveParentsCollectionImpl(entity: ${this.entity}, fieldName: ${this.fieldName})`;
+	}
+	doGet() {
+		ensureNotDeleted(this.entity, "pending");
+		const unloaded = this.findUnloadedReference();
+		if (unloaded) throw new Error(this.toString() + `.get was called but ${unloaded} was not loaded`);
+		const parents = [];
+		const visited = /* @__PURE__ */ new Set();
+		for (let current = getLoadedReference(this.entity[this.#m2oName]); current !== void 0; current = getLoadedReference(current[this.#m2oName])) {
+			parents.push(current);
+			if (visited.has(current)) throw new RecursiveCycleError(this, [...visited, current]);
+			visited.add(current);
+		}
+		return parents;
+	}
+	findUnloadedReference() {
+		const visited = /* @__PURE__ */ new Set();
+		for (let current = this.entity; current !== void 0; current = getLoadedReference(current[this.#m2oName])) {
+			const relation = current[this.#m2oName];
+			if (isReference(relation) && !isLoadedReference(relation)) return relation;
+			if (visited.has(current)) throw new RecursiveCycleError(this, [...visited, current]);
+			visited.add(current);
+		}
+	}
+};
+var RecursiveChildrenCollectionImpl = class extends AbstractRecursiveCollectionImpl {
+	#fieldName;
+	#o2mName;
+	#otherFieldName;
+	#loaded = void 0;
+	#loadPromise;
+	constructor(entity, fieldName, o2mName, otherFieldName) {
+		super(entity);
+		this.#fieldName = fieldName;
+		this.#o2mName = o2mName;
+		this.#otherFieldName = otherFieldName;
+	}
+	async load(opts = {}) {
+		ensureNotDeleted(this.entity, "pending");
+		if (!this.isLoaded || opts.forceReload) {
+			if (opts.forceReload) this.#loaded = void 0;
+			if (!this.entity.isNewEntity) await (this.#loadPromise ??= recursiveChildrenBatchLoader(this.entity.em, this).load(this.entity).catch(function load(err) {
+				throw appendStack(err, /* @__PURE__ */ new Error());
+			}).finally(() => {
+				this.#loadPromise = void 0;
+			}));
+			const unloaded = this.findUnloadedCollections();
+			if (unloaded.length > 0) await Promise.all(unloaded.map((r) => r.entity[this.fieldName].load(opts)));
+			this.#loaded = true;
+		}
+		return this.filterDeleted(this.doGet(), opts);
+	}
+	get isLoaded() {
+		if (this.#loaded !== void 0) return this.#loaded;
+		this.#loaded = this.findUnloadedCollections().length === 0;
+		getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);
+		return this.#loaded;
+	}
+	resetIsLoaded() {
+		this.#loaded = void 0;
+	}
+	get fieldName() {
+		return this.#fieldName;
+	}
+	get o2mFieldName() {
+		return this.#o2mName;
+	}
+	get otherFieldName() {
+		return this.#otherFieldName;
+	}
+	get hasBeenSet() {
+		return false;
+	}
+	toString() {
+		return `RecursiveChildrenCollectionImpl(entity: ${this.entity}, fieldName: ${this.fieldName})`;
+	}
+	doGet() {
+		ensureNotDeleted(this.entity, "pending");
+		if (!this.isLoaded) throw new Error(this.toString() + `.get was called but when not loaded`);
+		const children = [];
+		const visited = /* @__PURE__ */ new Set();
+		const todo = [{
+			relation: this.entity[this.#o2mName],
+			path: [this.entity]
+		}];
+		while (todo.length > 0) {
+			const { relation, path } = todo.pop();
+			if (visited.has(relation)) throw new RecursiveCycleError(this, path);
+			visited.add(relation);
+			for (const child of getLoadedCollection(relation)) {
+				children.push(child);
+				todo.push({
+					relation: child[this.#o2mName],
+					path: [...path, child]
+				});
+			}
+		}
+		return children;
+	}
+	/** Finds any children/downstream o2m collections or o2o references. */
+	findUnloadedCollections() {
+		const visited = /* @__PURE__ */ new Set();
+		const unloaded = [];
+		const todo = [{
+			relation: this.entity[this.#o2mName],
+			path: [this.entity]
+		}];
+		while (todo.length > 0) {
+			const { relation, path } = todo.pop();
+			if (visited.has(relation)) throw new RecursiveCycleError(this, path);
+			visited.add(relation);
+			if (isCollection(relation) && !isLoadedCollection(relation)) unloaded.push(relation);
+			else if (isOneToOneReference(relation) && !isLoadedOneToOneReference(relation)) unloaded.push(relation);
+			else for (const child of getLoadedCollection(relation)) todo.push({
+				relation: child[this.#o2mName],
+				path: [...path, child]
+			});
+		}
+		return unloaded;
+	}
+};
+var RecursiveM2mCollectionImpl = class extends AbstractRecursiveCollectionImpl {
+	#fieldName;
+	#m2mName;
+	#otherFieldName;
+	#loaded = void 0;
+	#loadPromise;
+	constructor(entity, fieldName, m2mName, otherFieldName) {
+		super(entity);
+		this.#fieldName = fieldName;
+		this.#m2mName = m2mName;
+		this.#otherFieldName = otherFieldName;
+	}
+	async load(opts = {}) {
+		ensureNotDeleted(this.entity, "pending");
+		if (!this.isLoaded || opts.forceReload) {
+			if (opts.forceReload) this.#loaded = void 0;
+			if (!this.entity.isNewEntity) await (this.#loadPromise ??= recursiveM2mBatchLoader(this.entity.em, this).load(this.entity).catch(function load(err) {
+				throw appendStack(err, /* @__PURE__ */ new Error());
+			}).finally(() => {
+				this.#loadPromise = void 0;
+			}));
+			const unloaded = this.findUnloadedCollections();
+			if (unloaded.length > 0) await Promise.all(unloaded.map((r) => r.entity[this.fieldName].load(opts)));
+			this.#loaded = true;
+		}
+		return this.filterDeleted(this.doGet(), opts);
+	}
+	get isLoaded() {
+		if (this.#loaded !== void 0) return this.#loaded;
+		this.#loaded = this.findUnloadedCollections().length === 0;
+		getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);
+		return this.#loaded;
+	}
+	resetIsLoaded() {
+		this.#loaded = void 0;
+	}
+	get fieldName() {
+		return this.#fieldName;
+	}
+	get m2mFieldName() {
+		return this.#m2mName;
+	}
+	get otherFieldName() {
+		return this.#otherFieldName;
+	}
+	get m2mField() {
+		return this.meta.allFields[this.#m2mName];
+	}
+	get hasBeenSet() {
+		return false;
+	}
+	toString() {
+		return `RecursiveM2mCollectionImpl(entity: ${this.entity}, fieldName: ${this.fieldName})`;
+	}
+	doGet() {
+		ensureNotDeleted(this.entity, "pending");
+		if (!this.isLoaded) throw new Error(this.toString() + `.get was called but when not loaded`);
+		const results = [];
+		const visited = /* @__PURE__ */ new Set();
+		visited.add(this.entity);
+		const todo = [{
+			entity: this.entity,
+			path: [this.entity]
+		}];
+		while (todo.length > 0) {
+			const { entity: current, path } = todo.pop();
+			for (const other of getLoadedCollection(current[this.#m2mName])) {
+				if (visited.has(other)) {
+					if (other === this.entity) throw new RecursiveCycleError(this, [...path, other]);
+					continue;
+				}
+				visited.add(other);
+				results.push(other);
+				todo.push({
+					entity: other,
+					path: [...path, other]
+				});
+			}
+		}
+		return results;
+	}
+	/** Finds any m2m collections that are not yet loaded in the recursive tree. */
+	findUnloadedCollections() {
+		const visited = /* @__PURE__ */ new Set();
+		visited.add(this.entity);
+		const unloaded = [];
+		const todo = [{
+			entity: this.entity,
+			path: [this.entity]
+		}];
+		while (todo.length > 0) {
+			const { entity: current, path } = todo.pop();
+			const relation = current[this.#m2mName];
+			if (isCollection(relation) && !isLoadedCollection(relation)) unloaded.push(relation);
+			else for (const other of getLoadedCollection(relation)) {
+				if (visited.has(other)) {
+					if (other === this.entity) throw new RecursiveCycleError(this, [...path, other]);
+					continue;
+				}
+				visited.add(other);
+				todo.push({
+					entity: other,
+					path: [...path, other]
+				});
+			}
+		}
+		return unloaded;
+	}
+};
 function getLoadedReference(relation) {
-    return (0, index_1.isLoadedReference)(relation) ? relation.get : (0, index_1.fail)(`${relation} was not loaded`);
+	return isLoadedReference(relation) ? relation.get : fail(`${relation} was not loaded`);
 }
 function getLoadedCollection(relation) {
-    return (0, index_1.isLoadedCollection)(relation)
-        ? relation.get
-        : (0, index_1.isLoadedOneToOneReference)(relation)
-            ? relation.get
-                ? [relation.get]
-                : []
-            : (0, index_1.fail)(`${relation} was not loaded`);
+	return isLoadedCollection(relation) ? relation.get : isLoadedOneToOneReference(relation) ? relation.get ? [relation.get] : [] : fail(`${relation} was not loaded`);
 }
+//#endregion
+export { RecursiveChildrenCollectionImpl, RecursiveCycleError, RecursiveM2mCollectionImpl, RecursiveParentsCollectionImpl, hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents };
+
 //# sourceMappingURL=RecursiveCollection.js.map