joist-core 2.3.0 → 2.4.0

package/build/loading/loadHints.js

@@ -0,0 +1,88 @@
+import { getRelationFromMaybePolyKey } from "../reactivity/reactiveHints.js";
+import { fail } from "../utils.js";
+//#region src/loading/loadHints.ts
+/** Detects whether an entity is newly created, and so we can treat all the relations as loaded. */
+function isNew(e) {
+	return e.isNewEntity;
+}
+/** Recursively checks if the relations from a load hint are loaded on an entity. */
+function isLoaded(entity, hint) {
+	if (typeof hint === "string") return entity[hint].isLoaded;
+	else if (Array.isArray(hint)) {
+		for (const key of hint) if (!entity[key].isLoaded) return false;
+		return true;
+	} else if (typeof hint === "object") {
+		for (const entry of Object.entries(hint)) {
+			const [key, nestedHint] = entry;
+			const relation = getRelationFromMaybePolyKey(entity, key);
+			if (!relation || typeof relation.load !== "function") continue;
+			if (relation.isLoaded) {
+				const result = relation.get;
+				if (Array.isArray(result)) {
+					for (const entity of result) if (!isLoaded(entity, nestedHint)) return false;
+				} else if (result && !isLoaded(result, nestedHint)) return false;
+			} else return false;
+		}
+		return true;
+	} else throw new Error(`Unexpected hint ${hint}`);
+}
+/**
+* Recursively checks if a relation-only populate hint is loaded on an entity.
+*
+* Unlike `isLoaded`, this returns `false` for non-loadable/primitive leaves instead of ignoring them, because
+* `ReactiveField.load` calls `em.populate` with load hints converted from reactive hints, i.e. `{ firstName: {} }`.
+* Treating those primitive leaves as loaded would let `EntityManager.populate` skip the batchloader path and change
+* reactive recalculation ordering, so the populate fast-path only applies to true relation populate hints.
+*/
+function isLoadedForPopulate(entity, hint) {
+	if (typeof hint === "string") {
+		const relation = getRelationFromMaybePolyKey(entity, hint);
+		return !!relation && typeof relation.load === "function" && relation.isLoaded;
+	} else if (Array.isArray(hint)) {
+		for (const key of hint) if (!isLoadedForPopulate(entity, key)) return false;
+		return true;
+	} else if (typeof hint === "object") {
+		for (const entry of Object.entries(hint)) {
+			const [key, nestedHint] = entry;
+			const relation = getRelationFromMaybePolyKey(entity, key);
+			if (!relation || typeof relation.load !== "function" || !relation.isLoaded) return false;
+			const result = relation.get;
+			if (Array.isArray(result)) {
+				for (const entity of result) if (!isLoadedForPopulate(entity, nestedHint)) return false;
+			} else if (result && !isLoadedForPopulate(result, nestedHint)) return false;
+		}
+		return true;
+	} else throw new Error(`Unexpected hint ${hint}`);
+}
+function maybePopulateThen(entity, hint, fn) {
+	return isLoaded(entity, hint) ? fn(entity) : entity.populate(hint).then(fn);
+}
+/**
+* Runtime checks that `entity` has `hint` loaded, and type guards it as a `Loaded<T, hint>`.
+*
+* Similar to `ensureLoaded`, although `ensureLoaded` returns its value.
+*/
+function assertLoaded(entity, hint) {
+	if (!isLoaded(entity, hint)) fail(`${entity.id} is not loaded for ${JSON.stringify(hint)}`);
+}
+/**
+* Runtime checks that `entity` has `hint` loaded, and returns it as a `Loaded<T, entity>`.
+*
+* Similar to `assertLoaded`, although `assertLoaded` is a boolean type guard.
+*/
+function ensureLoaded(entity, hint) {
+	assertLoaded(entity, hint);
+	return entity;
+}
+/**
+* Unsafe type check for `entity` to `hint`, *without* a runtime type check.
+*
+* You should only use this if you're extremely sure that entity has hint loaded.
+*/
+function unsafeLoaded(entity, hint) {
+	return entity;
+}
+//#endregion
+export { assertLoaded, ensureLoaded, isLoaded, isLoadedForPopulate, isNew, maybePopulateThen, unsafeLoaded };
+
+//# sourceMappingURL=loadHints.js.map

package/build/loading/loadHints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadHints.js","names":[],"sources":["../../src/loading/loadHints.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport type { NormalizeHint } from \"src/normalizeHints.ts\";\nimport { getRelationFromMaybePolyKey } from \"src/reactivity/reactiveHints.ts\";\nimport type {\n  AsyncMethod,\n  Collection,\n  EnumCollection,\n  LoadedCollection,\n  LoadedEnumCollection,\n  LoadedMethod,\n  LoadedProperty,\n  LoadedReadOnlyCollection,\n  LoadedReference,\n  OneToOneReference,\n  Property,\n  ReadOnlyCollection,\n  Reference,\n  Relation,\n} from \"src/relations/index.ts\";\nimport type { LoadedOneToOneReference } from \"src/relations/OneToOneReference.ts\";\nimport type { OptsOf } from \"src/typeMap.ts\";\nimport { type MaybePromise, type NullOrDefinedOr, fail } from \"src/utils.ts\";\n\nconst deepLoad = Symbol();\ntype DeepLoadHint<T extends Entity> = NestedLoadHint<T> & { [deepLoad]: true };\n\n// Use any to correctly handle subtype/base type load hints.\n//\n// If a load hint is typed as `LoadHint<SmallPublisher, \"authors\">`, but the property\n// is actually `Publisher.authors`, if we do `P extends LoadedCollection<SmallPublisher, ...>`\n// the `SmallPublisher !== Publisher`, so the `authors` property doesn't match, and then\n// we drop the rest of the nested load hint.\n//\n// But if we check `P extends LoadedCollection<any, ...>` it works.\ntype MaybeBaseType = any;\n\n/** Marks a given `T[K]` field as the loaded/synchronous version of the collection. */\nexport type MarkLoaded<T extends Entity, P, UH = {}> =\n  P extends EnumCollection<MaybeBaseType, infer E>\n    ? LoadedEnumCollection<T, E>\n    : P extends OneToOneReference<MaybeBaseType, infer U>\n      ? LoadedOneToOneReference<T, Loaded<U, UH>>\n      : P extends Reference<MaybeBaseType, infer U, infer N>\n        ? LoadedReference<T, Loaded<U, UH>, N>\n        : P extends Collection<MaybeBaseType, infer U>\n          ? LoadedCollection<T, Loaded<U, UH>>\n          : P extends ReadOnlyCollection<MaybeBaseType, infer U>\n            ? LoadedReadOnlyCollection<T, Loaded<U, UH>>\n            : P extends Property<MaybeBaseType, infer V>\n              ? // prettier-ignore\n                [V] extends [(infer U extends Entity) | undefined]\n    ? LoadedProperty<T, Loaded<U, UH> | Exclude<V, U>>\n    : V extends readonly (infer U extends Entity)[]\n    ? LoadedProperty<T, Loaded<U, UH>[]>\n    : LoadedProperty<T, V>\n              : P extends AsyncMethod<T, infer A, infer V>\n                ? LoadedMethod<T, A, V>\n                : unknown;\n\n/** A version of MarkLoaded the uses `DeepLoadHint` for tests. */\ntype MarkDeepLoaded<T extends Entity, P> =\n  P extends EnumCollection<MaybeBaseType, infer E>\n    ? LoadedEnumCollection<T, E>\n    : P extends OneToOneReference<MaybeBaseType, infer U>\n      ? LoadedOneToOneReference<T, Loaded<U, DeepLoadHint<U>>>\n      : P extends Reference<MaybeBaseType, infer U, infer N>\n        ? LoadedReference<T, Loaded<U, DeepLoadHint<U>>, N>\n        : P extends Collection<MaybeBaseType, infer U>\n          ? LoadedCollection<T, Loaded<U, DeepLoadHint<U>>>\n          : P extends ReadOnlyCollection<MaybeBaseType, infer U>\n            ? LoadedReadOnlyCollection<T, Loaded<U, DeepLoadHint<U>>>\n            : P extends Property<MaybeBaseType, infer V>\n              ? // prettier-ignore\n                [V] extends [(infer U extends Entity) | undefined]\n    ? LoadedProperty<T, Loaded<U, DeepLoadHint<U>> | Exclude<V, U>>\n    : V extends readonly (infer U extends Entity)[]\n    ? LoadedProperty<T, Loaded<U, DeepLoadHint<U>>[]>\n    : LoadedProperty<T, V>\n              : P extends AsyncMethod<T, infer A, infer V>\n                ? LoadedMethod<T, A, V>\n                : unknown;\n\n/**\n * A helper type for `New` that marks every `Reference` and `LoadedCollection` in `T` as loaded.\n *\n * We also look in opts `O` for the \"`U`\" type, i.e. the next level up/down in the graph,\n * because the call site's opts may be using an also-marked loaded parent/child as an opt,\n * so this will infer the type of that parent/child and use that for the `U` type.\n *\n * This means things like `entity.parent.get.grandParent.get` will work on the resulting\n * type.\n *\n * Note that this is also purposefully broken out of `New` because of some weirdness\n * around type narrowing that wasn't working when inlined into `New`.\n */\ntype MaybeUseOptsType<T extends Entity, O, K extends keyof T & keyof O> =\n  O[K] extends NullOrDefinedOr<infer OK>\n    ? OK extends Entity\n      ? T[K] extends OneToOneReference<T, infer U>\n        ? LoadedOneToOneReference<T, U>\n        : T[K] extends Reference<T, infer U, infer N>\n          ? LoadedReference<T, OK, N>\n          : never\n      : OK extends Array<infer OU>\n        ? OU extends Entity\n          ? T[K] extends Collection<T, infer U>\n            ? LoadedCollection<T, OU>\n            : never\n          : T[K]\n        : T[K]\n    : never;\n\n/**\n * Marks all references/collections of `T` as loaded, i.e. for newly instantiated entities where\n * we know there are no already-existing rows with fk's to this new entity in the database.\n *\n * `O` is the generic from the call site so that if the caller passes `{ author: SomeLoadedAuthor }`,\n * we'll prefer that type, as it might have more nested load hints that we can't otherwise assume.\n */\nexport type New<T extends Entity, O extends OptsOf<T> = OptsOf<T>> = T & {\n  // K will be `keyof T` and `keyof O` for codegen'd relations, but custom relations\n  // line `hasOneThrough` and `hasOneDerived` will not pass `keyof O` and so use the\n  // `: MarkLoaded`.\n  //\n  // Note that the safest thing is to probably make this `: unknown` instead so that\n  // custom relations are not marked loaded, b/c they will very likely require a `.load`\n  // to work. However, we have some tests that currently expect `author.image.get` to work\n  // on a new author, so keeping the `MarkLoaded` behavior for now.\n  [K in keyof T]: K extends keyof O ? MaybeUseOptsType<T, O, K> : MarkLoaded<T, T[K]>;\n};\n\n/**\n * Marks all references/collections of `T` as deeply loaded, which is only useful for\n * tests where we can have \"the whole object graph\" in-memory.\n */\nexport type DeepNew<T extends Entity> = Loaded<T, DeepLoadHint<T>>;\n\n/** Detects whether an entity is newly created, and so we can treat all the relations as loaded. */\nexport function isNew<T extends Entity>(e: T): e is New<T> {\n  return e.isNewEntity;\n}\n\n/**\n * All the loadable fields, i.e. relations or lazy-loaded/async properties, in an entity.\n *\n * We use a mapped type (instead of a code-generated type) so that we can pick up custom\n * fields that have be added to the entity classes, i.e. `Author.numberOfBooks2` async\n * properties.\n */\nexport type Loadable<T extends Entity> = {\n  -readonly [K in keyof T as LoadableValue<T[K]> extends never ? never : K]: LoadableValue<T[K]>;\n};\n\n/**\n * Given an entity field/value, return the loadable entity.\n *\n * I.e. `Author.books` as a Reference or Collection, return `Book`.\n *\n * Note that we usually return entities, but for AsyncProperties it could be\n * a calculated primitive value like number or string.\n */\nexport type LoadableValue<V> =\n  V extends EnumCollection<any, infer E>\n    ? E\n    : V extends Reference<any, infer U, any>\n      ? U\n      : V extends Collection<any, infer U>\n        ? U\n        : V extends ReadOnlyCollection<any, infer U>\n          ? U\n          : V extends AsyncMethod<any, any, infer V>\n            ? V\n            : V extends Property<any, infer P>\n              ? // If the Property returns `Comment | undefined`, then we want to return `Comment`\n                // prettier-ignore\n                P extends (infer U extends Entity) | undefined ? U : P\n              : never;\n\n/**\n *  A load hint of a single key, multiple keys, or nested keys and sub-hints.\n *\n * Load hints are different from reactive hints in that load hints include only references,\n * collections, and async properties to preload (like `Book.author` or `Author.books`), and\n * do not include any primitive fields (like `Author.firstName`).\n */\nexport type LoadHint<T extends Entity> =\n  | (keyof Loadable<T> & string)\n  | ReadonlyArray<keyof Loadable<T> & string>\n  | NestedLoadHint<T>;\n\nexport type NestedLoadHint<T extends Entity> = {\n  // Don't filter out entity-loadable keys, because we need to support `{ numberOfBooks2: {} }`\n  [K in keyof Loadable<T>]?: Loadable<T>[K] extends infer U extends Entity ? LoadHint<U> : {};\n};\n\n/** Given an entity `T` that is being populated with hints `H`, marks the `H` attributes as populated. */\nexport type Loaded<T extends Entity, H> = T & {\n  [K in keyof T & keyof NormalizeHint<H>]: H extends DeepLoadHint<T>\n    ? MarkDeepLoaded<T, T[K]>\n    : MarkLoaded<T, T[K], NormalizeHint<H>[K]>;\n};\n\n/** Recursively checks if the relations from a load hint are loaded on an entity. */\nexport function isLoaded<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H> {\n  if (typeof hint === \"string\") {\n    return (entity as any)[hint].isLoaded;\n  } else if (Array.isArray(hint)) {\n    for (const key of hint as string[]) {\n      if (!(entity as any)[key].isLoaded) return false;\n    }\n    return true;\n  } else if (typeof hint === \"object\") {\n    for (const entry of Object.entries(hint as object)) {\n      const [key, nestedHint] = entry;\n      const relation = getRelationFromMaybePolyKey(entity, key);\n      if (!relation || typeof relation.load !== \"function\") continue;\n      if (relation.isLoaded) {\n        const result = relation.get;\n        if (Array.isArray(result)) {\n          for (const entity of result) {\n            if (!isLoaded(entity, nestedHint)) return false;\n          }\n        } else if (result && !isLoaded(result, nestedHint)) {\n          return false;\n        }\n      } else {\n        return false;\n      }\n    }\n    return true;\n  } else {\n    throw new Error(`Unexpected hint ${hint}`);\n  }\n}\n\n/**\n * Recursively checks if a relation-only populate hint is loaded on an entity.\n *\n * Unlike `isLoaded`, this returns `false` for non-loadable/primitive leaves instead of ignoring them, because\n * `ReactiveField.load` calls `em.populate` with load hints converted from reactive hints, i.e. `{ firstName: {} }`.\n * Treating those primitive leaves as loaded would let `EntityManager.populate` skip the batchloader path and change\n * reactive recalculation ordering, so the populate fast-path only applies to true relation populate hints.\n */\nexport function isLoadedForPopulate<T extends Entity, H extends LoadHint<T>>(\n  entity: T,\n  hint: H,\n): entity is Loaded<T, H> {\n  if (typeof hint === \"string\") {\n    const relation = getRelationFromMaybePolyKey(entity, hint);\n    return !!relation && typeof relation.load === \"function\" && relation.isLoaded;\n  } else if (Array.isArray(hint)) {\n    for (const key of hint as string[]) {\n      if (!isLoadedForPopulate(entity, key as H)) return false;\n    }\n    return true;\n  } else if (typeof hint === \"object\") {\n    for (const entry of Object.entries(hint as object)) {\n      const [key, nestedHint] = entry;\n      const relation = getRelationFromMaybePolyKey(entity, key);\n      if (!relation || typeof relation.load !== \"function\" || !relation.isLoaded) return false;\n      const result = relation.get;\n      if (Array.isArray(result)) {\n        for (const entity of result) {\n          if (!isLoadedForPopulate(entity, nestedHint as LoadHint<typeof entity>)) return false;\n        }\n      } else if (result && !isLoadedForPopulate(result, nestedHint as LoadHint<typeof result>)) {\n        return false;\n      }\n    }\n    return true;\n  } else {\n    throw new Error(`Unexpected hint ${hint}`);\n  }\n}\n\nexport function maybePopulateThen<T extends Entity, H extends LoadHint<T>, R>(\n  entity: T,\n  hint: H,\n  fn: (loaded: Loaded<T, H>) => R,\n): MaybePromise<R> {\n  return isLoaded(entity, hint) ? fn(entity) : (entity as any).populate(hint).then(fn);\n}\n\n/**\n * Runtime checks that `entity` has `hint` loaded, and type guards it as a `Loaded<T, hint>`.\n *\n * Similar to `ensureLoaded`, although `ensureLoaded` returns its value.\n */\nexport function assertLoaded<T extends Entity, const H extends LoadHint<T>>(\n  entity: T,\n  hint: H,\n): asserts entity is Loaded<T, H> {\n  if (!isLoaded(entity, hint)) fail(`${entity.id} is not loaded for ${JSON.stringify(hint)}`);\n}\n\n/**\n * Runtime checks that `entity` has `hint` loaded, and returns it as a `Loaded<T, entity>`.\n *\n * Similar to `assertLoaded`, although `assertLoaded` is a boolean type guard.\n */\nexport function ensureLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H> {\n  assertLoaded<T, H>(entity, hint);\n  return entity;\n}\n\n/**\n * Unsafe type check for `entity` to `hint`, *without* a runtime type check.\n *\n * You should only use this if you're extremely sure that entity has hint loaded.\n */\nexport function unsafeLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H> {\n  return entity as Loaded<T, H>;\n}\n\n/** From any `Relations` field in `T`, i.e. for loader hints. */\nexport type RelationsIn<T extends Entity> = SubType<T, Relation<any, any>>;\n\n// https://medium.com/dailyjs/typescript-create-a-condition-based-subset-types-9d902cea5b8c\ntype SubType<T, C> = Pick<T, { [K in keyof T]: T[K] extends C ? K : never }[keyof T]>;\n"],"mappings":";;;;AA0IA,SAAgB,MAAwB,GAAmB;CACzD,OAAO,EAAE;AACX;;AA+DA,SAAgB,SAAkD,QAAW,MAAiC;CAC5G,IAAI,OAAO,SAAS,UAClB,OAAQ,OAAe,KAAK,CAAC;MACxB,IAAI,MAAM,QAAQ,IAAI,GAAG;EAC9B,KAAK,MAAM,OAAO,MAChB,IAAI,CAAE,OAAe,IAAI,CAAC,UAAU,OAAO;EAE7C,OAAO;CACT,OAAO,IAAI,OAAO,SAAS,UAAU;EACnC,KAAK,MAAM,SAAS,OAAO,QAAQ,IAAc,GAAG;GAClD,MAAM,CAAC,KAAK,cAAc;GAC1B,MAAM,WAAW,4BAA4B,QAAQ,GAAG;GACxD,IAAI,CAAC,YAAY,OAAO,SAAS,SAAS,YAAY;GACtD,IAAI,SAAS,UAAU;IACrB,MAAM,SAAS,SAAS;IACxB,IAAI,MAAM,QAAQ,MAAM,GACjB;UAAA,MAAM,UAAU,QACnB,IAAI,CAAC,SAAS,QAAQ,UAAU,GAAG,OAAO;IAAA,OAEvC,IAAI,UAAU,CAAC,SAAS,QAAQ,UAAU,GAC/C,OAAO;GAEX,OACE,OAAO;EAEX;EACA,OAAO;CACT,OACE,MAAM,IAAI,MAAM,mBAAmB,MAAM;AAE7C;;;;;;;;;AAUA,SAAgB,oBACd,QACA,MACwB;CACxB,IAAI,OAAO,SAAS,UAAU;EAC5B,MAAM,WAAW,4BAA4B,QAAQ,IAAI;EACzD,OAAO,CAAC,CAAC,YAAY,OAAO,SAAS,SAAS,cAAc,SAAS;CACvE,OAAO,IAAI,MAAM,QAAQ,IAAI,GAAG;EAC9B,KAAK,MAAM,OAAO,MAChB,IAAI,CAAC,oBAAoB,QAAQ,GAAQ,GAAG,OAAO;EAErD,OAAO;CACT,OAAO,IAAI,OAAO,SAAS,UAAU;EACnC,KAAK,MAAM,SAAS,OAAO,QAAQ,IAAc,GAAG;GAClD,MAAM,CAAC,KAAK,cAAc;GAC1B,MAAM,WAAW,4BAA4B,QAAQ,GAAG;GACxD,IAAI,CAAC,YAAY,OAAO,SAAS,SAAS,cAAc,CAAC,SAAS,UAAU,OAAO;GACnF,MAAM,SAAS,SAAS;GACxB,IAAI,MAAM,QAAQ,MAAM,GACjB;SAAA,MAAM,UAAU,QACnB,IAAI,CAAC,oBAAoB,QAAQ,UAAqC,GAAG,OAAO;GAAA,OAE7E,IAAI,UAAU,CAAC,oBAAoB,QAAQ,UAAqC,GACrF,OAAO;EAEX;EACA,OAAO;CACT,OACE,MAAM,IAAI,MAAM,mBAAmB,MAAM;AAE7C;AAEA,SAAgB,kBACd,QACA,MACA,IACiB;CACjB,OAAO,SAAS,QAAQ,IAAI,IAAI,GAAG,MAAM,IAAK,OAAe,SAAS,IAAI,CAAC,CAAC,KAAK,EAAE;AACrF;;;;;;AAOA,SAAgB,aACd,QACA,MACgC;CAChC,IAAI,CAAC,SAAS,QAAQ,IAAI,GAAG,KAAK,GAAG,OAAO,GAAG,qBAAqB,KAAK,UAAU,IAAI,GAAG;AAC5F;;;;;;AAOA,SAAgB,aAA4D,QAAW,MAAuB;CAC5G,aAAmB,QAAQ,IAAI;CAC/B,OAAO;AACT;;;;;;AAOA,SAAgB,aAA4D,QAAW,MAAuB;CAC5G,OAAO;AACT"}

package/build/loading/loadLens.cjs

@@ -0,0 +1,212 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_AbstractRelationImpl = require("../relations/AbstractRelationImpl.cjs");
+const require_relations_hasProperty = require("../relations/hasProperty.cjs");
+require("../relations/index.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+const require_dataloaders_lensDataLoader = require("../dataloaders/lensDataLoader.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+const require_Entity = require("../Entity.cjs");
+//#region src/loading/loadLens.ts
+/**
+* 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);
+}
+/** Loads a precomputed lens path, avoiding repeated lambda/proxy evaluation for long-lived relation declarations. */
+function loadLensPath(start, paths, opts = {}) {
+	const meta = Array.isArray(start) ? require_Entity.isEntity(start[0]) && require_EntityMetadata.getMetadata(start[0]) : require_Entity.isEntity(start) && require_EntityMetadata.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.
+*/
+async function loadLensPathAsync(meta, start, paths, opts) {
+	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 require_dataloaders_lensDataLoader.lensDataLoader(em, meta.cstr, true, paths).loadMany(start.map((e) => e.idTagged)).catch(function loadLens(err) {
+					throw require_EntityManager.appendStack(err, /* @__PURE__ */ new Error());
+				});
+			} else {
+				const em = start.em;
+				return await require_dataloaders_lensDataLoader.lensDataLoader(em, meta.cstr, false, paths).load(start.idTagged).catch(function loadLens(err) {
+					throw require_EntityManager.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;
+}
+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()];
+}
+function maybeLoad(object, path, opts) {
+	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.
+*/
+function getLens(startMeta, start, 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;
+	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 (require_Entity.isEntity(entity)) return require_EntityMetadata.getMetadata(entity);
+	return field && "otherMetadata" in field ? field.otherMetadata() : void 0;
+}
+function maybeAdd(set, 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));
+}
+/** Returns whether a precomputed lens path is loaded; primarily for deeply loaded instances in tests. */
+function isLensLoadedPath(start, paths) {
+	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));
+}
+/** 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--) 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)];
+}
+function isNotLoaded(object, path) {
+	const value = object && object[path];
+	if (value instanceof require_relations_AbstractRelationImpl.AbstractRelationImpl || require_relations_hasProperty.isProperty(value)) return !value.isLoaded;
+	return false;
+}
+function maybeGet(object, path) {
+	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 = [];
+	fn(new Proxy({}, { get(_, property, receiver) {
+		paths.push(String(property));
+		return receiver;
+	} }));
+	return paths;
+}
+function isReadOnlyArray(value) {
+	return Array.isArray(value);
+}
+//#endregion
+exports.getLens = getLens;
+exports.getLensPath = getLensPath;
+exports.isAllSqlPaths = isAllSqlPaths;
+exports.isLensLoaded = isLensLoaded;
+exports.isLensLoadedPath = isLensLoadedPath;
+exports.lensPathToLoadHint = lensPathToLoadHint;
+exports.lensToLoadHint = lensToLoadHint;
+exports.lensToPath = lensToPath;
+exports.loadLens = loadLens;
+exports.loadLensPath = loadLensPath;
+exports.mapPathsToTarget = mapPathsToTarget;
+
+//# sourceMappingURL=loadLens.cjs.map

package/build/loading/loadLens.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.cjs","names":["isEntity","getMetadata","lensDataLoader","appendStack","AbstractRelationImpl","isProperty"],"sources":["../../src/loading/loadLens.ts"],"sourcesContent":["import { lensDataLoader } from \"src/dataloaders/lensDataLoader.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\nimport { appendStack } from \"src/EntityManager.ts\";\nimport {\n  type EntityMetadata,\n  type Field,\n  type ManyToManyField,\n  type ManyToOneField,\n  type OneToManyField,\n  type OneToOneField,\n  type PrimitiveField,\n  getMetadata,\n} from \"src/EntityMetadata.ts\";\nimport type { LoadHint } from \"src/loading/loadHints.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { isProperty } from \"src/relations/index.ts\";\n\n/** Generically matches on a Reference/Collection's load method. */\ntype LoadLike<U> = { load(): Promise<U> };\n\n/** Generically matches a property or zero-arg method that returns a promise. */\ntype PromiseFnLike<U> = () => PromiseLike<U>;\n\n/**\n * Given a parent type `R` (that is our current lens \"return type\", i.e. `Author` or `Author | undefined` or `Author[]`),\n * and the type `V` of the \"next step\" of the traversal (i.e. itself `Book` or `Book | undefined` or `Book[]`, depending\n * on the relation being traversed), returns `V` mapped to \"the right format\" based on `R`.\n *\n * I.e.:\n *\n * - `Author | undefined` that navigates a `Book` will become `Book | undefined`\n * - `Author` that navigates a `Book | undefined` will also become `Book | undefined`\n * - `Author[]` that navigates a `Book | undefined` will become a `Book[]`\n * - `Author | undefined` that navigates a `Book[]` will become a `Book[]`\n */\n// The extra `[]` around `V` and `ReadonlyArray<any>` are to keep the type as `Array<Foo | undefined>`\n// instead of `Foo[] | undefined[]`.\n// When `P extends ReadonlyArray, i.e. we're in flatMap mode, we're also in filter undefined mode.\ntype MaybeArray<R, V> =\n  R extends ReadonlyArray<any>\n    ? [V] extends [ReadonlyArray<infer U>]\n      ? DropUndefined<U>[]\n      : DropUndefined<V>[]\n    : V extends ReadonlyArray<any>\n      ? V\n      : [R] extends [undefined]\n        ? V | undefined\n        : V;\n\n// ([R] extends [undefined]) ? (V) : V;\n\n/** Given a type T that we come across in the path, de-array it to continue our flatMap-ish semantics. */\ntype MaybeDropArray<T> = T extends ReadonlyArray<infer U> ? U : T;\n\ntype DropUndefined<T> = Exclude<T, undefined>;\n\n/**\n * A type for declaratively walking the object graph.\n *\n * This is not technically a Lens that can `get/set`, but the idea is generally the same.\n *\n * `T` is the type we're on, i.e. when `T = Author` we can do `.firstName` or `.lastName.\n * `R` is either a `T` or `T[]` or `T | undefined` and just captures whether we've hit a\n * list at any point in the lens navigation path.\n */\nexport type Lens<T, R = T> = {\n  [P in keyof T]: T[P] extends LoadLike<infer U>\n    ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>>\n    : T[P] extends PromiseFnLike<infer U>\n      ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>>\n      : Lens<MaybeDropArray<DropUndefined<T[P]>>, MaybeArray<R, T[P]>>;\n};\n\n/**\n * Allows declaratively loading/traversing several layers of references at once.\n *\n * I.e.:\n *\n * ```typescript\n * const publisher = await book.load(b => b.author.publisher);\n * ```\n */\n// For some reason accepting Lens<this, this> does not work when called from within the entity\n// subclass itself, so we use the codegen hammer in our subclass to force the right Lens type\n// in a .load stub that just calls us for the implementation.\nexport async function loadLens<T extends Entity, U, V>(\n  start: T | readonly T[],\n  fn: (lens: Lens<T>) => Lens<U, V>,\n  opts: { forceReload?: boolean; sql?: boolean } = {},\n): Promise<V> {\n  return loadLensPath(start, collectPaths(fn), opts);\n}\n\n/** Loads a precomputed lens path, avoiding repeated lambda/proxy evaluation for long-lived relation declarations. */\nexport function loadLensPath<T extends Entity, V>(\n  start: T | readonly T[],\n  paths: string[],\n  opts: { forceReload?: boolean; sql?: boolean } = {},\n): Promise<V> {\n  // Probe for the meta, so we can track when/if it needs to flip to a collection (even after hitting undefined)\n  const meta = Array.isArray(start)\n    ? isEntity(start[0]) && getMetadata(start[0])\n    : isEntity(start) && getMetadata(start);\n  // This should only happen for `start=[]`, which we know should return `[]`\n  if (!meta) return [] as unknown as Promise<V>;\n\n  // If we're already loaded, just return\n  if (!opts.forceReload && isLensLoadedPath(start, paths)) {\n    // Keep this synchronous to avoid adding a promise turn; this preserves nuanced hook timing in production code.\n    return getLensPath(meta, start, paths) as Promise<V>;\n  }\n\n  return loadLensPathAsync(meta, start, paths, opts);\n}\n\n/**\n * Loads an unloaded lens path, keeping the already-loaded shortcut in `loadLensPath` synchronous.\n *\n * I.e. this avoids adding an extra promise turn for already-loaded paths during concurrent hooks.\n */\nasync function loadLensPathAsync<T extends Entity, V>(\n  meta: EntityMetadata,\n  start: T | readonly T[],\n  paths: string[],\n  opts: { forceReload?: boolean; sql?: boolean },\n): Promise<V> {\n  // See if we can load this via SQL\n  if (opts.sql) {\n    // Are all paths SQL query-able?\n    if (!isAllSqlPaths(meta, paths)) {\n      throw new Error(\"Cannot use loadLens opts.sql with non-SQL paths\");\n    }\n    // If there is only 1 path, don't both with the fancy join\n    if (paths.length > 1) {\n      // TODO We can only do this is _none_ of the paths are loaded, otherwise we'll miss WIP mutations\n      if (isReadOnlyArray(start)) {\n        const em = start[0].em;\n        return (await lensDataLoader(em, meta.cstr, true, paths)\n          .loadMany(start.map((e) => e.idTagged))\n          .catch(function loadLens(err) {\n            throw appendStack(err, new Error());\n          })) as V;\n      } else {\n        const em = start.em;\n        return (await lensDataLoader(em, meta.cstr, false, paths)\n          .load(start.idTagged)\n          .catch(function loadLens(err) {\n            throw appendStack(err, new Error());\n          })) as V;\n      }\n    }\n  }\n\n  // This could be `Entity | Entity[] | undefined` as we keep walking\n  let current: any = start;\n  let currentMeta: EntityMetadata | undefined = meta;\n  let seenSoftDeleted = false;\n  // Now evaluate each step of the path\n  for (const path of paths) {\n    const field = currentMeta?.allFields[path] as\n      | ManyToOneField\n      | ManyToManyField\n      | OneToManyField\n      | OneToOneField\n      | PrimitiveField\n      | undefined;\n    if (Array.isArray(current)) {\n      current = (await Promise.all(current.map((c) => maybeLoad(c, path, opts)))).flat();\n      current = [...new Set(current.filter((c: any) => c !== undefined && !c.isSoftDeletedEntity))];\n      // As soon as we hit `current=[]`, we can early return (...`current=undefined` cannot b/c the next path might flip to a list)\n      if (current.length === 0) return current!;\n    } else if (current) {\n      current = await maybeLoad(current, path, opts);\n      seenSoftDeleted ||= (current as any)?.isSoftDeletedEntity;\n      // If we had been traversing m2o -> m2o (i.e. book -> author) and just hit an o2m/m2m (i.e.\n      // book -> author -> comments), and any of our prior m2os like `author` had been soft deleted,\n      // just filter everything out.\n      //\n      // Otherwise, we keep `book -> author`, even if author is soft-deleted, b/c it changes the return\n      // type from \"author\" to \"author | undefined\".\n      if (Array.isArray(current) && seenSoftDeleted) {\n        return [] as any;\n      }\n    } else {\n      // current is undefined; see if we should flip to a list ... which means we can early return\n      if (field?.kind === \"o2m\" || field?.kind === \"m2m\") return [] as any;\n    }\n    currentMeta = nextMeta(current, field);\n  }\n  return current!;\n}\n\nexport function isAllSqlPaths(meta: EntityMetadata, paths: string[]): boolean {\n  for (let i = 0, current = meta; i < paths.length; i++) {\n    const next = current.allFields[paths[i]];\n    if (next && (next.kind === \"m2o\" || next.kind === \"m2m\" || next.kind === \"o2m\" || next.kind === \"o2o\")) {\n      current = next.otherMetadata();\n    } else {\n      return false;\n    }\n  }\n  return true;\n}\n\n// Given BookReview+[book, author] return [Author, books+bookReviews]\nexport function mapPathsToTarget(source: EntityMetadata, paths: string[]): [EntityMetadata, [EntityMetadata, Field][]] {\n  let other = source;\n  let fields: [EntityMetadata, Field][] = [];\n  for (let i = 0; i < paths.length; i++) {\n    const next = other.allFields[paths[i]];\n    if (next && (next.kind === \"m2o\" || next.kind === \"m2m\" || next.kind === \"o2m\" || next.kind === \"o2o\")) {\n      other = next.otherMetadata();\n      fields.push([other, other.allFields[next.otherFieldName]]);\n    } else {\n      throw new Error(\"Either not an all-SQL path or not supported yet\");\n    }\n  }\n  return [other, fields.reverse()];\n}\n\nfunction maybeLoad(object: any, path: string, opts: { forceReload?: boolean }): unknown {\n  if (object === undefined || object === null) {\n    return undefined;\n  }\n  const value = object[path];\n  if (value && typeof value === \"object\" && \"load\" in value) {\n    return value.load(opts);\n  } else if (value && typeof value === \"function\") {\n    return value.apply(object);\n  } else {\n    return value;\n  }\n}\n\n/**\n * The synchronous version of `loadLens`.\n *\n * This assumes you've first evaluated the lens with `loadLens` and now can access it synchronously.\n */\nexport function getLens<T, U, V>(\n  startMeta: EntityMetadata,\n  start: T | readonly T[],\n  fn: (lens: Lens<T>) => Lens<U, V>,\n): V {\n  return getLensPath(startMeta, start, collectPaths(fn));\n}\n\n/** Synchronously traverses a precomputed lens path. */\nexport function getLensPath<T, V>(startMeta: EntityMetadata, start: T | readonly T[], paths: string[]): V {\n  let currentMeta: EntityMetadata | undefined = startMeta;\n  let current: any = start;\n  let seenSoftDeleted = false;\n  // Now evaluate each step of the path\n  for (const path of paths) {\n    // We might navigate into properties, at which point we won't know the currentMeta\n    const field = currentMeta?.allFields[path] as\n      | ManyToOneField\n      | ManyToManyField\n      | OneToManyField\n      | OneToOneField\n      | PrimitiveField\n      | undefined;\n    if (Array.isArray(current)) {\n      // Use a set to dedup as we go\n      const next = new Set();\n      // This can be a hot path, so avoid `map` and `flat` and just loop\n      for (const c of current) {\n        const value = maybeGet(c, path);\n        if (Array.isArray(value)) for (const v of value) maybeAdd(next, v);\n        else maybeAdd(next, value);\n      }\n      current = [...next];\n    } else if (current) {\n      current = maybeGet(current, path);\n      seenSoftDeleted ||= (current as any)?.isSoftDeletedEntity;\n      // If we had been traversing m2o -> m2o and just hit an o2m/m2m, and any of our\n      // prior m2os had been soft-deleted, just filter everything out.\n      if (Array.isArray(current) && seenSoftDeleted) {\n        return [] as any;\n      }\n    } else {\n      // current is undefined; see if we should flip to a list ... which means we can early return\n      if (field?.kind === \"o2m\" || field?.kind === \"m2m\") return [] as any;\n    }\n    currentMeta = nextMeta(current, field);\n  }\n  return current!;\n}\n\n/** Returns the next runtime metadata, preserving subtype-specific fields after base-typed traversals. */\nfunction nextMeta(current: unknown, field: Field | undefined): EntityMetadata | undefined {\n  const entity = Array.isArray(current) ? current[0] : current;\n  if (isEntity(entity)) return getMetadata(entity);\n  return field && \"otherMetadata\" in field ? field.otherMetadata() : undefined;\n}\n\nfunction maybeAdd(set: Set<any>, value: any) {\n  if (value !== undefined && !value.isSoftDeletedEntity) set.add(value);\n}\n\n/** Returns whether a lens is loaded; primarily for deeply loaded instances in tests. */\nexport function isLensLoaded<T, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): boolean {\n  return isLensLoadedPath(start, collectPaths(fn));\n}\n\n/** Returns whether a precomputed lens path is loaded; primarily for deeply loaded instances in tests. */\nexport function isLensLoadedPath<T>(start: T | readonly T[], paths: string[]): boolean {\n  // This is a huge copy/paste of `getLens` but we check `isNotLoaded` and early return\n  // as soon as we find any not-loaded relation\n  let current: any = start;\n  let seenSoftDeleted = false;\n  // Now evaluate each step of the path\n  for (const path of paths) {\n    if (Array.isArray(current)) {\n      // Use a set to dedup as we go\n      const next = new Set();\n      for (const c of current) {\n        if (isNotLoaded(c, path)) return false;\n        const value = maybeGet(c, path);\n        if (Array.isArray(value)) for (const v of value) maybeAdd(next, v);\n        else maybeAdd(next, value);\n      }\n      current = [...next];\n    } else {\n      if (isNotLoaded(current, path)) return false;\n      current = maybeGet(current, path);\n      seenSoftDeleted ||= (current as any)?.isSoftDeletedEntity;\n      // If we had been traversing m2o -> m2o and just hit an o2m/m2m, and any of our\n      // prior m2os had been soft deleted, just filter everything out.\n      if (Array.isArray(current) && seenSoftDeleted) {\n        return true;\n      }\n    }\n  }\n  return true;\n}\n\n/** Accepts a lens like `a => a.books.reviews` and returns a hint like `{ books: { reviews: {} } }`. */\nexport function lensToLoadHint<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): LoadHint<T> {\n  return lensPathToLoadHint(collectPaths(fn));\n}\n\n/** Accepts lens paths like `[books, reviews]` and returns a hint like `{ books: { reviews: {} } }`. */\nexport function lensPathToLoadHint<T extends Entity>(paths: string[]): LoadHint<T> {\n  let current = {};\n  for (let i = paths.length - 1; i >= 0; i--) {\n    const path = paths[i];\n    current = { [path]: current };\n  }\n  return current as LoadHint<T>;\n}\n\n/** Accepts a lens like `a => a.books.reviews` and returns the paths like `[books, reviews]`. */\nexport function lensToPath<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): string[] {\n  return [...collectPaths(fn)];\n}\n\nfunction isNotLoaded(object: any, path: string): boolean {\n  const value = object && object[path];\n  if (value instanceof AbstractRelationImpl || isProperty(value)) {\n    return !value.isLoaded;\n  }\n  return false;\n}\n\nfunction maybeGet(object: any, path: string): unknown {\n  if (object === undefined || object === null) {\n    return undefined;\n  }\n  const value = object[path];\n  if (typeof value === \"object\" && \"get\" in value) {\n    return value.get;\n  } else if (value && typeof value === \"function\") {\n    return value.apply(object);\n  } else {\n    return value;\n  }\n}\n\nfunction collectPaths(fn: Function): string[] {\n  const paths: string[] = [];\n  // The proxy collects the path navigations that the user's `fn` lambda invokes.\n  const proxy = new Proxy(\n    {},\n    {\n      get(_, property, receiver) {\n        paths.push(String(property));\n        return receiver;\n      },\n    },\n  );\n  // Invoke the lens function to record the navigation path on our proxy\n  fn(proxy as any);\n  return paths;\n}\n\n// Work around https://github.com/microsoft/TypeScript/issues/17002\nfunction isReadOnlyArray<T>(value: T | readonly T[]): value is readonly T[] {\n  return Array.isArray(value);\n}\n"],"mappings":"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"}

package/build/loading/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/loading/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/loading/loadLens.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.d.cts","names":[],"sources":["../../src/loading/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/loading/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/loading/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/loading/loadLens.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.d.mts","names":[],"sources":["../../src/loading/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"}