joist-core 2.3.0-next.7 → 2.3.0-next.71

package/build/loadLens.d.cts

@@ -0,0 +1,77 @@
+import { LoadHint } from "./loadHints.cjs";
+import { EntityMetadata, Field } from "./EntityMetadata.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/loadLens.d.ts
+/** Generically matches on a Reference/Collection's load method. */
+type LoadLike<U> = {
+  load(): Promise<U>;
+};
+/** Generically matches a property or zero-arg method that returns a promise. */
+type PromiseFnLike<U> = () => PromiseLike<U>;
+/**
+ * Given a parent type `R` (that is our current lens "return type", i.e. `Author` or `Author | undefined` or `Author[]`),
+ * and the type `V` of the "next step" of the traversal (i.e. itself `Book` or `Book | undefined` or `Book[]`, depending
+ * on the relation being traversed), returns `V` mapped to "the right format" based on `R`.
+ *
+ * I.e.:
+ *
+ * - `Author | undefined` that navigates a `Book` will become `Book | undefined`
+ * - `Author` that navigates a `Book | undefined` will also become `Book | undefined`
+ * - `Author[]` that navigates a `Book | undefined` will become a `Book[]`
+ * - `Author | undefined` that navigates a `Book[]` will become a `Book[]`
+ */
+type MaybeArray<R, V> = R extends ReadonlyArray<any> ? [V] extends [ReadonlyArray<infer U>] ? DropUndefined<U>[] : DropUndefined<V>[] : V extends ReadonlyArray<any> ? V : [R] extends [undefined] ? V | undefined : V;
+/** Given a type T that we come across in the path, de-array it to continue our flatMap-ish semantics. */
+type MaybeDropArray<T> = T extends ReadonlyArray<infer U> ? U : T;
+type DropUndefined<T> = Exclude<T, undefined>;
+/**
+ * A type for declaratively walking the object graph.
+ *
+ * This is not technically a Lens that can `get/set`, but the idea is generally the same.
+ *
+ * `T` is the type we're on, i.e. when `T = Author` we can do `.firstName` or `.lastName.
+ * `R` is either a `T` or `T[]` or `T | undefined` and just captures whether we've hit a
+ * list at any point in the lens navigation path.
+ */
+type Lens<T, R = T> = { [P in keyof T]: T[P] extends LoadLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : T[P] extends PromiseFnLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : Lens<MaybeDropArray<DropUndefined<T[P]>>, MaybeArray<R, T[P]>>; };
+/**
+ * Allows declaratively loading/traversing several layers of references at once.
+ *
+ * I.e.:
+ *
+ * ```typescript
+ * const publisher = await book.load(b => b.author.publisher);
+ * ```
+ */
+declare function loadLens<T extends Entity, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>, opts?: {
+  forceReload?: boolean;
+  sql?: boolean;
+}): Promise<V>;
+/** Loads a precomputed lens path, avoiding repeated lambda/proxy evaluation for long-lived relation declarations. */
+declare function loadLensPath<T extends Entity, V>(start: T | readonly T[], paths: string[], opts?: {
+  forceReload?: boolean;
+  sql?: boolean;
+}): Promise<V>;
+declare function isAllSqlPaths(meta: EntityMetadata, paths: string[]): boolean;
+declare function mapPathsToTarget(source: EntityMetadata, paths: string[]): [EntityMetadata, [EntityMetadata, Field][]];
+/**
+ * The synchronous version of `loadLens`.
+ *
+ * This assumes you've first evaluated the lens with `loadLens` and now can access it synchronously.
+ */
+declare function getLens<T, U, V>(startMeta: EntityMetadata, start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): V;
+/** Synchronously traverses a precomputed lens path. */
+declare function getLensPath<T, V>(startMeta: EntityMetadata, start: T | readonly T[], paths: string[]): V;
+/** Returns whether a lens is loaded; primarily for deeply loaded instances in tests. */
+declare function isLensLoaded<T, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): boolean;
+/** Returns whether a precomputed lens path is loaded; primarily for deeply loaded instances in tests. */
+declare function isLensLoadedPath<T>(start: T | readonly T[], paths: string[]): boolean;
+/** Accepts a lens like `a => a.books.reviews` and returns a hint like `{ books: { reviews: {} } }`. */
+declare function lensToLoadHint<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): LoadHint<T>;
+/** Accepts lens paths like `[books, reviews]` and returns a hint like `{ books: { reviews: {} } }`. */
+declare function lensPathToLoadHint<T extends Entity>(paths: string[]): LoadHint<T>;
+/** Accepts a lens like `a => a.books.reviews` and returns the paths like `[books, reviews]`. */
+declare function lensToPath<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): string[];
+//#endregion
+export { Lens, getLens, getLensPath, isAllSqlPaths, isLensLoaded, isLensLoadedPath, lensPathToLoadHint, lensToLoadHint, lensToPath, loadLens, loadLensPath, mapPathsToTarget };
+//# sourceMappingURL=loadLens.d.cts.map

package/build/loadLens.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.d.cts","names":[],"sources":["../src/loadLens.ts"],"mappings":";;;;;KAkBK,SAAS;EAAO,QAAQ,QAAQ;;;KAGhC,cAAc,WAAW,YAAY;;;;;;;;;;;;;KAiBrC,WAAW,GAAG,KACjB,UAAU,sBACL,YAAY,oBAAoB,MAC/B,cAAc,OACd,cAAc,OAChB,UAAU,qBACR,KACC,yBACC,gBACA;;KAKL,eAAe,KAAK,UAAU,oBAAoB,KAAK,IAAI;KAE3D,cAAc,KAAK,QAAQ;;;;;;;;;;KAWpB,KAAK,GAAG,IAAI,QACrB,WAAW,IAAI,EAAE,WAAW,eAAe,KACxC,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,EAAE,WAAW,oBAAoB,KAC/B,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,KAAK,eAAe,cAAc,EAAE,MAAM,WAAW,GAAG,EAAE;;;;;;;;;;iBAe5C,SAAS,UAAU,QAAQ,GAAG,GAClD,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,IAC/B;EAAQ;EAAuB;IAC9B,QAAQ;;iBAKK,aAAa,UAAU,QAAQ,GAC7C,OAAO,aAAa,KACpB,iBACA;EAAQ;EAAuB;IAC9B,QAAQ;iBA8FK,cAAc,MAAM,gBAAgB;iBAapC,iBAAiB,QAAQ,gBAAgB,mBAAmB,iBAAiB,gBAAgB;;;;;;iBAkC7F,QAAQ,GAAG,GAAG,GAC5B,WAAW,gBACX,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAC9B;;iBAKa,YAAY,GAAG,GAAG,WAAW,gBAAgB,OAAO,aAAa,KAAK,kBAAkB;;iBAqDxF,aAAa,GAAG,GAAG,GAAG,OAAO,aAAa,KAAK,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG;;iBAK9E,iBAAiB,GAAG,OAAO,aAAa,KAAK;;iBAgC7C,eAAe,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAAK,SAAS;;iBAKpF,mBAAmB,UAAU,QAAQ,kBAAkB,SAAS;;iBAUhE,WAAW,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG"}

package/build/loadLens.d.mts

@@ -0,0 +1,77 @@
+import { LoadHint } from "./loadHints.mjs";
+import { EntityMetadata, Field } from "./EntityMetadata.mjs";
+import { Entity } from "./Entity.mjs";
+//#region src/loadLens.d.ts
+/** Generically matches on a Reference/Collection's load method. */
+type LoadLike<U> = {
+  load(): Promise<U>;
+};
+/** Generically matches a property or zero-arg method that returns a promise. */
+type PromiseFnLike<U> = () => PromiseLike<U>;
+/**
+ * Given a parent type `R` (that is our current lens "return type", i.e. `Author` or `Author | undefined` or `Author[]`),
+ * and the type `V` of the "next step" of the traversal (i.e. itself `Book` or `Book | undefined` or `Book[]`, depending
+ * on the relation being traversed), returns `V` mapped to "the right format" based on `R`.
+ *
+ * I.e.:
+ *
+ * - `Author | undefined` that navigates a `Book` will become `Book | undefined`
+ * - `Author` that navigates a `Book | undefined` will also become `Book | undefined`
+ * - `Author[]` that navigates a `Book | undefined` will become a `Book[]`
+ * - `Author | undefined` that navigates a `Book[]` will become a `Book[]`
+ */
+type MaybeArray<R, V> = R extends ReadonlyArray<any> ? [V] extends [ReadonlyArray<infer U>] ? DropUndefined<U>[] : DropUndefined<V>[] : V extends ReadonlyArray<any> ? V : [R] extends [undefined] ? V | undefined : V;
+/** Given a type T that we come across in the path, de-array it to continue our flatMap-ish semantics. */
+type MaybeDropArray<T> = T extends ReadonlyArray<infer U> ? U : T;
+type DropUndefined<T> = Exclude<T, undefined>;
+/**
+ * A type for declaratively walking the object graph.
+ *
+ * This is not technically a Lens that can `get/set`, but the idea is generally the same.
+ *
+ * `T` is the type we're on, i.e. when `T = Author` we can do `.firstName` or `.lastName.
+ * `R` is either a `T` or `T[]` or `T | undefined` and just captures whether we've hit a
+ * list at any point in the lens navigation path.
+ */
+type Lens<T, R = T> = { [P in keyof T]: T[P] extends LoadLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : T[P] extends PromiseFnLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : Lens<MaybeDropArray<DropUndefined<T[P]>>, MaybeArray<R, T[P]>>; };
+/**
+ * Allows declaratively loading/traversing several layers of references at once.
+ *
+ * I.e.:
+ *
+ * ```typescript
+ * const publisher = await book.load(b => b.author.publisher);
+ * ```
+ */
+declare function loadLens<T extends Entity, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>, opts?: {
+  forceReload?: boolean;
+  sql?: boolean;
+}): Promise<V>;
+/** Loads a precomputed lens path, avoiding repeated lambda/proxy evaluation for long-lived relation declarations. */
+declare function loadLensPath<T extends Entity, V>(start: T | readonly T[], paths: string[], opts?: {
+  forceReload?: boolean;
+  sql?: boolean;
+}): Promise<V>;
+declare function isAllSqlPaths(meta: EntityMetadata, paths: string[]): boolean;
+declare function mapPathsToTarget(source: EntityMetadata, paths: string[]): [EntityMetadata, [EntityMetadata, Field][]];
+/**
+ * The synchronous version of `loadLens`.
+ *
+ * This assumes you've first evaluated the lens with `loadLens` and now can access it synchronously.
+ */
+declare function getLens<T, U, V>(startMeta: EntityMetadata, start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): V;
+/** Synchronously traverses a precomputed lens path. */
+declare function getLensPath<T, V>(startMeta: EntityMetadata, start: T | readonly T[], paths: string[]): V;
+/** Returns whether a lens is loaded; primarily for deeply loaded instances in tests. */
+declare function isLensLoaded<T, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): boolean;
+/** Returns whether a precomputed lens path is loaded; primarily for deeply loaded instances in tests. */
+declare function isLensLoadedPath<T>(start: T | readonly T[], paths: string[]): boolean;
+/** Accepts a lens like `a => a.books.reviews` and returns a hint like `{ books: { reviews: {} } }`. */
+declare function lensToLoadHint<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): LoadHint<T>;
+/** Accepts lens paths like `[books, reviews]` and returns a hint like `{ books: { reviews: {} } }`. */
+declare function lensPathToLoadHint<T extends Entity>(paths: string[]): LoadHint<T>;
+/** Accepts a lens like `a => a.books.reviews` and returns the paths like `[books, reviews]`. */
+declare function lensToPath<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): string[];
+//#endregion
+export { Lens, getLens, getLensPath, isAllSqlPaths, isLensLoaded, isLensLoadedPath, lensPathToLoadHint, lensToLoadHint, lensToPath, loadLens, loadLensPath, mapPathsToTarget };
+//# sourceMappingURL=loadLens.d.mts.map

package/build/loadLens.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.d.mts","names":[],"sources":["../src/loadLens.ts"],"mappings":";;;;;KAkBK,SAAS;EAAO,QAAQ,QAAQ;;;KAGhC,cAAc,WAAW,YAAY;;;;;;;;;;;;;KAiBrC,WAAW,GAAG,KACjB,UAAU,sBACL,YAAY,oBAAoB,MAC/B,cAAc,OACd,cAAc,OAChB,UAAU,qBACR,KACC,yBACC,gBACA;;KAKL,eAAe,KAAK,UAAU,oBAAoB,KAAK,IAAI;KAE3D,cAAc,KAAK,QAAQ;;;;;;;;;;KAWpB,KAAK,GAAG,IAAI,QACrB,WAAW,IAAI,EAAE,WAAW,eAAe,KACxC,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,EAAE,WAAW,oBAAoB,KAC/B,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,KAAK,eAAe,cAAc,EAAE,MAAM,WAAW,GAAG,EAAE;;;;;;;;;;iBAe5C,SAAS,UAAU,QAAQ,GAAG,GAClD,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,IAC/B;EAAQ;EAAuB;IAC9B,QAAQ;;iBAKK,aAAa,UAAU,QAAQ,GAC7C,OAAO,aAAa,KACpB,iBACA;EAAQ;EAAuB;IAC9B,QAAQ;iBA8FK,cAAc,MAAM,gBAAgB;iBAapC,iBAAiB,QAAQ,gBAAgB,mBAAmB,iBAAiB,gBAAgB;;;;;;iBAkC7F,QAAQ,GAAG,GAAG,GAC5B,WAAW,gBACX,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAC9B;;iBAKa,YAAY,GAAG,GAAG,WAAW,gBAAgB,OAAO,aAAa,KAAK,kBAAkB;;iBAqDxF,aAAa,GAAG,GAAG,GAAG,OAAO,aAAa,KAAK,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG;;iBAK9E,iBAAiB,GAAG,OAAO,aAAa,KAAK;;iBAgC7C,eAAe,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAAK,SAAS;;iBAKpF,mBAAmB,UAAU,QAAQ,kBAAkB,SAAS;;iBAUhE,WAAW,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG"}

package/build/loadLens.js

@@ -1,320 +1,202 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadLens = loadLens;
-exports.loadLensPath = loadLensPath;
-exports.isAllSqlPaths = isAllSqlPaths;
-exports.mapPathsToTarget = mapPathsToTarget;
-exports.getLens = getLens;
-exports.getLensPath = getLensPath;
-exports.isLensLoaded = isLensLoaded;
-exports.isLensLoadedPath = isLensLoadedPath;
-exports.lensToLoadHint = lensToLoadHint;
-exports.lensPathToLoadHint = lensPathToLoadHint;
-exports.lensToPath = lensToPath;
-const Entity_1 = require("./Entity");
-const EntityManager_1 = require("./EntityManager");
-const EntityMetadata_1 = require("./EntityMetadata");
-const lensDataLoader_1 = require("./dataloaders/lensDataLoader");
-const relations_1 = require("./relations");
-const AbstractRelationImpl_1 = require("./relations/AbstractRelationImpl");
+import { AbstractRelationImpl } from "./relations/AbstractRelationImpl.js";
+import { isProperty } from "./relations/hasProperty.js";
+import "./relations/index.js";
+import { getMetadata } from "./EntityMetadata.js";
+import "./loadHints.js";
+import { lensDataLoader } from "./dataloaders/lensDataLoader.js";
+import { appendStack } from "./EntityManager.js";
+import { isEntity } from "./Entity.js";
+//#region src/loadLens.ts
 /**
- * Allows declaratively loading/traversing several layers of references at once.
- *
- * I.e.:
- *
- * ```typescript
- * const publisher = await book.load(b => b.author.publisher);
- * ```
- */
-// For some reason accepting Lens<this, this> does not work when called from within the entity
-// subclass itself, so we use the codegen hammer in our subclass to force the right Lens type
-// in a .load stub that just calls us for the implementation.
+* Allows declaratively loading/traversing several layers of references at once.
+*
+* I.e.:
+*
+* ```typescript
+* const publisher = await book.load(b => b.author.publisher);
+* ```
+*/
 async function loadLens(start, fn, opts = {}) {
-    return loadLensPath(start, collectPaths(fn), opts);
+	return loadLensPath(start, collectPaths(fn), opts);
 }
 /** Loads a precomputed lens path, avoiding repeated lambda/proxy evaluation for long-lived relation declarations. */
 function loadLensPath(start, paths, opts = {}) {
-    // Probe for the meta, so we can track when/if it needs to flip to a collection (even after hitting undefined)
-    const meta = Array.isArray(start)
-        ? (0, Entity_1.isEntity)(start[0]) && (0, EntityMetadata_1.getMetadata)(start[0])
-        : (0, Entity_1.isEntity)(start) && (0, EntityMetadata_1.getMetadata)(start);
-    // This should only happen for `start=[]`, which we know should return `[]`
-    if (!meta)
-        return [];
-    // If we're already loaded, just return
-    if (!opts.forceReload && isLensLoadedPath(start, paths)) {
-        // Keep this synchronous to avoid adding a promise turn; this preserves nuanced hook timing in production code.
-        return getLensPath(meta, start, paths);
-    }
-    return loadLensPathAsync(meta, start, paths, opts);
+	const meta = Array.isArray(start) ? isEntity(start[0]) && getMetadata(start[0]) : isEntity(start) && getMetadata(start);
+	if (!meta) return [];
+	if (!opts.forceReload && isLensLoadedPath(start, paths)) return getLensPath(meta, start, paths);
+	return loadLensPathAsync(meta, start, paths, opts);
 }
 /**
- * Loads an unloaded lens path, keeping the already-loaded shortcut in `loadLensPath` synchronous.
- *
- * I.e. this avoids adding an extra promise turn for already-loaded paths during concurrent hooks.
- */
+* Loads an unloaded lens path, keeping the already-loaded shortcut in `loadLensPath` synchronous.
+*
+* I.e. this avoids adding an extra promise turn for already-loaded paths during concurrent hooks.
+*/
 async function loadLensPathAsync(meta, start, paths, opts) {
-    // See if we can load this via SQL
-    if (opts.sql) {
-        // Are all paths SQL query-able?
-        if (!isAllSqlPaths(meta, paths)) {
-            throw new Error("Cannot use loadLens opts.sql with non-SQL paths");
-        }
-        // If there is only 1 path, don't both with the fancy join
-        if (paths.length > 1) {
-            // TODO We can only do this is _none_ of the paths are loaded, otherwise we'll miss WIP mutations
-            if (isReadOnlyArray(start)) {
-                const em = start[0].em;
-                return (await (0, lensDataLoader_1.lensDataLoader)(em, meta.cstr, true, paths)
-                    .loadMany(start.map((e) => e.idTagged))
-                    .catch(function loadLens(err) {
-                    throw (0, EntityManager_1.appendStack)(err, new Error());
-                }));
-            }
-            else {
-                const em = start.em;
-                return (await (0, lensDataLoader_1.lensDataLoader)(em, meta.cstr, false, paths)
-                    .load(start.idTagged)
-                    .catch(function loadLens(err) {
-                    throw (0, EntityManager_1.appendStack)(err, new Error());
-                }));
-            }
-        }
-    }
-    // This could be `Entity | Entity[] | undefined` as we keep walking
-    let current = start;
-    let currentMeta = meta;
-    let seenSoftDeleted = false;
-    // Now evaluate each step of the path
-    for (const path of paths) {
-        const field = currentMeta?.allFields[path];
-        if (Array.isArray(current)) {
-            current = (await Promise.all(current.map((c) => maybeLoad(c, path, opts)))).flat();
-            current = [...new Set(current.filter((c) => c !== undefined && !c.isSoftDeletedEntity))];
-            // As soon as we hit `current=[]`, we can early return (...`current=undefined` cannot b/c the next path might flip to a list)
-            if (current.length === 0)
-                return current;
-        }
-        else if (current) {
-            current = await maybeLoad(current, path, opts);
-            seenSoftDeleted ||= current?.isSoftDeletedEntity;
-            // If we had been traversing m2o -> m2o (i.e. book -> author) and just hit an o2m/m2m (i.e.
-            // book -> author -> comments), and any of our prior m2os like `author` had been soft deleted,
-            // just filter everything out.
-            //
-            // Otherwise, we keep `book -> author`, even if author is soft-deleted, b/c it changes the return
-            // type from "author" to "author | undefined".
-            if (Array.isArray(current) && seenSoftDeleted) {
-                return [];
-            }
-        }
-        else {
-            // current is undefined; see if we should flip to a list ... which means we can early return
-            if (field?.kind === "o2m" || field?.kind === "m2m")
-                return [];
-        }
-        currentMeta = nextMeta(current, field);
-    }
-    return current;
+	if (opts.sql) {
+		if (!isAllSqlPaths(meta, paths)) throw new Error("Cannot use loadLens opts.sql with non-SQL paths");
+		if (paths.length > 1) {
+			if (isReadOnlyArray(start)) {
+				const em = start[0].em;
+				return await lensDataLoader(em, meta.cstr, true, paths).loadMany(start.map((e) => e.idTagged)).catch(function loadLens(err) {
+					throw appendStack(err, /* @__PURE__ */ new Error());
+				});
+			} else {
+				const em = start.em;
+				return await lensDataLoader(em, meta.cstr, false, paths).load(start.idTagged).catch(function loadLens(err) {
+					throw appendStack(err, /* @__PURE__ */ new Error());
+				});
+			}
+		}
+	}
+	let current = start;
+	let currentMeta = meta;
+	let seenSoftDeleted = false;
+	for (const path of paths) {
+		const field = currentMeta?.allFields[path];
+		if (Array.isArray(current)) {
+			current = (await Promise.all(current.map((c) => maybeLoad(c, path, opts)))).flat();
+			current = [...new Set(current.filter((c) => c !== void 0 && !c.isSoftDeletedEntity))];
+			if (current.length === 0) return current;
+		} else if (current) {
+			current = await maybeLoad(current, path, opts);
+			seenSoftDeleted ||= current?.isSoftDeletedEntity;
+			if (Array.isArray(current) && seenSoftDeleted) return [];
+		} else if (field?.kind === "o2m" || field?.kind === "m2m") return [];
+		currentMeta = nextMeta(current, field);
+	}
+	return current;
 }
 function isAllSqlPaths(meta, paths) {
-    for (let i = 0, current = meta; i < paths.length; i++) {
-        const next = current.allFields[paths[i]];
-        if (next && (next.kind === "m2o" || next.kind === "m2m" || next.kind === "o2m" || next.kind === "o2o")) {
-            current = next.otherMetadata();
-        }
-        else {
-            return false;
-        }
-    }
-    return true;
+	for (let i = 0, current = meta; i < paths.length; i++) {
+		const next = current.allFields[paths[i]];
+		if (next && (next.kind === "m2o" || next.kind === "m2m" || next.kind === "o2m" || next.kind === "o2o")) current = next.otherMetadata();
+		else return false;
+	}
+	return true;
 }
-// Given BookReview+[book, author] return [Author, books+bookReviews]
 function mapPathsToTarget(source, paths) {
-    let other = source;
-    let fields = [];
-    for (let i = 0; i < paths.length; i++) {
-        const next = other.allFields[paths[i]];
-        if (next && (next.kind === "m2o" || next.kind === "m2m" || next.kind === "o2m" || next.kind === "o2o")) {
-            other = next.otherMetadata();
-            fields.push([other, other.allFields[next.otherFieldName]]);
-        }
-        else {
-            throw new Error("Either not an all-SQL path or not supported yet");
-        }
-    }
-    return [other, fields.reverse()];
+	let other = source;
+	let fields = [];
+	for (let i = 0; i < paths.length; i++) {
+		const next = other.allFields[paths[i]];
+		if (next && (next.kind === "m2o" || next.kind === "m2m" || next.kind === "o2m" || next.kind === "o2o")) {
+			other = next.otherMetadata();
+			fields.push([other, other.allFields[next.otherFieldName]]);
+		} else throw new Error("Either not an all-SQL path or not supported yet");
+	}
+	return [other, fields.reverse()];
 }
 function maybeLoad(object, path, opts) {
-    if (object === undefined || object === null) {
-        return undefined;
-    }
-    const value = object[path];
-    if (value && typeof value === "object" && "load" in value) {
-        return value.load(opts);
-    }
-    else if (value && typeof value === "function") {
-        return value.apply(object);
-    }
-    else {
-        return value;
-    }
+	if (object === void 0 || object === null) return;
+	const value = object[path];
+	if (value && typeof value === "object" && "load" in value) return value.load(opts);
+	else if (value && typeof value === "function") return value.apply(object);
+	else return value;
 }
 /**
- * The synchronous version of `loadLens`.
- *
- * This assumes you've first evaluated the lens with `loadLens` and now can access it synchronously.
- */
+* The synchronous version of `loadLens`.
+*
+* This assumes you've first evaluated the lens with `loadLens` and now can access it synchronously.
+*/
 function getLens(startMeta, start, fn) {
-    return getLensPath(startMeta, start, collectPaths(fn));
+	return getLensPath(startMeta, start, collectPaths(fn));
 }
 /** Synchronously traverses a precomputed lens path. */
 function getLensPath(startMeta, start, paths) {
-    let currentMeta = startMeta;
-    let current = start;
-    let seenSoftDeleted = false;
-    // Now evaluate each step of the path
-    for (const path of paths) {
-        // We might navigate into properties, at which point we won't know the currentMeta
-        const field = currentMeta?.allFields[path];
-        if (Array.isArray(current)) {
-            // Use a set to dedup as we go
-            const next = new Set();
-            // This can be a hot path, so avoid `map` and `flat` and just loop
-            for (const c of current) {
-                const value = maybeGet(c, path);
-                if (Array.isArray(value))
-                    for (const v of value)
-                        maybeAdd(next, v);
-                else
-                    maybeAdd(next, value);
-            }
-            current = [...next];
-        }
-        else if (current) {
-            current = maybeGet(current, path);
-            seenSoftDeleted ||= current?.isSoftDeletedEntity;
-            // If we had been traversing m2o -> m2o and just hit an o2m/m2m, and any of our
-            // prior m2os had been soft-deleted, just filter everything out.
-            if (Array.isArray(current) && seenSoftDeleted) {
-                return [];
-            }
-        }
-        else {
-            // current is undefined; see if we should flip to a list ... which means we can early return
-            if (field?.kind === "o2m" || field?.kind === "m2m")
-                return [];
-        }
-        currentMeta = nextMeta(current, field);
-    }
-    return current;
+	let currentMeta = startMeta;
+	let current = start;
+	let seenSoftDeleted = false;
+	for (const path of paths) {
+		const field = currentMeta?.allFields[path];
+		if (Array.isArray(current)) {
+			const next = /* @__PURE__ */ new Set();
+			for (const c of current) {
+				const value = maybeGet(c, path);
+				if (Array.isArray(value)) for (const v of value) maybeAdd(next, v);
+				else maybeAdd(next, value);
+			}
+			current = [...next];
+		} else if (current) {
+			current = maybeGet(current, path);
+			seenSoftDeleted ||= current?.isSoftDeletedEntity;
+			if (Array.isArray(current) && seenSoftDeleted) return [];
+		} else if (field?.kind === "o2m" || field?.kind === "m2m") return [];
+		currentMeta = nextMeta(current, field);
+	}
+	return current;
 }
 /** Returns the next runtime metadata, preserving subtype-specific fields after base-typed traversals. */
 function nextMeta(current, field) {
-    const entity = Array.isArray(current) ? current[0] : current;
-    if ((0, Entity_1.isEntity)(entity))
-        return (0, EntityMetadata_1.getMetadata)(entity);
-    return field && "otherMetadata" in field ? field.otherMetadata() : undefined;
+	const entity = Array.isArray(current) ? current[0] : current;
+	if (isEntity(entity)) return getMetadata(entity);
+	return field && "otherMetadata" in field ? field.otherMetadata() : void 0;
 }
 function maybeAdd(set, value) {
-    if (value !== undefined && !value.isSoftDeletedEntity)
-        set.add(value);
+	if (value !== void 0 && !value.isSoftDeletedEntity) set.add(value);
 }
 /** Returns whether a lens is loaded; primarily for deeply loaded instances in tests. */
 function isLensLoaded(start, fn) {
-    return isLensLoadedPath(start, collectPaths(fn));
+	return isLensLoadedPath(start, collectPaths(fn));
 }
 /** Returns whether a precomputed lens path is loaded; primarily for deeply loaded instances in tests. */
 function isLensLoadedPath(start, paths) {
-    // This is a huge copy/paste of `getLens` but we check `isNotLoaded` and early return
-    // as soon as we find any not-loaded relation
-    let current = start;
-    let seenSoftDeleted = false;
-    // Now evaluate each step of the path
-    for (const path of paths) {
-        if (Array.isArray(current)) {
-            // Use a set to dedup as we go
-            const next = new Set();
-            for (const c of current) {
-                if (isNotLoaded(c, path))
-                    return false;
-                const value = maybeGet(c, path);
-                if (Array.isArray(value))
-                    for (const v of value)
-                        maybeAdd(next, v);
-                else
-                    maybeAdd(next, value);
-            }
-            current = [...next];
-        }
-        else {
-            if (isNotLoaded(current, path))
-                return false;
-            current = maybeGet(current, path);
-            seenSoftDeleted ||= current?.isSoftDeletedEntity;
-            // If we had been traversing m2o -> m2o and just hit an o2m/m2m, and any of our
-            // prior m2os had been soft deleted, just filter everything out.
-            if (Array.isArray(current) && seenSoftDeleted) {
-                return true;
-            }
-        }
-    }
-    return true;
+	let current = start;
+	let seenSoftDeleted = false;
+	for (const path of paths) if (Array.isArray(current)) {
+		const next = /* @__PURE__ */ new Set();
+		for (const c of current) {
+			if (isNotLoaded(c, path)) return false;
+			const value = maybeGet(c, path);
+			if (Array.isArray(value)) for (const v of value) maybeAdd(next, v);
+			else maybeAdd(next, value);
+		}
+		current = [...next];
+	} else {
+		if (isNotLoaded(current, path)) return false;
+		current = maybeGet(current, path);
+		seenSoftDeleted ||= current?.isSoftDeletedEntity;
+		if (Array.isArray(current) && seenSoftDeleted) return true;
+	}
+	return true;
 }
 /** Accepts a lens like `a => a.books.reviews` and returns a hint like `{ books: { reviews: {} } }`. */
 function lensToLoadHint(fn) {
-    return lensPathToLoadHint(collectPaths(fn));
+	return lensPathToLoadHint(collectPaths(fn));
 }
 /** Accepts lens paths like `[books, reviews]` and returns a hint like `{ books: { reviews: {} } }`. */
 function lensPathToLoadHint(paths) {
-    let current = {};
-    for (let i = paths.length - 1; i >= 0; i--) {
-        const path = paths[i];
-        current = { [path]: current };
-    }
-    return current;
+	let current = {};
+	for (let i = paths.length - 1; i >= 0; i--) current = { [paths[i]]: current };
+	return current;
 }
 /** Accepts a lens like `a => a.books.reviews` and returns the paths like `[books, reviews]`. */
 function lensToPath(fn) {
-    return [...collectPaths(fn)];
+	return [...collectPaths(fn)];
 }
 function isNotLoaded(object, path) {
-    const value = object && object[path];
-    if (value instanceof AbstractRelationImpl_1.AbstractRelationImpl || (0, relations_1.isProperty)(value)) {
-        return !value.isLoaded;
-    }
-    return false;
+	const value = object && object[path];
+	if (value instanceof AbstractRelationImpl || isProperty(value)) return !value.isLoaded;
+	return false;
 }
 function maybeGet(object, path) {
-    if (object === undefined || object === null) {
-        return undefined;
-    }
-    const value = object[path];
-    if (typeof value === "object" && "get" in value) {
-        return value.get;
-    }
-    else if (value && typeof value === "function") {
-        return value.apply(object);
-    }
-    else {
-        return value;
-    }
+	if (object === void 0 || object === null) return;
+	const value = object[path];
+	if (typeof value === "object" && "get" in value) return value.get;
+	else if (value && typeof value === "function") return value.apply(object);
+	else return value;
 }
 function collectPaths(fn) {
-    const paths = [];
-    // The proxy collects the path navigations that the user's `fn` lambda invokes.
-    const proxy = new Proxy({}, {
-        get(_, property, receiver) {
-            paths.push(String(property));
-            return receiver;
-        },
-    });
-    // Invoke the lens function to record the navigation path on our proxy
-    fn(proxy);
-    return paths;
+	const paths = [];
+	fn(new Proxy({}, { get(_, property, receiver) {
+		paths.push(String(property));
+		return receiver;
+	} }));
+	return paths;
 }
-// Work around https://github.com/microsoft/TypeScript/issues/17002
 function isReadOnlyArray(value) {
-    return Array.isArray(value);
+	return Array.isArray(value);
 }
+//#endregion
+export { getLens, getLensPath, isAllSqlPaths, isLensLoaded, isLensLoadedPath, lensPathToLoadHint, lensToLoadHint, lensToPath, loadLens, loadLensPath, mapPathsToTarget };
+
 //# sourceMappingURL=loadLens.js.map