joist-core 2.3.0 → 2.4.0

package/build/loading/loadLens.js

@@ -0,0 +1,201 @@
+import { AbstractRelationImpl } from "../relations/AbstractRelationImpl.js";
+import { isProperty } from "../relations/hasProperty.js";
+import "../relations/index.js";
+import { getMetadata } from "../EntityMetadata.js";
+import { lensDataLoader } from "../dataloaders/lensDataLoader.js";
+import { appendStack } from "../EntityManager.js";
+import { isEntity } from "../Entity.js";
+//#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) ? 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.
+*/
+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 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;
+}
+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 (isEntity(entity)) return 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 AbstractRelationImpl || 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
+export { getLens, getLensPath, isAllSqlPaths, isLensLoaded, isLensLoadedPath, lensPathToLoadHint, lensToLoadHint, lensToPath, loadLens, loadLensPath, mapPathsToTarget };
+
+//# sourceMappingURL=loadLens.js.map

package/build/loading/loadLens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadLens.js","names":[],"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/withLoaded.cjs

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_Collection = require("../relations/Collection.cjs");
+const require_relations_ReactiveGetter = require("../relations/ReactiveGetter.cjs");
+const require_relations_Relation = require("../relations/Relation.cjs");
+const require_loading_loadHints = require("./loadHints.cjs");
+const require_relations_hasProperty = require("../relations/hasProperty.cjs");
+const require_relations_Reference = require("../relations/Reference.cjs");
+const require_relations_ReactiveField = require("../relations/ReactiveField.cjs");
+const require_relations_AsyncReactiveField = require("../relations/AsyncReactiveField.cjs");
+require("../relations/index.cjs");
+const require_utils = require("../utils.cjs");
+//#region src/loading/withLoaded.ts
+function withLoaded(loadedOrPromise) {
+	return require_utils.maybePromiseThen(loadedOrPromise, (loaded) => new Proxy(loaded, { get: (target, prop) => {
+		const value = target[prop];
+		if (require_relations_Relation.isRelation(value) || require_relations_hasProperty.isProperty(value) || require_relations_ReactiveField.isReactiveField(value) || require_relations_ReactiveGetter.isReactiveGetter(value) || require_relations_AsyncReactiveField.isAsyncReactiveField(value)) return require_relations_Reference.isLoadedReference(value) || require_relations_Collection.isLoadedCollection(value) || require_relations_hasProperty.isLoadedProperty(value) || require_relations_ReactiveField.isReactiveField(value) || require_relations_AsyncReactiveField.isLoadedAsyncReactiveField(value) || require_relations_ReactiveGetter.isReactiveGetter(value) ? value.get : require_utils.fail(`${target}.${String(prop)} is not loaded`);
+		else if (value instanceof StubbedRelation) return value.get;
+		else return value;
+	} }));
+}
+function ensureWithLoaded(entity, hint) {
+	require_loading_loadHints.assertLoaded(entity, hint);
+	return withLoaded(entity);
+}
+/**
+* Allow stubbing of relations with dummy values.
+*
+* In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful
+* to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m
+* .load/.isLoaded/.get code paths.
+*
+* We'd originally done some of this by poking relation internal implementation details, but
+* using private fields like `#loaded` breaks that, and it was brittle anyway.
+*
+* So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:
+*
+* ```
+* // Force `author.books` to always be `[]` and never load.
+* Object.defineProperty(author, "books", {
+*   get: () => new StubbedRelation([]),
+*  });
+* ```
+*/
+var StubbedRelation = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+	get get() {
+		return this.value;
+	}
+	get isLoaded() {
+		return true;
+	}
+	load() {
+		return this.get;
+	}
+};
+//#endregion
+exports.StubbedRelation = StubbedRelation;
+exports.ensureWithLoaded = ensureWithLoaded;
+exports.withLoaded = withLoaded;
+
+//# sourceMappingURL=withLoaded.cjs.map

package/build/loading/withLoaded.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLoaded.cjs","names":["maybePromiseThen","isRelation","isProperty","isReactiveField","isReactiveGetter","isAsyncReactiveField","isLoadedReference","isLoadedCollection","isLoadedProperty","isLoadedAsyncReactiveField","fail"],"sources":["../../src/loading/withLoaded.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"src/loading/loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"src/relations/AsyncReactiveField.ts\";\nimport {\n  type LoadedCollection,\n  type LoadedProperty,\n  type LoadedReadOnlyCollection,\n  type LoadedReference,\n  type PolymorphicReference,\n  type Property,\n  type Relation,\n  isAsyncReactiveField,\n  isLoadedCollection,\n  isLoadedProperty,\n  isLoadedReference,\n  isProperty,\n  isReactiveField,\n  isReactiveGetter,\n  isRelation,\n} from \"src/relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"src/utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = {\n  [\n    K in keyof L as L[K] extends { get: unknown } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K\n  ]: L[K] extends PolymorphicReference<T, infer U, infer N>\n    ? L[K] extends LoadedReference<T, U, N>\n      ? U | N\n      : L[K]\n    : L[K] extends LoadedReference<T, infer U, never>\n      ? U\n      : L[K] extends LoadedReference<T, infer U, undefined>\n        ? U | undefined\n        : L[K] extends LoadedCollection<T, infer U>\n          ? U[]\n          : L[K] extends LoadedReadOnlyCollection<T, infer U>\n            ? // leaving out `readonly U[]` until we're ready to switch\n              U[]\n            : L[K] extends LoadedProperty<T, infer V>\n              ? V\n              : L[K];\n};\n\n/**\n * Allows destructuring against entities to more succinctly access loaded relations.\n *\n * ```typescript\n * // Instead of\n * const author = book.author.get;\n * // Use withLoaded\n * const { author } = withLoaded(book);\n * ```\n *\n * Granted, when accessing one property, this is not a win, but if you're accessing\n * ~3-4 separate loaded properties, then it can be more succinct than using `get`s\n * for each one.\n *\n * This function returns a proxy to an entity, instead of a real entity, and as such its return\n * value should only be used as part of a destructure and never directly assigned to a variable.\n *\n * This is also why the function is not recursive, as returning nested proxies could result in\n * them inadvertently being stored and passed to code that expects a real entity.\n */\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  promise: Promise<L>,\n): Promise<WithLoaded<T, H, L>>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loaded: L,\n): WithLoaded<T, H, L>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loadedOrPromise: MaybePromise<L> | L,\n): MaybePromise<WithLoaded<T, H, L>> {\n  return maybePromiseThen(\n    loadedOrPromise,\n    (loaded) =>\n      new Proxy(loaded, {\n        get: (target, prop) => {\n          const value: any = (target as any)[prop];\n          if (\n            isRelation(value) ||\n            isProperty(value) ||\n            isReactiveField(value) ||\n            isReactiveGetter(value) ||\n            isAsyncReactiveField(value)\n          ) {\n            return isLoadedReference(value) ||\n              isLoadedCollection(value) ||\n              isLoadedProperty(value) ||\n              isReactiveField(value) ||\n              isLoadedAsyncReactiveField(value) ||\n              isReactiveGetter(value)\n              ? value.get\n              : fail(`${target}.${String(prop)} is not loaded`);\n          } else if (value instanceof StubbedRelation) {\n            return value.get;\n          } else {\n            return value;\n          }\n        },\n      }) as WithLoaded<T, H, L>,\n  );\n}\n\nexport function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(\n  entity: T,\n  hint: H,\n): WithLoaded<T, H, Loaded<T, H>> {\n  assertLoaded<T, H>(entity, hint);\n  return withLoaded(entity);\n}\n\n/**\n * Allow stubbing of relations with dummy values.\n *\n * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful\n * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m\n * .load/.isLoaded/.get code paths.\n *\n * We'd originally done some of this by poking relation internal implementation details, but\n * using private fields like `#loaded` breaks that, and it was brittle anyway.\n *\n * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:\n *\n * ```\n * // Force `author.books` to always be `[]` and never load.\n * Object.defineProperty(author, \"books\", {\n *   get: () => new StubbedRelation([]),\n *  });\n * ```\n */\nexport class StubbedRelation {\n  constructor(private value: any) {}\n\n  get get() {\n    return this.value;\n  }\n\n  get isLoaded() {\n    return true;\n  }\n\n  load() {\n    return this.get;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAuEA,SAAgB,WACd,iBACmC;CACnC,OAAOA,cAAAA,iBACL,kBACC,WACC,IAAI,MAAM,QAAQ,EAChB,MAAM,QAAQ,SAAS;EACrB,MAAM,QAAc,OAAe;EACnC,IACEC,2BAAAA,WAAW,KAAK,KAChBC,8BAAAA,WAAW,KAAK,KAChBC,gCAAAA,gBAAgB,KAAK,KACrBC,iCAAAA,iBAAiB,KAAK,KACtBC,qCAAAA,qBAAqB,KAAK,GAE1B,OAAOC,4BAAAA,kBAAkB,KAAK,KAC5BC,6BAAAA,mBAAmB,KAAK,KACxBC,8BAAAA,iBAAiB,KAAK,KACtBL,gCAAAA,gBAAgB,KAAK,KACrBM,qCAAAA,2BAA2B,KAAK,KAChCL,iCAAAA,iBAAiB,KAAK,IACpB,MAAM,MACNM,cAAAA,KAAK,GAAG,OAAO,GAAG,OAAO,IAAI,EAAE,eAAe;OAC7C,IAAI,iBAAiB,iBAC1B,OAAO,MAAM;OAEb,OAAO;CAEX,EACF,CAAC,CACL;AACF;AAEA,SAAgB,iBACd,QACA,MACgC;CAChC,0BAAA,aAAmB,QAAQ,IAAI;CAC/B,OAAO,WAAW,MAAM;AAC1B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,kBAAb,MAA6B;CACP;CAApB,YAAY,OAAoB;EAAZ,KAAA,QAAA;CAAa;CAEjC,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CAEA,IAAI,WAAW;EACb,OAAO;CACT;CAEA,OAAO;EACL,OAAO,KAAK;CACd;AACF"}

package/build/loading/withLoaded.d.cts

@@ -0,0 +1,65 @@
+import { LoadedCollection } from "../relations/Collection.cjs";
+import { LoadedProperty, Property } from "../relations/hasProperty.cjs";
+import { LoadedReference } from "../relations/Reference.cjs";
+import { Relation } from "../relations/Relation.cjs";
+import { PolymorphicReference } from "../relations/PolymorphicReference.cjs";
+import { LoadedReadOnlyCollection } from "../relations/ReadOnlyCollection.cjs";
+import "../relations/index.cjs";
+import { LoadHint, Loaded } from "./loadHints.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/loading/withLoaded.d.ts
+type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
+  get: unknown;
+} ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K]: L[K] extends PolymorphicReference<T, infer U, infer N> ? L[K] extends LoadedReference<T, U, N> ? U | N : L[K] : L[K] extends LoadedReference<T, infer U, never> ? U : L[K] extends LoadedReference<T, infer U, undefined> ? U | undefined : L[K] extends LoadedCollection<T, infer U> ? U[] : L[K] extends LoadedReadOnlyCollection<T, infer U> ? U[] : L[K] extends LoadedProperty<T, infer V> ? V : L[K]; };
+/**
+ * Allows destructuring against entities to more succinctly access loaded relations.
+ *
+ * ```typescript
+ * // Instead of
+ * const author = book.author.get;
+ * // Use withLoaded
+ * const { author } = withLoaded(book);
+ * ```
+ *
+ * Granted, when accessing one property, this is not a win, but if you're accessing
+ * ~3-4 separate loaded properties, then it can be more succinct than using `get`s
+ * for each one.
+ *
+ * This function returns a proxy to an entity, instead of a real entity, and as such its return
+ * value should only be used as part of a destructure and never directly assigned to a variable.
+ *
+ * This is also why the function is not recursive, as returning nested proxies could result in
+ * them inadvertently being stored and passed to code that expects a real entity.
+ */
+declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(promise: Promise<L>): Promise<WithLoaded<T, H, L>>;
+declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(loaded: L): WithLoaded<T, H, L>;
+declare function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): WithLoaded<T, H, Loaded<T, H>>;
+/**
+ * Allow stubbing of relations with dummy values.
+ *
+ * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful
+ * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m
+ * .load/.isLoaded/.get code paths.
+ *
+ * We'd originally done some of this by poking relation internal implementation details, but
+ * using private fields like `#loaded` breaks that, and it was brittle anyway.
+ *
+ * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:
+ *
+ * ```
+ * // Force `author.books` to always be `[]` and never load.
+ * Object.defineProperty(author, "books", {
+ *   get: () => new StubbedRelation([]),
+ *  });
+ * ```
+ */
+declare class StubbedRelation {
+  private value;
+  constructor(value: any);
+  get get(): any;
+  get isLoaded(): boolean;
+  load(): any;
+}
+//#endregion
+export { StubbedRelation, WithLoaded, ensureWithLoaded, withLoaded };
+//# sourceMappingURL=withLoaded.d.cts.map

package/build/loading/withLoaded.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLoaded.d.cts","names":[],"sources":["../../src/loading/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}

package/build/loading/withLoaded.d.mts

@@ -0,0 +1,65 @@
+import { LoadedCollection } from "../relations/Collection.mjs";
+import { LoadedProperty, Property } from "../relations/hasProperty.mjs";
+import { LoadedReference } from "../relations/Reference.mjs";
+import { Relation } from "../relations/Relation.mjs";
+import { PolymorphicReference } from "../relations/PolymorphicReference.mjs";
+import { LoadedReadOnlyCollection } from "../relations/ReadOnlyCollection.mjs";
+import "../relations/index.mjs";
+import { LoadHint, Loaded } from "./loadHints.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/loading/withLoaded.d.ts
+type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
+  get: unknown;
+} ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K]: L[K] extends PolymorphicReference<T, infer U, infer N> ? L[K] extends LoadedReference<T, U, N> ? U | N : L[K] : L[K] extends LoadedReference<T, infer U, never> ? U : L[K] extends LoadedReference<T, infer U, undefined> ? U | undefined : L[K] extends LoadedCollection<T, infer U> ? U[] : L[K] extends LoadedReadOnlyCollection<T, infer U> ? U[] : L[K] extends LoadedProperty<T, infer V> ? V : L[K]; };
+/**
+ * Allows destructuring against entities to more succinctly access loaded relations.
+ *
+ * ```typescript
+ * // Instead of
+ * const author = book.author.get;
+ * // Use withLoaded
+ * const { author } = withLoaded(book);
+ * ```
+ *
+ * Granted, when accessing one property, this is not a win, but if you're accessing
+ * ~3-4 separate loaded properties, then it can be more succinct than using `get`s
+ * for each one.
+ *
+ * This function returns a proxy to an entity, instead of a real entity, and as such its return
+ * value should only be used as part of a destructure and never directly assigned to a variable.
+ *
+ * This is also why the function is not recursive, as returning nested proxies could result in
+ * them inadvertently being stored and passed to code that expects a real entity.
+ */
+declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(promise: Promise<L>): Promise<WithLoaded<T, H, L>>;
+declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(loaded: L): WithLoaded<T, H, L>;
+declare function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): WithLoaded<T, H, Loaded<T, H>>;
+/**
+ * Allow stubbing of relations with dummy values.
+ *
+ * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful
+ * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m
+ * .load/.isLoaded/.get code paths.
+ *
+ * We'd originally done some of this by poking relation internal implementation details, but
+ * using private fields like `#loaded` breaks that, and it was brittle anyway.
+ *
+ * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:
+ *
+ * ```
+ * // Force `author.books` to always be `[]` and never load.
+ * Object.defineProperty(author, "books", {
+ *   get: () => new StubbedRelation([]),
+ *  });
+ * ```
+ */
+declare class StubbedRelation {
+  private value;
+  constructor(value: any);
+  get get(): any;
+  get isLoaded(): boolean;
+  load(): any;
+}
+//#endregion
+export { StubbedRelation, WithLoaded, ensureWithLoaded, withLoaded };
+//# sourceMappingURL=withLoaded.d.mts.map

package/build/loading/withLoaded.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLoaded.d.mts","names":[],"sources":["../../src/loading/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}

package/build/loading/withLoaded.js

@@ -0,0 +1,61 @@
+import { isLoadedCollection } from "../relations/Collection.js";
+import { isReactiveGetter } from "../relations/ReactiveGetter.js";
+import { isRelation } from "../relations/Relation.js";
+import { assertLoaded } from "./loadHints.js";
+import { isLoadedProperty, isProperty } from "../relations/hasProperty.js";
+import { isLoadedReference } from "../relations/Reference.js";
+import { isReactiveField } from "../relations/ReactiveField.js";
+import { isAsyncReactiveField, isLoadedAsyncReactiveField } from "../relations/AsyncReactiveField.js";
+import "../relations/index.js";
+import { fail, maybePromiseThen } from "../utils.js";
+//#region src/loading/withLoaded.ts
+function withLoaded(loadedOrPromise) {
+	return maybePromiseThen(loadedOrPromise, (loaded) => new Proxy(loaded, { get: (target, prop) => {
+		const value = target[prop];
+		if (isRelation(value) || isProperty(value) || isReactiveField(value) || isReactiveGetter(value) || isAsyncReactiveField(value)) return isLoadedReference(value) || isLoadedCollection(value) || isLoadedProperty(value) || isReactiveField(value) || isLoadedAsyncReactiveField(value) || isReactiveGetter(value) ? value.get : fail(`${target}.${String(prop)} is not loaded`);
+		else if (value instanceof StubbedRelation) return value.get;
+		else return value;
+	} }));
+}
+function ensureWithLoaded(entity, hint) {
+	assertLoaded(entity, hint);
+	return withLoaded(entity);
+}
+/**
+* Allow stubbing of relations with dummy values.
+*
+* In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful
+* to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m
+* .load/.isLoaded/.get code paths.
+*
+* We'd originally done some of this by poking relation internal implementation details, but
+* using private fields like `#loaded` breaks that, and it was brittle anyway.
+*
+* So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:
+*
+* ```
+* // Force `author.books` to always be `[]` and never load.
+* Object.defineProperty(author, "books", {
+*   get: () => new StubbedRelation([]),
+*  });
+* ```
+*/
+var StubbedRelation = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+	get get() {
+		return this.value;
+	}
+	get isLoaded() {
+		return true;
+	}
+	load() {
+		return this.get;
+	}
+};
+//#endregion
+export { StubbedRelation, ensureWithLoaded, withLoaded };
+
+//# sourceMappingURL=withLoaded.js.map

package/build/loading/withLoaded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withLoaded.js","names":[],"sources":["../../src/loading/withLoaded.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"src/loading/loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"src/relations/AsyncReactiveField.ts\";\nimport {\n  type LoadedCollection,\n  type LoadedProperty,\n  type LoadedReadOnlyCollection,\n  type LoadedReference,\n  type PolymorphicReference,\n  type Property,\n  type Relation,\n  isAsyncReactiveField,\n  isLoadedCollection,\n  isLoadedProperty,\n  isLoadedReference,\n  isProperty,\n  isReactiveField,\n  isReactiveGetter,\n  isRelation,\n} from \"src/relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"src/utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = {\n  [\n    K in keyof L as L[K] extends { get: unknown } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K\n  ]: L[K] extends PolymorphicReference<T, infer U, infer N>\n    ? L[K] extends LoadedReference<T, U, N>\n      ? U | N\n      : L[K]\n    : L[K] extends LoadedReference<T, infer U, never>\n      ? U\n      : L[K] extends LoadedReference<T, infer U, undefined>\n        ? U | undefined\n        : L[K] extends LoadedCollection<T, infer U>\n          ? U[]\n          : L[K] extends LoadedReadOnlyCollection<T, infer U>\n            ? // leaving out `readonly U[]` until we're ready to switch\n              U[]\n            : L[K] extends LoadedProperty<T, infer V>\n              ? V\n              : L[K];\n};\n\n/**\n * Allows destructuring against entities to more succinctly access loaded relations.\n *\n * ```typescript\n * // Instead of\n * const author = book.author.get;\n * // Use withLoaded\n * const { author } = withLoaded(book);\n * ```\n *\n * Granted, when accessing one property, this is not a win, but if you're accessing\n * ~3-4 separate loaded properties, then it can be more succinct than using `get`s\n * for each one.\n *\n * This function returns a proxy to an entity, instead of a real entity, and as such its return\n * value should only be used as part of a destructure and never directly assigned to a variable.\n *\n * This is also why the function is not recursive, as returning nested proxies could result in\n * them inadvertently being stored and passed to code that expects a real entity.\n */\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  promise: Promise<L>,\n): Promise<WithLoaded<T, H, L>>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loaded: L,\n): WithLoaded<T, H, L>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loadedOrPromise: MaybePromise<L> | L,\n): MaybePromise<WithLoaded<T, H, L>> {\n  return maybePromiseThen(\n    loadedOrPromise,\n    (loaded) =>\n      new Proxy(loaded, {\n        get: (target, prop) => {\n          const value: any = (target as any)[prop];\n          if (\n            isRelation(value) ||\n            isProperty(value) ||\n            isReactiveField(value) ||\n            isReactiveGetter(value) ||\n            isAsyncReactiveField(value)\n          ) {\n            return isLoadedReference(value) ||\n              isLoadedCollection(value) ||\n              isLoadedProperty(value) ||\n              isReactiveField(value) ||\n              isLoadedAsyncReactiveField(value) ||\n              isReactiveGetter(value)\n              ? value.get\n              : fail(`${target}.${String(prop)} is not loaded`);\n          } else if (value instanceof StubbedRelation) {\n            return value.get;\n          } else {\n            return value;\n          }\n        },\n      }) as WithLoaded<T, H, L>,\n  );\n}\n\nexport function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(\n  entity: T,\n  hint: H,\n): WithLoaded<T, H, Loaded<T, H>> {\n  assertLoaded<T, H>(entity, hint);\n  return withLoaded(entity);\n}\n\n/**\n * Allow stubbing of relations with dummy values.\n *\n * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful\n * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m\n * .load/.isLoaded/.get code paths.\n *\n * We'd originally done some of this by poking relation internal implementation details, but\n * using private fields like `#loaded` breaks that, and it was brittle anyway.\n *\n * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:\n *\n * ```\n * // Force `author.books` to always be `[]` and never load.\n * Object.defineProperty(author, \"books\", {\n *   get: () => new StubbedRelation([]),\n *  });\n * ```\n */\nexport class StubbedRelation {\n  constructor(private value: any) {}\n\n  get get() {\n    return this.value;\n  }\n\n  get isLoaded() {\n    return true;\n  }\n\n  load() {\n    return this.get;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAuEA,SAAgB,WACd,iBACmC;CACnC,OAAO,iBACL,kBACC,WACC,IAAI,MAAM,QAAQ,EAChB,MAAM,QAAQ,SAAS;EACrB,MAAM,QAAc,OAAe;EACnC,IACE,WAAW,KAAK,KAChB,WAAW,KAAK,KAChB,gBAAgB,KAAK,KACrB,iBAAiB,KAAK,KACtB,qBAAqB,KAAK,GAE1B,OAAO,kBAAkB,KAAK,KAC5B,mBAAmB,KAAK,KACxB,iBAAiB,KAAK,KACtB,gBAAgB,KAAK,KACrB,2BAA2B,KAAK,KAChC,iBAAiB,KAAK,IACpB,MAAM,MACN,KAAK,GAAG,OAAO,GAAG,OAAO,IAAI,EAAE,eAAe;OAC7C,IAAI,iBAAiB,iBAC1B,OAAO,MAAM;OAEb,OAAO;CAEX,EACF,CAAC,CACL;AACF;AAEA,SAAgB,iBACd,QACA,MACgC;CAChC,aAAmB,QAAQ,IAAI;CAC/B,OAAO,WAAW,MAAM;AAC1B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,kBAAb,MAA6B;CACP;CAApB,YAAY,OAAoB;EAAZ,KAAA,QAAA;CAAa;CAEjC,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CAEA,IAAI,WAAW;EACb,OAAO;CACT;CAEA,OAAO;EACL,OAAO,KAAK;CACd;AACF"}

package/build/logging/FactoryLogger.cjs

@@ -0,0 +1,66 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_config = require("../config.cjs");
+require("../EntityMetadata.cjs");
+require("../newTestInstance.cjs");
+require("../Entity.cjs");
+let ansis = require("ansis");
+ansis = require_runtime.__toESM(ansis, 1);
+//#region src/logging/FactoryLogger.ts
+let writer = void 0;
+const { gray, green, yellow } = ansis.default;
+var FactoryLogger = class {
+	level = 0;
+	writeFn;
+	skipNextLogCreating = false;
+	constructor() {
+		this.writeFn = writer ?? process.stdout.write.bind(process.stdout);
+	}
+	logCreating(cstr) {
+		if (this.skipNextLogCreating) this.skipNextLogCreating = false;
+		else this.write("Creating", green.bold(`new ${cstr.name}`), gray(`at ${require_config.getCallerName(2)}`));
+	}
+	logAddToUseMap(e, source) {
+		if (source === "sameBranch" || source === "diffBranch") this.write(`${gray(`created`)} ${e.toString()} ${gray("added to scope")}`);
+		else this.write(`${gray(`...adding`)} ${e.toString()} ${gray("opt to scope")}`);
+	}
+	logCreated(e) {
+		this.write(`${gray(`created`)} ${e.toString()}`);
+	}
+	logFoundExisting(e) {
+		this.write(`${yellow(`using existing`)} ${e.toString()}`);
+	}
+	logFoundOpt(fieldName, e) {
+		this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray("from opt")}`);
+	}
+	logNotFoundAndCreating(fieldName, meta) {
+		this.write(`${gray(`${fieldName} =`)} creating ${green.bold(`new ${meta.type}`)}`);
+		this.skipNextLogCreating = true;
+	}
+	logFoundInUseMap(fieldName, e) {
+		this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray("from scope")}`);
+	}
+	logFoundSingleEntity(fieldName, e) {
+		this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray("from em")}`);
+	}
+	indent() {
+		this.level++;
+	}
+	dedent() {
+		this.level--;
+	}
+	write(...line) {
+		this.writeFn(this.prefix() + line.join(" ") + "\n");
+	}
+	prefix() {
+		return "  ".repeat(this.level);
+	}
+};
+function setFactoryWriter(write) {
+	writer = write;
+}
+//#endregion
+exports.FactoryLogger = FactoryLogger;
+exports.setFactoryWriter = setFactoryWriter;
+
+//# sourceMappingURL=FactoryLogger.cjs.map

package/build/logging/FactoryLogger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FactoryLogger.cjs","names":["getCallerName"],"sources":["../../src/logging/FactoryLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getCallerName } from \"src/config.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { type UseMapSource } from \"src/newTestInstance.ts\";\n\nlet writer: WriteFn | undefined = undefined;\nexport type WriteFn = (line: string) => void;\n\nconst { gray, green, yellow } = ansis;\n\nexport class FactoryLogger {\n  private level = 0;\n  private writeFn: WriteFn;\n  private skipNextLogCreating = false;\n\n  // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n  // adding \"...at...\" stack traces to our output.\n  constructor() {\n    this.writeFn = writer ?? process.stdout.write.bind(process.stdout);\n  }\n\n  logCreating(cstr: any): void {\n    // This was already logged by the parent `field = creating new`\n    if (this.skipNextLogCreating) {\n      this.skipNextLogCreating = false;\n    } else {\n      this.write(\"Creating\", green.bold(`new ${cstr.name}`), gray(`at ${getCallerName(2)}`));\n    }\n  }\n\n  logAddToUseMap(e: Entity, source: UseMapSource): void {\n    if (source === \"sameBranch\" || source === \"diffBranch\") {\n      this.write(`${gray(`created`)} ${e.toString()} ${gray(\"added to scope\")}`);\n    } else {\n      this.write(`${gray(`...adding`)} ${e.toString()} ${gray(\"opt to scope\")}`);\n    }\n  }\n\n  logCreated(e: Entity): void {\n    // This matches the `logAddToUseMap` but for entities not going into scope\n    this.write(`${gray(`created`)} ${e.toString()}`);\n  }\n\n  logFoundExisting(e: Entity): void {\n    // Make this yellow because it reverses the \"new Entity\" we thought we were going to do\n    this.write(`${yellow(`using existing`)} ${e.toString()}`);\n  }\n\n  logFoundOpt(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from opt\")}`);\n  }\n\n  logNotFoundAndCreating(fieldName: string, meta: EntityMetadata): void {\n    this.write(`${gray(`${fieldName} =`)} creating ${green.bold(`new ${meta.type}`)}`);\n    this.skipNextLogCreating = true;\n  }\n\n  logFoundInUseMap(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from scope\")}`);\n  }\n\n  logFoundSingleEntity(fieldName: string, e: Entity): void {\n    this.write(`${gray(`${fieldName} =`)} ${e.toString()} ${gray(\"from em\")}`);\n  }\n\n  indent() {\n    this.level++;\n  }\n\n  dedent() {\n    this.level--;\n  }\n\n  private write(...line: string[]): void {\n    this.writeFn(this.prefix() + line.join(\" \") + \"\\n\");\n  }\n\n  private prefix() {\n    return \"  \".repeat(this.level);\n  }\n}\n\n// Allow our test suite observe the logger behavior\nexport function setFactoryWriter(write: WriteFn | undefined): void {\n  writer = write;\n}\n"],"mappings":";;;;;;;;;AAMA,IAAI,SAA8B,KAAA;AAGlC,MAAM,EAAE,MAAM,OAAO,WAAW,MAAA;AAEhC,IAAa,gBAAb,MAA2B;CACzB,QAAgB;CAChB;CACA,sBAA8B;CAI9B,cAAc;EACZ,KAAK,UAAU,UAAU,QAAQ,OAAO,MAAM,KAAK,QAAQ,MAAM;CACnE;CAEA,YAAY,MAAiB;EAE3B,IAAI,KAAK,qBACP,KAAK,sBAAsB;OAE3B,KAAK,MAAM,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG,KAAK,MAAMA,eAAAA,cAAc,CAAC,GAAG,CAAC;CAEzF;CAEA,eAAe,GAAW,QAA4B;EACpD,IAAI,WAAW,gBAAgB,WAAW,cACxC,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,gBAAgB,GAAG;OAEzE,KAAK,MAAM,GAAG,KAAK,WAAW,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,cAAc,GAAG;CAE7E;CAEA,WAAW,GAAiB;EAE1B,KAAK,MAAM,GAAG,KAAK,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG;CACjD;CAEA,iBAAiB,GAAiB;EAEhC,KAAK,MAAM,GAAG,OAAO,gBAAgB,EAAE,GAAG,EAAE,SAAS,GAAG;CAC1D;CAEA,YAAY,WAAmB,GAAiB;EAC9C,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,UAAU,GAAG;CAC5E;CAEA,uBAAuB,WAAmB,MAA4B;EACpE,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,YAAY,MAAM,KAAK,OAAO,KAAK,MAAM,GAAG;EACjF,KAAK,sBAAsB;CAC7B;CAEA,iBAAiB,WAAmB,GAAiB;EACnD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,YAAY,GAAG;CAC9E;CAEA,qBAAqB,WAAmB,GAAiB;EACvD,KAAK,MAAM,GAAG,KAAK,GAAG,UAAU,GAAG,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,KAAK,SAAS,GAAG;CAC3E;CAEA,SAAS;EACP,KAAK;CACP;CAEA,SAAS;EACP,KAAK;CACP;CAEA,MAAc,GAAG,MAAsB;EACrC,KAAK,QAAQ,KAAK,OAAO,IAAI,KAAK,KAAK,GAAG,IAAI,IAAI;CACpD;CAEA,SAAiB;EACf,OAAO,KAAK,OAAO,KAAK,KAAK;CAC/B;AACF;AAGA,SAAgB,iBAAiB,OAAkC;CACjE,SAAS;AACX"}