joist-core 2.3.0-next.97 → 2.3.0-next.99

package/build/keys.js

@@ -1,5 +1,5 @@
-import { assertNever, fail } from "./utils.js";
 import "./relations/index.js";
+import { assertNever, fail } from "./utils.js";
 import { getMetadata } from "./EntityMetadata.js";
 import "./EntityManager.js";
 import { isEntity } from "./Entity.js";

package/build/keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"keys.js","names":[],"sources":["../src/keys.ts"],"sourcesContent":["import { BaseEntity } from \"./BaseEntity.ts\";\nimport { type Entity, type IdType, isEntity } from \"./Entity.ts\";\nimport { type EntityConstructor, type IdOf, type TaggedId } from \"./EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"./EntityMetadata.ts\";\nimport { type Reference } from \"./relations/index.ts\";\nimport { assertNever, fail } from \"./utils.ts\";\n\nlet tagDelimiter: string | undefined = \":\";\n\n/** Sets the process-wide tagged-id format during metadata boot. */\nexport function setTaggedIdDelimiter(delimiter: string | undefined): void {\n  tagDelimiter = delimiter;\n}\n\n// I'm not entirely sure this is still necessary, but use a small subset of EntityMetadata so\n// that this file doesn't have to import the type and potentially create import cycles.\ntype HasTagName = {\n  tagName: string;\n  /** The database column type, i.e. used to do `::type` casts in Postgres. */\n  idDbType: \"bigint\" | \"int\" | \"uuid\" | \"text\";\n};\n\n/** Converts our internal/always-tagged `id` to the domain entity's `id` type (could be a number or uuid). */\nexport function toIdOf<T extends Entity>(meta: EntityMetadata<T>, id: TaggedId | undefined): IdOf<T> | undefined {\n  if (!id) return undefined;\n  switch (meta.idType) {\n    case \"number\":\n      return Number(deTagId(meta, id)) as IdOf<T>;\n    case \"tagged-string\":\n      return id as IdOf<T>;\n    case \"untagged-string\":\n      return deTagId(meta, id) as IdOf<T>;\n    default:\n      return assertNever(meta.idType);\n  }\n}\n\n// Before a referred-to object is saved, we keep its instance in our data\n// map, and then assume it will be persisted before we're asked to persist\nexport function maybeResolveReferenceToId(\n  value: Entity | Reference<any, any, any> | string | undefined,\n): TaggedId | undefined {\n  return typeof value === \"string\" ? value : value?.idTaggedMaybe;\n}\n\n/** Converts `value` to a number, i.e. for string ids, unless its undefined. */\nexport function keyToNumber(meta: HasTagName, value: string | number): number;\nexport function keyToNumber(meta: HasTagName, value: string | number | undefined): number | undefined;\nexport function keyToNumber(meta: HasTagName, value: any): number | undefined {\n  if (value === undefined || value === null) {\n    return undefined;\n  } else if (typeof value === \"number\") {\n    return value;\n  } else if (typeof value === \"string\") {\n    if (tagDelimiter === undefined) {\n      const id = value.startsWith(meta.tagName) ? value.slice(meta.tagName.length) : value;\n      return maybeNumberUnlessUuid(meta, id);\n    }\n    const delimiterIndex = value.indexOf(tagDelimiter);\n    if (delimiterIndex === -1) {\n      return maybeNumberUnlessUuid(meta, value);\n    }\n    const tag = value.slice(0, delimiterIndex);\n    if (tag !== meta.tagName) {\n      throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${value}`);\n    }\n    return maybeNumberUnlessUuid(meta, value.slice(delimiterIndex + tagDelimiter.length));\n  } else {\n    throw new Error(`Invalid key ${value}`);\n  }\n}\n\n// UUIDs, text, and bigints are strings at the database boundary, so lie to the type system and pretend they're numbers.\nfunction maybeNumberUnlessUuid(meta: HasTagName, key: string): number {\n  switch (meta.idDbType) {\n    case \"bigint\":\n    case \"uuid\":\n    case \"text\":\n      return key as any;\n    case \"int\":\n      return Number(key);\n    default:\n      assertNever(meta.idDbType);\n  }\n}\n\n/** Converts `dbValue` (big int, int, uuid) to a tagged string, unless its undefined. */\nexport function keyToTaggedId(meta: HasTagName, dbValue: string | number): TaggedId | undefined {\n  if (dbValue === undefined || dbValue === null) return undefined;\n  return `${meta.tagName}${tagDelimiter ?? \"\"}${dbValue}`;\n}\n\n/** Fails if any keys are untagged; internal batch-loader keys must always be tagged. */\nexport function assertIdsAreTagged(keys: readonly string[]): void {\n  for (const key of keys) {\n    const isTagged = tagDelimiter === undefined ? validSlugId.test(key) : key.indexOf(tagDelimiter) !== -1;\n    if (!isTagged) throw new Error(`Key ${key} is missing a tag`);\n  }\n}\n\nconst validSlugId = /^([a-z]+)(\\d+)$/i;\nconst uuidIshId = /[0-9a-z-]+/i;\n\n/** Returns whether `id` is tagged and a probably-correct value. */\nexport function isTaggedId(id: string | number): boolean;\n/** Returns whether `id` is tagged and the tag matches `meta`'s tag. */\nexport function isTaggedId(meta: EntityMetadata, id: string): boolean;\nexport function isTaggedId(metaOrId: string | number | HasTagName, id?: string): boolean {\n  if (typeof metaOrId === \"number\") {\n    // number overload\n    return false;\n  } else if (typeof metaOrId === \"string\") {\n    // string overload\n    return tagDelimiter === undefined ? validSlugId.test(metaOrId) : hasTagDelimiter(metaOrId);\n  } else {\n    // meta + string overload\n    return isTaggedIdForMeta(metaOrId, id!);\n  }\n}\n\nexport function assertIdIsTagged(id: string): void {\n  if (!isTaggedId(id)) {\n    throw new Error(`Key is not tagged ${id}`);\n  }\n}\n\n/** We accept an entity in case this is m2o storing a not-yet-saved entity. */\nexport function toTaggedId(meta: HasTagName, id: IdType): TaggedId;\nexport function toTaggedId(meta: HasTagName, id: IdType | undefined): TaggedId | undefined;\nexport function toTaggedId(meta: HasTagName, id: IdType | undefined): TaggedId | undefined {\n  if (typeof id === \"number\") {\n    return `${meta.tagName}${tagDelimiter ?? \"\"}${id}`;\n  } else if (typeof id === \"string\") {\n    // This seems odd, but is covered by a unit test, so I guess we need it?\n    if (id === \"\") return undefined;\n    if (tagDelimiter === undefined) {\n      const tag = validSlugId.exec(id)?.[1];\n      if (tag && tag !== meta.tagName) {\n        throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${id}`);\n      }\n      return tag ? id : `${meta.tagName}${id}`;\n    } else {\n      const i = id.indexOf(tagDelimiter);\n      if (i === -1) return `${meta.tagName}${tagDelimiter}${id}`;\n      const tag = id.slice(0, i);\n      if (tag !== meta.tagName) {\n        throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${id}`);\n      }\n    }\n  }\n  return id;\n}\n\n/** Similar to `toTaggedId`, but we accept an entity for handling relations to not-yet-saved entities. */\nexport function ensureTagged<T extends Entity>(\n  meta: HasTagName,\n  value: T | string | number | undefined,\n): T | TaggedId | undefined {\n  return isEntity(value) ? value : toTaggedId(meta, value);\n}\n\n/** Tags a potentially untagged id, while our API inputs still accept either tagged or untagged ids. */\nexport function tagId(meta: HasTagName, id: string | number): string;\nexport function tagId(cstr: EntityConstructor<any>, id: string | number): string;\nexport function tagId(meta: HasTagName, id: string | number | null | undefined): string | undefined;\nexport function tagId(cstr: EntityConstructor<any>, id: string | number | null | undefined): string | undefined;\nexport function tagId(\n  metaOrCstr: HasTagName | EntityConstructor<any>,\n  id: string | number | null | undefined,\n): string | undefined {\n  const meta = metadata(metaOrCstr);\n  const tag = meta.tagName;\n  if (typeof id === \"number\") {\n    return `${tag}${tagDelimiter ?? \"\"}${id}`;\n  }\n  if (id === null || id === undefined) {\n    return undefined;\n  }\n  if (tagDelimiter === undefined) {\n    const existingTag = validSlugId.exec(id)?.[1];\n    if (existingTag && existingTag !== tag) {\n      throw new Error(`Invalid tagged id, expected tag ${tag}, got ${id}`);\n    }\n    return existingTag ? id : `${tag}${id}`;\n  }\n  // Avoid using includes/split, for a faster indexOf + length + startsWith\n  const delimiterIndex = id.indexOf(tagDelimiter);\n  if (delimiterIndex !== -1) {\n    if (delimiterIndex !== tag.length || !id.startsWith(tag)) {\n      throw new Error(`Invalid tagged id, expected tag ${tag}, got ${id}`);\n    }\n    return id;\n  }\n  return `${tag}${tagDelimiter}${id}`;\n}\n\n/** Adds the tag prefixes. */\nexport function tagIds(meta: HasTagName, keys: readonly (string | number)[]): readonly string[];\nexport function tagIds(cstr: EntityConstructor<any>, keys: readonly (string | number)[]): readonly string[];\nexport function tagIds(\n  metaOrCstr: HasTagName | EntityConstructor<any>,\n  keys: readonly (string | number)[],\n): readonly string[] {\n  return keys.map((k) => tagId(metaOrCstr as any, k));\n}\n\nexport function deTagId(meta: HasTagName, id: string | number): string;\nexport function deTagId(meta: HasTagName, id: string | number | undefined): string | undefined;\nexport function deTagId(entity: Entity): string;\nexport function deTagId(entityOrMeta: Entity | HasTagName, id?: string | number): string | undefined {\n  const meta = entityOrMeta instanceof BaseEntity ? getMetadata(entityOrMeta) : (entityOrMeta as HasTagName);\n  id = id ?? (entityOrMeta as Entity).id;\n  return id === undefined ? undefined : keyToNumber(meta, id).toString();\n}\n\n/** Removes the tag prefixes so we can use the keys for SQL operations. */\nexport function deTagIds(meta: HasTagName, keys: readonly string[]): readonly string[] {\n  const deTagged = Array(keys.length);\n  for (let i = 0; i < keys.length; i++) deTagged[i] = deTagId(meta, keys[i]);\n  return deTagged;\n}\n\n/** Removes the tag prefixes so we can use the keys for SQL operations. */\nexport function unsafeDeTagIds(keys: readonly string[]): readonly string[] {\n  const deTagged = Array(keys.length);\n  for (let i = 0; i < keys.length; i++) {\n    if (tagDelimiter === undefined) {\n      deTagged[i] = validSlugId.exec(keys[i])?.[2];\n    } else {\n      const delimiterIndex = keys[i].indexOf(tagDelimiter);\n      deTagged[i] = delimiterIndex === -1 ? undefined : keys[i].slice(delimiterIndex + tagDelimiter.length);\n    }\n  }\n  return deTagged;\n}\n\n/** Given a tagged id, returns its tag. */\nexport function tagFromId(id: string): string {\n  if (tagDelimiter === undefined) {\n    return validSlugId.exec(id)?.[1] ?? fail(`Unknown tagged id format: \"${id}\"`);\n  }\n  const delimiterIndex = id.indexOf(tagDelimiter);\n  return delimiterIndex > 0 && delimiterIndex + tagDelimiter.length < id.length\n    ? id.slice(0, delimiterIndex)\n    : fail(`Unknown tagged id format: \"${id}\"`);\n}\n\n/** Returns the metadata needed to format an id. */\nfunction metadata(metaOrCstr: HasTagName | EntityConstructor<any>): HasTagName {\n  return typeof metaOrCstr === \"function\" ? getMetadata(metaOrCstr) : metaOrCstr;\n}\n\n/** Returns whether `id` has the tag and database id shape required by `meta`. */\nfunction isTaggedIdForMeta(meta: HasTagName, id: string): boolean {\n  if (tagDelimiter === undefined) {\n    return validSlugId.exec(id)?.[1] === meta.tagName;\n  }\n  const delimiterIndex = id.indexOf(tagDelimiter);\n  if (delimiterIndex === -1) return false;\n  const tag = id.slice(0, delimiterIndex);\n  const untaggedId = id.slice(delimiterIndex + tagDelimiter.length);\n  if (meta.tagName !== tag) return false;\n  switch (meta.idDbType) {\n    case \"int\":\n    case \"bigint\":\n      return !Number.isNaN(Number(untaggedId));\n    case \"uuid\":\n      return uuidIshId.test(untaggedId);\n    case \"text\":\n      return true;\n    default:\n      return assertNever(meta.idDbType);\n  }\n}\n\n/** Returns whether `id` has a non-empty tag and value separated by the configured delimiter. */\nfunction hasTagDelimiter(id: string): boolean {\n  if (tagDelimiter === undefined) return false;\n  const delimiterIndex = id.indexOf(tagDelimiter);\n  return delimiterIndex > 0 && delimiterIndex + tagDelimiter.length < id.length;\n}\n"],"mappings":"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"}
+{"version":3,"file":"keys.js","names":[],"sources":["../src/keys.ts"],"sourcesContent":["import { BaseEntity } from \"src/BaseEntity.ts\";\nimport { type Entity, type IdType, isEntity } from \"src/Entity.ts\";\nimport { type EntityConstructor, type IdOf, type TaggedId } from \"src/EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\nimport { type Reference } from \"src/relations/index.ts\";\nimport { assertNever, fail } from \"src/utils.ts\";\n\nlet tagDelimiter: string | undefined = \":\";\n\n/** Sets the process-wide tagged-id format during metadata boot. */\nexport function setTaggedIdDelimiter(delimiter: string | undefined): void {\n  tagDelimiter = delimiter;\n}\n\n// I'm not entirely sure this is still necessary, but use a small subset of EntityMetadata so\n// that this file doesn't have to import the type and potentially create import cycles.\ntype HasTagName = {\n  tagName: string;\n  /** The database column type, i.e. used to do `::type` casts in Postgres. */\n  idDbType: \"bigint\" | \"int\" | \"uuid\" | \"text\";\n};\n\n/** Converts our internal/always-tagged `id` to the domain entity's `id` type (could be a number or uuid). */\nexport function toIdOf<T extends Entity>(meta: EntityMetadata<T>, id: TaggedId | undefined): IdOf<T> | undefined {\n  if (!id) return undefined;\n  switch (meta.idType) {\n    case \"number\":\n      return Number(deTagId(meta, id)) as IdOf<T>;\n    case \"tagged-string\":\n      return id as IdOf<T>;\n    case \"untagged-string\":\n      return deTagId(meta, id) as IdOf<T>;\n    default:\n      return assertNever(meta.idType);\n  }\n}\n\n// Before a referred-to object is saved, we keep its instance in our data\n// map, and then assume it will be persisted before we're asked to persist\nexport function maybeResolveReferenceToId(\n  value: Entity | Reference<any, any, any> | string | undefined,\n): TaggedId | undefined {\n  return typeof value === \"string\" ? value : value?.idTaggedMaybe;\n}\n\n/** Converts `value` to a number, i.e. for string ids, unless its undefined. */\nexport function keyToNumber(meta: HasTagName, value: string | number): number;\nexport function keyToNumber(meta: HasTagName, value: string | number | undefined): number | undefined;\nexport function keyToNumber(meta: HasTagName, value: any): number | undefined {\n  if (value === undefined || value === null) {\n    return undefined;\n  } else if (typeof value === \"number\") {\n    return value;\n  } else if (typeof value === \"string\") {\n    if (tagDelimiter === undefined) {\n      const id = value.startsWith(meta.tagName) ? value.slice(meta.tagName.length) : value;\n      return maybeNumberUnlessUuid(meta, id);\n    }\n    const delimiterIndex = value.indexOf(tagDelimiter);\n    if (delimiterIndex === -1) {\n      return maybeNumberUnlessUuid(meta, value);\n    }\n    const tag = value.slice(0, delimiterIndex);\n    if (tag !== meta.tagName) {\n      throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${value}`);\n    }\n    return maybeNumberUnlessUuid(meta, value.slice(delimiterIndex + tagDelimiter.length));\n  } else {\n    throw new Error(`Invalid key ${value}`);\n  }\n}\n\n// UUIDs, text, and bigints are strings at the database boundary, so lie to the type system and pretend they're numbers.\nfunction maybeNumberUnlessUuid(meta: HasTagName, key: string): number {\n  switch (meta.idDbType) {\n    case \"bigint\":\n    case \"uuid\":\n    case \"text\":\n      return key as any;\n    case \"int\":\n      return Number(key);\n    default:\n      assertNever(meta.idDbType);\n  }\n}\n\n/** Converts `dbValue` (big int, int, uuid) to a tagged string, unless its undefined. */\nexport function keyToTaggedId(meta: HasTagName, dbValue: string | number): TaggedId | undefined {\n  if (dbValue === undefined || dbValue === null) return undefined;\n  return `${meta.tagName}${tagDelimiter ?? \"\"}${dbValue}`;\n}\n\n/** Fails if any keys are untagged; internal batch-loader keys must always be tagged. */\nexport function assertIdsAreTagged(keys: readonly string[]): void {\n  for (const key of keys) {\n    const isTagged = tagDelimiter === undefined ? validSlugId.test(key) : key.indexOf(tagDelimiter) !== -1;\n    if (!isTagged) throw new Error(`Key ${key} is missing a tag`);\n  }\n}\n\nconst validSlugId = /^([a-z]+)(\\d+)$/i;\nconst uuidIshId = /[0-9a-z-]+/i;\n\n/** Returns whether `id` is tagged and a probably-correct value. */\nexport function isTaggedId(id: string | number): boolean;\n/** Returns whether `id` is tagged and the tag matches `meta`'s tag. */\nexport function isTaggedId(meta: EntityMetadata, id: string): boolean;\nexport function isTaggedId(metaOrId: string | number | HasTagName, id?: string): boolean {\n  if (typeof metaOrId === \"number\") {\n    // number overload\n    return false;\n  } else if (typeof metaOrId === \"string\") {\n    // string overload\n    return tagDelimiter === undefined ? validSlugId.test(metaOrId) : hasTagDelimiter(metaOrId);\n  } else {\n    // meta + string overload\n    return isTaggedIdForMeta(metaOrId, id!);\n  }\n}\n\nexport function assertIdIsTagged(id: string): void {\n  if (!isTaggedId(id)) {\n    throw new Error(`Key is not tagged ${id}`);\n  }\n}\n\n/** We accept an entity in case this is m2o storing a not-yet-saved entity. */\nexport function toTaggedId(meta: HasTagName, id: IdType): TaggedId;\nexport function toTaggedId(meta: HasTagName, id: IdType | undefined): TaggedId | undefined;\nexport function toTaggedId(meta: HasTagName, id: IdType | undefined): TaggedId | undefined {\n  if (typeof id === \"number\") {\n    return `${meta.tagName}${tagDelimiter ?? \"\"}${id}`;\n  } else if (typeof id === \"string\") {\n    // This seems odd, but is covered by a unit test, so I guess we need it?\n    if (id === \"\") return undefined;\n    if (tagDelimiter === undefined) {\n      const tag = validSlugId.exec(id)?.[1];\n      if (tag && tag !== meta.tagName) {\n        throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${id}`);\n      }\n      return tag ? id : `${meta.tagName}${id}`;\n    } else {\n      const i = id.indexOf(tagDelimiter);\n      if (i === -1) return `${meta.tagName}${tagDelimiter}${id}`;\n      const tag = id.slice(0, i);\n      if (tag !== meta.tagName) {\n        throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${id}`);\n      }\n    }\n  }\n  return id;\n}\n\n/** Similar to `toTaggedId`, but we accept an entity for handling relations to not-yet-saved entities. */\nexport function ensureTagged<T extends Entity>(\n  meta: HasTagName,\n  value: T | string | number | undefined,\n): T | TaggedId | undefined {\n  return isEntity(value) ? value : toTaggedId(meta, value);\n}\n\n/** Tags a potentially untagged id, while our API inputs still accept either tagged or untagged ids. */\nexport function tagId(meta: HasTagName, id: string | number): string;\nexport function tagId(cstr: EntityConstructor<any>, id: string | number): string;\nexport function tagId(meta: HasTagName, id: string | number | null | undefined): string | undefined;\nexport function tagId(cstr: EntityConstructor<any>, id: string | number | null | undefined): string | undefined;\nexport function tagId(\n  metaOrCstr: HasTagName | EntityConstructor<any>,\n  id: string | number | null | undefined,\n): string | undefined {\n  const meta = metadata(metaOrCstr);\n  const tag = meta.tagName;\n  if (typeof id === \"number\") {\n    return `${tag}${tagDelimiter ?? \"\"}${id}`;\n  }\n  if (id === null || id === undefined) {\n    return undefined;\n  }\n  if (tagDelimiter === undefined) {\n    const existingTag = validSlugId.exec(id)?.[1];\n    if (existingTag && existingTag !== tag) {\n      throw new Error(`Invalid tagged id, expected tag ${tag}, got ${id}`);\n    }\n    return existingTag ? id : `${tag}${id}`;\n  }\n  // Avoid using includes/split, for a faster indexOf + length + startsWith\n  const delimiterIndex = id.indexOf(tagDelimiter);\n  if (delimiterIndex !== -1) {\n    if (delimiterIndex !== tag.length || !id.startsWith(tag)) {\n      throw new Error(`Invalid tagged id, expected tag ${tag}, got ${id}`);\n    }\n    return id;\n  }\n  return `${tag}${tagDelimiter}${id}`;\n}\n\n/** Adds the tag prefixes. */\nexport function tagIds(meta: HasTagName, keys: readonly (string | number)[]): readonly string[];\nexport function tagIds(cstr: EntityConstructor<any>, keys: readonly (string | number)[]): readonly string[];\nexport function tagIds(\n  metaOrCstr: HasTagName | EntityConstructor<any>,\n  keys: readonly (string | number)[],\n): readonly string[] {\n  return keys.map((k) => tagId(metaOrCstr as any, k));\n}\n\nexport function deTagId(meta: HasTagName, id: string | number): string;\nexport function deTagId(meta: HasTagName, id: string | number | undefined): string | undefined;\nexport function deTagId(entity: Entity): string;\nexport function deTagId(entityOrMeta: Entity | HasTagName, id?: string | number): string | undefined {\n  const meta = entityOrMeta instanceof BaseEntity ? getMetadata(entityOrMeta) : (entityOrMeta as HasTagName);\n  id = id ?? (entityOrMeta as Entity).id;\n  return id === undefined ? undefined : keyToNumber(meta, id).toString();\n}\n\n/** Removes the tag prefixes so we can use the keys for SQL operations. */\nexport function deTagIds(meta: HasTagName, keys: readonly string[]): readonly string[] {\n  const deTagged = Array(keys.length);\n  for (let i = 0; i < keys.length; i++) deTagged[i] = deTagId(meta, keys[i]);\n  return deTagged;\n}\n\n/** Removes the tag prefixes so we can use the keys for SQL operations. */\nexport function unsafeDeTagIds(keys: readonly string[]): readonly string[] {\n  const deTagged = Array(keys.length);\n  for (let i = 0; i < keys.length; i++) {\n    if (tagDelimiter === undefined) {\n      deTagged[i] = validSlugId.exec(keys[i])?.[2];\n    } else {\n      const delimiterIndex = keys[i].indexOf(tagDelimiter);\n      deTagged[i] = delimiterIndex === -1 ? undefined : keys[i].slice(delimiterIndex + tagDelimiter.length);\n    }\n  }\n  return deTagged;\n}\n\n/** Given a tagged id, returns its tag. */\nexport function tagFromId(id: string): string {\n  if (tagDelimiter === undefined) {\n    return validSlugId.exec(id)?.[1] ?? fail(`Unknown tagged id format: \"${id}\"`);\n  }\n  const delimiterIndex = id.indexOf(tagDelimiter);\n  return delimiterIndex > 0 && delimiterIndex + tagDelimiter.length < id.length\n    ? id.slice(0, delimiterIndex)\n    : fail(`Unknown tagged id format: \"${id}\"`);\n}\n\n/** Returns the metadata needed to format an id. */\nfunction metadata(metaOrCstr: HasTagName | EntityConstructor<any>): HasTagName {\n  return typeof metaOrCstr === \"function\" ? getMetadata(metaOrCstr) : metaOrCstr;\n}\n\n/** Returns whether `id` has the tag and database id shape required by `meta`. */\nfunction isTaggedIdForMeta(meta: HasTagName, id: string): boolean {\n  if (tagDelimiter === undefined) {\n    return validSlugId.exec(id)?.[1] === meta.tagName;\n  }\n  const delimiterIndex = id.indexOf(tagDelimiter);\n  if (delimiterIndex === -1) return false;\n  const tag = id.slice(0, delimiterIndex);\n  const untaggedId = id.slice(delimiterIndex + tagDelimiter.length);\n  if (meta.tagName !== tag) return false;\n  switch (meta.idDbType) {\n    case \"int\":\n    case \"bigint\":\n      return !Number.isNaN(Number(untaggedId));\n    case \"uuid\":\n      return uuidIshId.test(untaggedId);\n    case \"text\":\n      return true;\n    default:\n      return assertNever(meta.idDbType);\n  }\n}\n\n/** Returns whether `id` has a non-empty tag and value separated by the configured delimiter. */\nfunction hasTagDelimiter(id: string): boolean {\n  if (tagDelimiter === undefined) return false;\n  const delimiterIndex = id.indexOf(tagDelimiter);\n  return delimiterIndex > 0 && delimiterIndex + tagDelimiter.length < id.length;\n}\n"],"mappings":"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"}

package/build/{HintTree.cjs → loading/HintTree.cjs}

@@ -1,9 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_normalizeHints = require("./normalizeHints.cjs");
-require("./loadHints.cjs");
-require("./EntityManager.cjs");
-require("./Entity.cjs");
-//#region src/HintTree.ts
+const require_normalizeHints = require("../normalizeHints.cjs");
+//#region src/loading/HintTree.ts
 /**
 * Given a number of potentially overlapping load hints, i.e. `{ authors: "books" }` and
 * `{ authors: "reviews" }`, combines them into a single `HintNode` tree, with bookkeeping

package/build/loading/HintTree.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HintTree.cjs","names":["normalizeHint"],"sources":["../../src/loading/HintTree.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport type { TaggedId } from \"src/EntityManager.ts\";\nimport type { LoadHint } from \"src/loading/loadHints.ts\";\nimport { normalizeHint } from \"src/normalizeHints.ts\";\n\n// We support preloading in `populate` with existing entities, or `load` with just ids.\n// (We could ask `populate` to convert its entities to ids, but it's convenient for it\n// to keep the HintTree populated with Entities so that newly-created entities can have\n// their collections marked as loaded.\nexport type EntityOrId = Entity | TaggedId;\n\nexport type HintNode<E extends EntityOrId> = {\n  /** These entities are the root entities of our preload, i.e. we use them to trim the tree to prevent over-fetching. */\n  entities: Set<E>;\n  /** A runtime indication of the type of `E`. */\n  entitiesKind: \"instances\" | \"ids\" | \"none\";\n  /** The hints to preload at this node, i.e. if `E` is `Author`, the `books: \"reviews` or just `comments: {}`. */\n  hints: { [key: string]: HintNode<E> };\n};\n\n/**\n * Given a number of potentially overlapping load hints, i.e. `{ authors: \"books\" }` and\n * `{ authors: \"reviews\" }`, combines them into a single `HintNode` tree, with bookkeeping\n * of which entities requested each specific node of the tree.\n *\n * I.e. if we're populating three publishers, two with `{ authors: \"books\" }` and one with\n * `{ authors: \"reviews\" }`, we'll end up with a tree like:\n *\n * ```\n *  {\n *    authors: {\n *      entities: [p1, p2, p3],\n *      hints: {\n *        books: { entities: [p1, p2], hints: {} },\n *        reviews: { entities: [p3], hints: {} },\n *      }\n *    }\n *  }\n * ```\n *\n * Which will let us preload `authors` for all three publishers, but `books` only for the\n * first two, and `reviews` only for the third, i.e. we can prevent over-fetching.\n */\nexport function buildHintTree<E extends EntityOrId>(\n  hints: readonly { entity: E; hint: LoadHint<any> | undefined }[] | LoadHint<any>,\n): HintNode<E> {\n  if (Array.isArray(hints)) {\n    // This might be a top-level LoadHint string[] like [\"books\"]\n    const isLoadHint = hints.length > 0 && typeof hints[0] === \"string\";\n    if (isLoadHint) {\n      const root: HintNode<E> = { entitiesKind: \"none\", entities: new Set(), hints: {} };\n      addHintNode(root, undefined, hints as LoadHint<any>);\n      return root;\n    } else {\n      const entitiesKind = typeof hints[0].entity === \"string\" ? (\"ids\" as const) : (\"instances\" as const);\n      const root: HintNode<E> = { entitiesKind, entities: new Set(), hints: {} };\n      for (const { entity, hint } of hints) {\n        addHintNode(root, entity, hint);\n      }\n      return root;\n    }\n  } else {\n    const root: HintNode<E> = { entitiesKind: \"none\", entities: new Set(), hints: {} };\n    addHintNode(root, undefined, hints as LoadHint<any>);\n    return root;\n  }\n}\n\nfunction addHintNode<E extends EntityOrId>(node: HintNode<E>, entity: E | undefined, hint: LoadHint<any> | undefined) {\n  // It's tempting to filter out new entities here, but we need to call `.load()` on their\n  // relations to ensure the `.get`s will later work, even if we don't look in the db for them.\n  if (entity) node.entities.add(entity);\n  if (hint) {\n    for (const [key, nestedHint] of Object.entries(normalizeHint(hint))) {\n      const child = (node.hints[key] ??= { entitiesKind: node.entitiesKind, entities: new Set(), hints: {} });\n      addHintNode(child, entity, nestedHint);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,cACd,OACa;CACb,IAAI,MAAM,QAAQ,KAAK,GAAG;EAGxB,IADmB,MAAM,SAAS,KAAK,OAAO,MAAM,OAAO,UAC3C;GACd,MAAM,OAAoB;IAAE,cAAc;IAAQ,0BAAU,IAAI,IAAI;IAAG,OAAO,CAAC;GAAE;GACjF,YAAY,MAAM,KAAA,GAAW,KAAsB;GACnD,OAAO;EACT,OAAO;GAEL,MAAM,OAAoB;IAAE,cADP,OAAO,MAAM,EAAE,CAAC,WAAW,WAAY,QAAmB;IACrC,0BAAU,IAAI,IAAI;IAAG,OAAO,CAAC;GAAE;GACzE,KAAK,MAAM,EAAE,QAAQ,UAAU,OAC7B,YAAY,MAAM,QAAQ,IAAI;GAEhC,OAAO;EACT;CACF,OAAO;EACL,MAAM,OAAoB;GAAE,cAAc;GAAQ,0BAAU,IAAI,IAAI;GAAG,OAAO,CAAC;EAAE;EACjF,YAAY,MAAM,KAAA,GAAW,KAAsB;EACnD,OAAO;CACT;AACF;AAEA,SAAS,YAAkC,MAAmB,QAAuB,MAAiC;CAGpH,IAAI,QAAQ,KAAK,SAAS,IAAI,MAAM;CACpC,IAAI,MACF,KAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QAAQA,uBAAAA,cAAc,IAAI,CAAC,GAEhE,YAAY,KADQ,MAAM,SAAS;EAAE,cAAc,KAAK;EAAc,0BAAU,IAAI,IAAI;EAAG,OAAO,CAAC;CAAE,GAClF,QAAQ,UAAU;AAG3C"}

package/build/{HintTree.d.cts → loading/HintTree.d.cts}

@@ -1,7 +1,7 @@
 import { LoadHint } from "./loadHints.cjs";
-import { TaggedId } from "./EntityManager.cjs";
-import { Entity } from "./Entity.cjs";
-//#region src/HintTree.d.ts
+import { TaggedId } from "../EntityManager.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/loading/HintTree.d.ts
 type EntityOrId = Entity | TaggedId;
 type HintNode<E extends EntityOrId> = {
   /** These entities are the root entities of our preload, i.e. we use them to trim the tree to prevent over-fetching. */

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

@@ -0,0 +1 @@
+{"version":3,"file":"HintTree.d.cts","names":[],"sources":["../../src/loading/HintTree.ts"],"mappings":";;;;KASY,aAAa,SAAS;KAEtB,SAAS,UAAU;;EAE7B,UAAU,IAAI;;EAEd;;EAEA;KAAU,cAAc,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BnB,cAAc,UAAU,YACtC;EAAkB,QAAQ;EAAG,MAAM;MAAgC,gBAClE,SAAS"}

package/build/{HintTree.d.mts → loading/HintTree.d.mts}

@@ -1,7 +1,7 @@
 import { LoadHint } from "./loadHints.mjs";
-import { TaggedId } from "./EntityManager.mjs";
-import { Entity } from "./Entity.mjs";
-//#region src/HintTree.d.ts
+import { TaggedId } from "../EntityManager.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/loading/HintTree.d.ts
 type EntityOrId = Entity | TaggedId;
 type HintNode<E extends EntityOrId> = {
   /** These entities are the root entities of our preload, i.e. we use them to trim the tree to prevent over-fetching. */

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

@@ -0,0 +1 @@
+{"version":3,"file":"HintTree.d.mts","names":[],"sources":["../../src/loading/HintTree.ts"],"mappings":";;;;KASY,aAAa,SAAS;KAEtB,SAAS,UAAU;;EAE7B,UAAU,IAAI;;EAEd;;EAEA;KAAU,cAAc,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BnB,cAAc,UAAU,YACtC;EAAkB,QAAQ;EAAG,MAAM;MAAgC,gBAClE,SAAS"}

package/build/{HintTree.js → loading/HintTree.js}

@@ -1,8 +1,5 @@
-import { normalizeHint } from "./normalizeHints.js";
-import "./loadHints.js";
-import "./EntityManager.js";
-import "./Entity.js";
-//#region src/HintTree.ts
+import { normalizeHint } from "../normalizeHints.js";
+//#region src/loading/HintTree.ts
 /**
 * Given a number of potentially overlapping load hints, i.e. `{ authors: "books" }` and
 * `{ authors: "reviews" }`, combines them into a single `HintNode` tree, with bookkeeping

package/build/loading/HintTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HintTree.js","names":[],"sources":["../../src/loading/HintTree.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport type { TaggedId } from \"src/EntityManager.ts\";\nimport type { LoadHint } from \"src/loading/loadHints.ts\";\nimport { normalizeHint } from \"src/normalizeHints.ts\";\n\n// We support preloading in `populate` with existing entities, or `load` with just ids.\n// (We could ask `populate` to convert its entities to ids, but it's convenient for it\n// to keep the HintTree populated with Entities so that newly-created entities can have\n// their collections marked as loaded.\nexport type EntityOrId = Entity | TaggedId;\n\nexport type HintNode<E extends EntityOrId> = {\n  /** These entities are the root entities of our preload, i.e. we use them to trim the tree to prevent over-fetching. */\n  entities: Set<E>;\n  /** A runtime indication of the type of `E`. */\n  entitiesKind: \"instances\" | \"ids\" | \"none\";\n  /** The hints to preload at this node, i.e. if `E` is `Author`, the `books: \"reviews` or just `comments: {}`. */\n  hints: { [key: string]: HintNode<E> };\n};\n\n/**\n * Given a number of potentially overlapping load hints, i.e. `{ authors: \"books\" }` and\n * `{ authors: \"reviews\" }`, combines them into a single `HintNode` tree, with bookkeeping\n * of which entities requested each specific node of the tree.\n *\n * I.e. if we're populating three publishers, two with `{ authors: \"books\" }` and one with\n * `{ authors: \"reviews\" }`, we'll end up with a tree like:\n *\n * ```\n *  {\n *    authors: {\n *      entities: [p1, p2, p3],\n *      hints: {\n *        books: { entities: [p1, p2], hints: {} },\n *        reviews: { entities: [p3], hints: {} },\n *      }\n *    }\n *  }\n * ```\n *\n * Which will let us preload `authors` for all three publishers, but `books` only for the\n * first two, and `reviews` only for the third, i.e. we can prevent over-fetching.\n */\nexport function buildHintTree<E extends EntityOrId>(\n  hints: readonly { entity: E; hint: LoadHint<any> | undefined }[] | LoadHint<any>,\n): HintNode<E> {\n  if (Array.isArray(hints)) {\n    // This might be a top-level LoadHint string[] like [\"books\"]\n    const isLoadHint = hints.length > 0 && typeof hints[0] === \"string\";\n    if (isLoadHint) {\n      const root: HintNode<E> = { entitiesKind: \"none\", entities: new Set(), hints: {} };\n      addHintNode(root, undefined, hints as LoadHint<any>);\n      return root;\n    } else {\n      const entitiesKind = typeof hints[0].entity === \"string\" ? (\"ids\" as const) : (\"instances\" as const);\n      const root: HintNode<E> = { entitiesKind, entities: new Set(), hints: {} };\n      for (const { entity, hint } of hints) {\n        addHintNode(root, entity, hint);\n      }\n      return root;\n    }\n  } else {\n    const root: HintNode<E> = { entitiesKind: \"none\", entities: new Set(), hints: {} };\n    addHintNode(root, undefined, hints as LoadHint<any>);\n    return root;\n  }\n}\n\nfunction addHintNode<E extends EntityOrId>(node: HintNode<E>, entity: E | undefined, hint: LoadHint<any> | undefined) {\n  // It's tempting to filter out new entities here, but we need to call `.load()` on their\n  // relations to ensure the `.get`s will later work, even if we don't look in the db for them.\n  if (entity) node.entities.add(entity);\n  if (hint) {\n    for (const [key, nestedHint] of Object.entries(normalizeHint(hint))) {\n      const child = (node.hints[key] ??= { entitiesKind: node.entitiesKind, entities: new Set(), hints: {} });\n      addHintNode(child, entity, nestedHint);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,cACd,OACa;CACb,IAAI,MAAM,QAAQ,KAAK,GAAG;EAGxB,IADmB,MAAM,SAAS,KAAK,OAAO,MAAM,OAAO,UAC3C;GACd,MAAM,OAAoB;IAAE,cAAc;IAAQ,0BAAU,IAAI,IAAI;IAAG,OAAO,CAAC;GAAE;GACjF,YAAY,MAAM,KAAA,GAAW,KAAsB;GACnD,OAAO;EACT,OAAO;GAEL,MAAM,OAAoB;IAAE,cADP,OAAO,MAAM,EAAE,CAAC,WAAW,WAAY,QAAmB;IACrC,0BAAU,IAAI,IAAI;IAAG,OAAO,CAAC;GAAE;GACzE,KAAK,MAAM,EAAE,QAAQ,UAAU,OAC7B,YAAY,MAAM,QAAQ,IAAI;GAEhC,OAAO;EACT;CACF,OAAO;EACL,MAAM,OAAoB;GAAE,cAAc;GAAQ,0BAAU,IAAI,IAAI;GAAG,OAAO,CAAC;EAAE;EACjF,YAAY,MAAM,KAAA,GAAW,KAAsB;EACnD,OAAO;CACT;AACF;AAEA,SAAS,YAAkC,MAAmB,QAAuB,MAAiC;CAGpH,IAAI,QAAQ,KAAK,SAAS,IAAI,MAAM;CACpC,IAAI,MACF,KAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QAAQ,cAAc,IAAI,CAAC,GAEhE,YAAY,KADQ,MAAM,SAAS;EAAE,cAAc,KAAK;EAAc,0BAAU,IAAI,IAAI;EAAG,OAAO,CAAC;CAAE,GAClF,QAAQ,UAAU;AAG3C"}

package/build/{IsLoadedCache.cjs → loading/IsLoadedCache.cjs}

@@ -1,7 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_EntityMetadata = require("./EntityMetadata.cjs");
-require("./Entity.cjs");
-//#region src/IsLoadedCache.ts
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+//#region src/loading/IsLoadedCache.ts
 var IsLoadedCache = class {
 	#smartCache = {};
 	#naiveCache = /* @__PURE__ */ new Set();

package/build/loading/IsLoadedCache.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsLoadedCache.cjs","names":["getMetadata","#smartCache","#smartDirtySets","#naiveCache","#naiveDirtySets","#resetDownstreamReactables"],"sources":["../../src/loading/IsLoadedCache.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\n\n/**\n * Interface for our relations that have dynamic & expensive `isLoaded` checks.\n *\n * ...and also `OneToManyCollection.get` calls.\n *\n * The primary m2o/o2m/m2m relations all have trivial `isLoaded` checks--are they\n * loaded or not.\n *\n * But for \"composite relations\", i.e. a ReactiveField or ReactiveRelation whose\n * \"load-ness\" is calculated by evaluating its load hint across a subgraph of entities\n * & relations, load-ness can be more dynamic true-then-false, as its subgraph changes.\n *\n * To avoid performance issues (see https://github.com/joist-orm/joist-orm/issues/1166),\n * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven\n * cache invalidation whenever relations are mutated (via a hook in `setField`).\n */\nexport interface IsLoadedCachable {\n  entity: Entity;\n  fieldName: string;\n  isLoaded: boolean;\n  resetIsLoaded(): void;\n}\n\nexport class IsLoadedCache {\n  // Cache of `{ tag -> { fieldName -> Set<IsLoadedCachable> } }` to hold derived relations\n  // we can selectively invalidate by walking from the mutated field to any downstream\n  // cacheables.\n  #smartCache: Record<string, Record<string, Set<IsLoadedCachable>>> = {};\n  // A dumb cache for things that are hard selectively invalidate (o2m.get, recursive collections,\n  // and custom references/collections), so any mutation resets these.\n  #naiveCache = new Set<IsLoadedCachable>();\n  // Counter to skip reactive hint walking when no smart cache sets are populated.\n  #smartDirtySets = 0;\n  // Counter to fast-path resetIsLoaded when the naive cache is empty.\n  #naiveDirtySets = 0;\n\n  /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */\n  add(target: IsLoadedCachable): void {\n    const meta = getMetadata(target.entity);\n    const set = ((this.#smartCache[meta.tagName] ??= {})[target.fieldName] ??= new Set());\n    if (set.size === 0) {\n      this.#smartDirtySets++;\n    }\n    set.add(target);\n  }\n\n  addNaive(target: IsLoadedCachable): void {\n    if (this.#naiveCache.size === 0) this.#naiveDirtySets++;\n    this.#naiveCache.add(target);\n  }\n\n  /** Resets any in-memory #isLoaded/#isCached caches that depend on `entity.fieldName`. */\n  resetIsLoaded(entity: Entity, fieldName: string): void {\n    if (this.#smartDirtySets === 0 && this.#naiveDirtySets === 0) return;\n    // Reset caches that we can deterministically find by walking the reactivity hints\n    if (this.#smartDirtySets > 0) {\n      this.#resetDownstreamReactables(getMetadata(entity), fieldName);\n    }\n    // We could use this to invalidate m2o.get, but it doesn't work for collections\n    // with an orderBy, when the orderBy changes, so for now we use the blunt naiveCache.\n    // const field = meta.allFields[fieldName];\n    // if (field.kind === \"m2o\") {\n    //   const otherMeta = field.otherMetadata();\n    //   const set = this.smartCache[otherMeta.tagName]?.[field.otherFieldName];\n    //   if (set) {\n    //     for (const target of set) target.resetIsLoaded();\n    //     set.clear();\n    //   }\n    // }\n    if (this.#naiveCache.size > 0) {\n      for (const target of this.#naiveCache.values()) target.resetIsLoaded();\n      this.#naiveCache.clear();\n      this.#naiveDirtySets--;\n    }\n  }\n\n  /**\n   * Given a `meta+field`, statically find all downstream Reactables, and if any of those\n   * Reactables are a) in-memory already, and b) registered themselves as cached,\n   * tell them to reset.\n   */\n  #resetDownstreamReactables(meta: EntityMetadata, fieldName: string): void {\n    // These are reactables in other entities that are watching/reacting to this entity/fieldName\n    const reactables = meta.reactablesIncludingReadOnlyByField!.get(fieldName);\n    if (reactables === undefined) return;\n    for (const r of reactables) {\n      if (this.#smartDirtySets === 0) return;\n      // I.e. we've written to Author.firstName, and this reactable in Book/otherMeta depends on it\n      const otherMeta = getMetadata(r.cstr);\n      // Find any cache entries for this cstr + name\n      const set = this.#smartCache[otherMeta.tagName]?.[r.name];\n      if (set?.size > 0) {\n        for (const target of set) {\n          target.resetIsLoaded();\n          // Is this target itself a RF/RR? If so, transitively reset its cache as well.\n          const otherMeta = getMetadata(target.entity);\n          const otherField = otherMeta.allFields[target.fieldName];\n          if (\"derived\" in otherField && otherField.derived) {\n            this.#resetDownstreamReactables(otherMeta, otherField.fieldName);\n          }\n        }\n        set.clear();\n        this.#smartDirtySets--;\n      }\n    }\n  }\n}\n"],"mappings":";;;AA0BA,IAAa,gBAAb,MAA2B;CAIzB,cAAqE,CAAC;CAGtE,8BAAc,IAAI,IAAsB;CAExC,kBAAkB;CAElB,kBAAkB;;CAGlB,IAAI,QAAgC;EAClC,MAAM,OAAOA,uBAAAA,YAAY,OAAO,MAAM;EACtC,MAAM,MAAO,CAAC,KAAKC,YAAY,KAAK,aAAa,CAAC,EAAA,CAAG,OAAO,+BAAe,IAAI,IAAI;EACnF,IAAI,IAAI,SAAS,GACf,KAAKC;EAEP,IAAI,IAAI,MAAM;CAChB;CAEA,SAAS,QAAgC;EACvC,IAAI,KAAKC,YAAY,SAAS,GAAG,KAAKC;EACtC,KAAKD,YAAY,IAAI,MAAM;CAC7B;;CAGA,cAAc,QAAgB,WAAyB;EACrD,IAAI,KAAKD,oBAAoB,KAAK,KAAKE,oBAAoB,GAAG;EAE9D,IAAI,KAAKF,kBAAkB,GACzB,KAAKG,2BAA2BL,uBAAAA,YAAY,MAAM,GAAG,SAAS;EAahE,IAAI,KAAKG,YAAY,OAAO,GAAG;GAC7B,KAAK,MAAM,UAAU,KAAKA,YAAY,OAAO,GAAG,OAAO,cAAc;GACrE,KAAKA,YAAY,MAAM;GACvB,KAAKC;EACP;CACF;;;;;;CAOA,2BAA2B,MAAsB,WAAyB;EAExE,MAAM,aAAa,KAAK,mCAAoC,IAAI,SAAS;EACzE,IAAI,eAAe,KAAA,GAAW;EAC9B,KAAK,MAAM,KAAK,YAAY;GAC1B,IAAI,KAAKF,oBAAoB,GAAG;GAEhC,MAAM,YAAYF,uBAAAA,YAAY,EAAE,IAAI;GAEpC,MAAM,MAAM,KAAKC,YAAY,UAAU,QAAQ,GAAG,EAAE;GACpD,IAAI,KAAK,OAAO,GAAG;IACjB,KAAK,MAAM,UAAU,KAAK;KACxB,OAAO,cAAc;KAErB,MAAM,YAAYD,uBAAAA,YAAY,OAAO,MAAM;KAC3C,MAAM,aAAa,UAAU,UAAU,OAAO;KAC9C,IAAI,aAAa,cAAc,WAAW,SACxC,KAAKK,2BAA2B,WAAW,WAAW,SAAS;IAEnE;IACA,IAAI,MAAM;IACV,KAAKH;GACP;EACF;CACF;AACF"}

package/build/{IsLoadedCache.d.cts → loading/IsLoadedCache.d.cts}

@@ -1,5 +1,5 @@
-import { Entity } from "./Entity.cjs";
-//#region src/IsLoadedCache.d.ts
+import { Entity } from "../Entity.cjs";
+//#region src/loading/IsLoadedCache.d.ts
 /**
  * Interface for our relations that have dynamic & expensive `isLoaded` checks.
  *

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsLoadedCache.d.cts","names":[],"sources":["../../src/loading/IsLoadedCache.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAmBiB;EACf,QAAQ;EACR;EACA;EACA;;cAGW;;;EAcX,IAAI,QAAQ;EASZ,SAAS,QAAQ;;EAMjB,cAAc,QAAQ,QAAQ"}

package/build/{IsLoadedCache.d.mts → loading/IsLoadedCache.d.mts}

@@ -1,5 +1,5 @@
-import { Entity } from "./Entity.mjs";
-//#region src/IsLoadedCache.d.ts
+import { Entity } from "../Entity.mjs";
+//#region src/loading/IsLoadedCache.d.ts
 /**
  * Interface for our relations that have dynamic & expensive `isLoaded` checks.
  *

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

@@ -0,0 +1 @@
+{"version":3,"file":"IsLoadedCache.d.mts","names":[],"sources":["../../src/loading/IsLoadedCache.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAmBiB;EACf,QAAQ;EACR;EACA;EACA;;cAGW;;;EAcX,IAAI,QAAQ;EASZ,SAAS,QAAQ;;EAMjB,cAAc,QAAQ,QAAQ"}

package/build/{IsLoadedCache.js → loading/IsLoadedCache.js}

@@ -1,6 +1,5 @@
-import { getMetadata } from "./EntityMetadata.js";
-import "./Entity.js";
-//#region src/IsLoadedCache.ts
+import { getMetadata } from "../EntityMetadata.js";
+//#region src/loading/IsLoadedCache.ts
 var IsLoadedCache = class {
 	#smartCache = {};
 	#naiveCache = /* @__PURE__ */ new Set();

package/build/{IsLoadedCache.cjs.map → loading/IsLoadedCache.js.map}

@@ -1 +1 @@
-{"version":3,"file":"IsLoadedCache.cjs","names":["getMetadata","#smartCache","#smartDirtySets","#naiveCache","#naiveDirtySets","#resetDownstreamReactables"],"sources":["../src/IsLoadedCache.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type EntityMetadata, getMetadata } from \"./EntityMetadata.ts\";\n\n/**\n * Interface for our relations that have dynamic & expensive `isLoaded` checks.\n *\n * ...and also `OneToManyCollection.get` calls.\n *\n * The primary m2o/o2m/m2m relations all have trivial `isLoaded` checks--are they\n * loaded or not.\n *\n * But for \"composite relations\", i.e. a ReactiveField or ReactiveRelation whose\n * \"load-ness\" is calculated by evaluating its load hint across a subgraph of entities\n * & relations, load-ness can be more dynamic true-then-false, as its subgraph changes.\n *\n * To avoid performance issues (see https://github.com/joist-orm/joist-orm/issues/1166),\n * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven\n * cache invalidation whenever relations are mutated (via a hook in `setField`).\n */\nexport interface IsLoadedCachable {\n  entity: Entity;\n  fieldName: string;\n  isLoaded: boolean;\n  resetIsLoaded(): void;\n}\n\nexport class IsLoadedCache {\n  // Cache of `{ tag -> { fieldName -> Set<IsLoadedCachable> } }` to hold derived relations\n  // we can selectively invalidate by walking from the mutated field to any downstream\n  // cacheables.\n  #smartCache: Record<string, Record<string, Set<IsLoadedCachable>>> = {};\n  // A dumb cache for things that are hard selectively invalidate (o2m.get, recursive collections,\n  // and custom references/collections), so any mutation resets these.\n  #naiveCache = new Set<IsLoadedCachable>();\n  // Counter to skip reactive hint walking when no smart cache sets are populated.\n  #smartDirtySets = 0;\n  // Counter to fast-path resetIsLoaded when the naive cache is empty.\n  #naiveDirtySets = 0;\n\n  /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */\n  add(target: IsLoadedCachable): void {\n    const meta = getMetadata(target.entity);\n    const set = ((this.#smartCache[meta.tagName] ??= {})[target.fieldName] ??= new Set());\n    if (set.size === 0) {\n      this.#smartDirtySets++;\n    }\n    set.add(target);\n  }\n\n  addNaive(target: IsLoadedCachable): void {\n    if (this.#naiveCache.size === 0) this.#naiveDirtySets++;\n    this.#naiveCache.add(target);\n  }\n\n  /** Resets any in-memory #isLoaded/#isCached caches that depend on `entity.fieldName`. */\n  resetIsLoaded(entity: Entity, fieldName: string): void {\n    if (this.#smartDirtySets === 0 && this.#naiveDirtySets === 0) return;\n    // Reset caches that we can deterministically find by walking the reactivity hints\n    if (this.#smartDirtySets > 0) {\n      this.#resetDownstreamReactables(getMetadata(entity), fieldName);\n    }\n    // We could use this to invalidate m2o.get, but it doesn't work for collections\n    // with an orderBy, when the orderBy changes, so for now we use the blunt naiveCache.\n    // const field = meta.allFields[fieldName];\n    // if (field.kind === \"m2o\") {\n    //   const otherMeta = field.otherMetadata();\n    //   const set = this.smartCache[otherMeta.tagName]?.[field.otherFieldName];\n    //   if (set) {\n    //     for (const target of set) target.resetIsLoaded();\n    //     set.clear();\n    //   }\n    // }\n    if (this.#naiveCache.size > 0) {\n      for (const target of this.#naiveCache.values()) target.resetIsLoaded();\n      this.#naiveCache.clear();\n      this.#naiveDirtySets--;\n    }\n  }\n\n  /**\n   * Given a `meta+field`, statically find all downstream Reactables, and if any of those\n   * Reactables are a) in-memory already, and b) registered themselves as cached,\n   * tell them to reset.\n   */\n  #resetDownstreamReactables(meta: EntityMetadata, fieldName: string): void {\n    // These are reactables in other entities that are watching/reacting to this entity/fieldName\n    const reactables = meta.reactablesIncludingReadOnlyByField!.get(fieldName);\n    if (reactables === undefined) return;\n    for (const r of reactables) {\n      if (this.#smartDirtySets === 0) return;\n      // I.e. we've written to Author.firstName, and this reactable in Book/otherMeta depends on it\n      const otherMeta = getMetadata(r.cstr);\n      // Find any cache entries for this cstr + name\n      const set = this.#smartCache[otherMeta.tagName]?.[r.name];\n      if (set?.size > 0) {\n        for (const target of set) {\n          target.resetIsLoaded();\n          // Is this target itself a RF/RR? If so, transitively reset its cache as well.\n          const otherMeta = getMetadata(target.entity);\n          const otherField = otherMeta.allFields[target.fieldName];\n          if (\"derived\" in otherField && otherField.derived) {\n            this.#resetDownstreamReactables(otherMeta, otherField.fieldName);\n          }\n        }\n        set.clear();\n        this.#smartDirtySets--;\n      }\n    }\n  }\n}\n"],"mappings":";;;;AA0BA,IAAa,gBAAb,MAA2B;CAIzB,cAAqE,CAAC;CAGtE,8BAAc,IAAI,IAAsB;CAExC,kBAAkB;CAElB,kBAAkB;;CAGlB,IAAI,QAAgC;EAClC,MAAM,OAAOA,uBAAAA,YAAY,OAAO,MAAM;EACtC,MAAM,MAAO,CAAC,KAAKC,YAAY,KAAK,aAAa,CAAC,EAAA,CAAG,OAAO,+BAAe,IAAI,IAAI;EACnF,IAAI,IAAI,SAAS,GACf,KAAKC;EAEP,IAAI,IAAI,MAAM;CAChB;CAEA,SAAS,QAAgC;EACvC,IAAI,KAAKC,YAAY,SAAS,GAAG,KAAKC;EACtC,KAAKD,YAAY,IAAI,MAAM;CAC7B;;CAGA,cAAc,QAAgB,WAAyB;EACrD,IAAI,KAAKD,oBAAoB,KAAK,KAAKE,oBAAoB,GAAG;EAE9D,IAAI,KAAKF,kBAAkB,GACzB,KAAKG,2BAA2BL,uBAAAA,YAAY,MAAM,GAAG,SAAS;EAahE,IAAI,KAAKG,YAAY,OAAO,GAAG;GAC7B,KAAK,MAAM,UAAU,KAAKA,YAAY,OAAO,GAAG,OAAO,cAAc;GACrE,KAAKA,YAAY,MAAM;GACvB,KAAKC;EACP;CACF;;;;;;CAOA,2BAA2B,MAAsB,WAAyB;EAExE,MAAM,aAAa,KAAK,mCAAoC,IAAI,SAAS;EACzE,IAAI,eAAe,KAAA,GAAW;EAC9B,KAAK,MAAM,KAAK,YAAY;GAC1B,IAAI,KAAKF,oBAAoB,GAAG;GAEhC,MAAM,YAAYF,uBAAAA,YAAY,EAAE,IAAI;GAEpC,MAAM,MAAM,KAAKC,YAAY,UAAU,QAAQ,GAAG,EAAE;GACpD,IAAI,KAAK,OAAO,GAAG;IACjB,KAAK,MAAM,UAAU,KAAK;KACxB,OAAO,cAAc;KAErB,MAAM,YAAYD,uBAAAA,YAAY,OAAO,MAAM;KAC3C,MAAM,aAAa,UAAU,UAAU,OAAO;KAC9C,IAAI,aAAa,cAAc,WAAW,SACxC,KAAKK,2BAA2B,WAAW,WAAW,SAAS;IAEnE;IACA,IAAI,MAAM;IACV,KAAKH;GACP;EACF;CACF;AACF"}
+{"version":3,"file":"IsLoadedCache.js","names":["#smartCache","#smartDirtySets","#naiveCache","#naiveDirtySets","#resetDownstreamReactables"],"sources":["../../src/loading/IsLoadedCache.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\n\n/**\n * Interface for our relations that have dynamic & expensive `isLoaded` checks.\n *\n * ...and also `OneToManyCollection.get` calls.\n *\n * The primary m2o/o2m/m2m relations all have trivial `isLoaded` checks--are they\n * loaded or not.\n *\n * But for \"composite relations\", i.e. a ReactiveField or ReactiveRelation whose\n * \"load-ness\" is calculated by evaluating its load hint across a subgraph of entities\n * & relations, load-ness can be more dynamic true-then-false, as its subgraph changes.\n *\n * To avoid performance issues (see https://github.com/joist-orm/joist-orm/issues/1166),\n * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven\n * cache invalidation whenever relations are mutated (via a hook in `setField`).\n */\nexport interface IsLoadedCachable {\n  entity: Entity;\n  fieldName: string;\n  isLoaded: boolean;\n  resetIsLoaded(): void;\n}\n\nexport class IsLoadedCache {\n  // Cache of `{ tag -> { fieldName -> Set<IsLoadedCachable> } }` to hold derived relations\n  // we can selectively invalidate by walking from the mutated field to any downstream\n  // cacheables.\n  #smartCache: Record<string, Record<string, Set<IsLoadedCachable>>> = {};\n  // A dumb cache for things that are hard selectively invalidate (o2m.get, recursive collections,\n  // and custom references/collections), so any mutation resets these.\n  #naiveCache = new Set<IsLoadedCachable>();\n  // Counter to skip reactive hint walking when no smart cache sets are populated.\n  #smartDirtySets = 0;\n  // Counter to fast-path resetIsLoaded when the naive cache is empty.\n  #naiveDirtySets = 0;\n\n  /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */\n  add(target: IsLoadedCachable): void {\n    const meta = getMetadata(target.entity);\n    const set = ((this.#smartCache[meta.tagName] ??= {})[target.fieldName] ??= new Set());\n    if (set.size === 0) {\n      this.#smartDirtySets++;\n    }\n    set.add(target);\n  }\n\n  addNaive(target: IsLoadedCachable): void {\n    if (this.#naiveCache.size === 0) this.#naiveDirtySets++;\n    this.#naiveCache.add(target);\n  }\n\n  /** Resets any in-memory #isLoaded/#isCached caches that depend on `entity.fieldName`. */\n  resetIsLoaded(entity: Entity, fieldName: string): void {\n    if (this.#smartDirtySets === 0 && this.#naiveDirtySets === 0) return;\n    // Reset caches that we can deterministically find by walking the reactivity hints\n    if (this.#smartDirtySets > 0) {\n      this.#resetDownstreamReactables(getMetadata(entity), fieldName);\n    }\n    // We could use this to invalidate m2o.get, but it doesn't work for collections\n    // with an orderBy, when the orderBy changes, so for now we use the blunt naiveCache.\n    // const field = meta.allFields[fieldName];\n    // if (field.kind === \"m2o\") {\n    //   const otherMeta = field.otherMetadata();\n    //   const set = this.smartCache[otherMeta.tagName]?.[field.otherFieldName];\n    //   if (set) {\n    //     for (const target of set) target.resetIsLoaded();\n    //     set.clear();\n    //   }\n    // }\n    if (this.#naiveCache.size > 0) {\n      for (const target of this.#naiveCache.values()) target.resetIsLoaded();\n      this.#naiveCache.clear();\n      this.#naiveDirtySets--;\n    }\n  }\n\n  /**\n   * Given a `meta+field`, statically find all downstream Reactables, and if any of those\n   * Reactables are a) in-memory already, and b) registered themselves as cached,\n   * tell them to reset.\n   */\n  #resetDownstreamReactables(meta: EntityMetadata, fieldName: string): void {\n    // These are reactables in other entities that are watching/reacting to this entity/fieldName\n    const reactables = meta.reactablesIncludingReadOnlyByField!.get(fieldName);\n    if (reactables === undefined) return;\n    for (const r of reactables) {\n      if (this.#smartDirtySets === 0) return;\n      // I.e. we've written to Author.firstName, and this reactable in Book/otherMeta depends on it\n      const otherMeta = getMetadata(r.cstr);\n      // Find any cache entries for this cstr + name\n      const set = this.#smartCache[otherMeta.tagName]?.[r.name];\n      if (set?.size > 0) {\n        for (const target of set) {\n          target.resetIsLoaded();\n          // Is this target itself a RF/RR? If so, transitively reset its cache as well.\n          const otherMeta = getMetadata(target.entity);\n          const otherField = otherMeta.allFields[target.fieldName];\n          if (\"derived\" in otherField && otherField.derived) {\n            this.#resetDownstreamReactables(otherMeta, otherField.fieldName);\n          }\n        }\n        set.clear();\n        this.#smartDirtySets--;\n      }\n    }\n  }\n}\n"],"mappings":";;AA0BA,IAAa,gBAAb,MAA2B;CAIzB,cAAqE,CAAC;CAGtE,8BAAc,IAAI,IAAsB;CAExC,kBAAkB;CAElB,kBAAkB;;CAGlB,IAAI,QAAgC;EAClC,MAAM,OAAO,YAAY,OAAO,MAAM;EACtC,MAAM,MAAO,CAAC,KAAKA,YAAY,KAAK,aAAa,CAAC,EAAA,CAAG,OAAO,+BAAe,IAAI,IAAI;EACnF,IAAI,IAAI,SAAS,GACf,KAAKC;EAEP,IAAI,IAAI,MAAM;CAChB;CAEA,SAAS,QAAgC;EACvC,IAAI,KAAKC,YAAY,SAAS,GAAG,KAAKC;EACtC,KAAKD,YAAY,IAAI,MAAM;CAC7B;;CAGA,cAAc,QAAgB,WAAyB;EACrD,IAAI,KAAKD,oBAAoB,KAAK,KAAKE,oBAAoB,GAAG;EAE9D,IAAI,KAAKF,kBAAkB,GACzB,KAAKG,2BAA2B,YAAY,MAAM,GAAG,SAAS;EAahE,IAAI,KAAKF,YAAY,OAAO,GAAG;GAC7B,KAAK,MAAM,UAAU,KAAKA,YAAY,OAAO,GAAG,OAAO,cAAc;GACrE,KAAKA,YAAY,MAAM;GACvB,KAAKC;EACP;CACF;;;;;;CAOA,2BAA2B,MAAsB,WAAyB;EAExE,MAAM,aAAa,KAAK,mCAAoC,IAAI,SAAS;EACzE,IAAI,eAAe,KAAA,GAAW;EAC9B,KAAK,MAAM,KAAK,YAAY;GAC1B,IAAI,KAAKF,oBAAoB,GAAG;GAEhC,MAAM,YAAY,YAAY,EAAE,IAAI;GAEpC,MAAM,MAAM,KAAKD,YAAY,UAAU,QAAQ,GAAG,EAAE;GACpD,IAAI,KAAK,OAAO,GAAG;IACjB,KAAK,MAAM,UAAU,KAAK;KACxB,OAAO,cAAc;KAErB,MAAM,YAAY,YAAY,OAAO,MAAM;KAC3C,MAAM,aAAa,UAAU,UAAU,OAAO;KAC9C,IAAI,aAAa,cAAc,WAAW,SACxC,KAAKI,2BAA2B,WAAW,WAAW,SAAS;IAEnE;IACA,IAAI,MAAM;IACV,KAAKH;GACP;EACF;CACF;AACF"}

package/build/{loadHints.cjs → loading/loadHints.cjs}

@@ -1,12 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./typeMap.cjs");
-require("./relations/OneToOneReference.cjs");
-const require_reactiveHints = require("./reactiveHints.cjs");
-require("./normalizeHints.cjs");
-const require_utils = require("./utils.cjs");
-require("./relations/index.cjs");
-require("./Entity.cjs");
-//#region src/loadHints.ts
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
+const require_utils = require("../utils.cjs");
+//#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;
@@ -20,7 +15,7 @@ function isLoaded(entity, hint) {
 	} else if (typeof hint === "object") {
 		for (const entry of Object.entries(hint)) {
 			const [key, nestedHint] = entry;
-			const relation = require_reactiveHints.getRelationFromMaybePolyKey(entity, key);
+			const relation = require_reactivity_reactiveHints.getRelationFromMaybePolyKey(entity, key);
 			if (!relation || typeof relation.load !== "function") continue;
 			if (relation.isLoaded) {
 				const result = relation.get;
@@ -42,7 +37,7 @@ function isLoaded(entity, hint) {
 */
 function isLoadedForPopulate(entity, hint) {
 	if (typeof hint === "string") {
-		const relation = require_reactiveHints.getRelationFromMaybePolyKey(entity, hint);
+		const relation = require_reactivity_reactiveHints.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;
@@ -50,7 +45,7 @@ function isLoadedForPopulate(entity, hint) {
 	} else if (typeof hint === "object") {
 		for (const entry of Object.entries(hint)) {
 			const [key, nestedHint] = entry;
-			const relation = require_reactiveHints.getRelationFromMaybePolyKey(entity, key);
+			const relation = require_reactivity_reactiveHints.getRelationFromMaybePolyKey(entity, key);
 			if (!relation || typeof relation.load !== "function" || !relation.isLoaded) return false;
 			const result = relation.get;
 			if (Array.isArray(result)) {

package/build/loading/loadHints.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadHints.cjs","names":["getRelationFromMaybePolyKey"],"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,WAAWA,iCAAAA,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,WAAWA,iCAAAA,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,WAAWA,iCAAAA,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,cAAA,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/{loadHints.d.cts → loading/loadHints.d.cts}

@@ -1,17 +1,17 @@
-import { OptsOf } from "./typeMap.cjs";
-import { NormalizeHint } from "./normalizeHints.cjs";
-import { Collection, LoadedCollection } from "./relations/Collection.cjs";
-import { EnumCollection, LoadedEnumCollection } from "./relations/EnumCollection.cjs";
-import { AsyncMethod, LoadedMethod } from "./relations/hasAsyncMethod.cjs";
-import { LoadedProperty, Property } from "./relations/hasProperty.cjs";
-import { LoadedReference, Reference } from "./relations/Reference.cjs";
-import { Relation } from "./relations/Relation.cjs";
-import { LoadedOneToOneReference, OneToOneReference } from "./relations/OneToOneReference.cjs";
-import { LoadedReadOnlyCollection, ReadOnlyCollection } from "./relations/ReadOnlyCollection.cjs";
-import "./relations/index.cjs";
-import { MaybePromise, NullOrDefinedOr } from "./utils.cjs";
-import { Entity } from "./Entity.cjs";
-//#region src/loadHints.d.ts
+import { OptsOf } from "../typeMap.cjs";
+import { NormalizeHint } from "../normalizeHints.cjs";
+import { Collection, LoadedCollection } from "../relations/Collection.cjs";
+import { EnumCollection, LoadedEnumCollection } from "../relations/EnumCollection.cjs";
+import { AsyncMethod, LoadedMethod } from "../relations/hasAsyncMethod.cjs";
+import { LoadedProperty, Property } from "../relations/hasProperty.cjs";
+import { LoadedReference, Reference } from "../relations/Reference.cjs";
+import { Relation } from "../relations/Relation.cjs";
+import { LoadedOneToOneReference, OneToOneReference } from "../relations/OneToOneReference.cjs";
+import { LoadedReadOnlyCollection, ReadOnlyCollection } from "../relations/ReadOnlyCollection.cjs";
+import "../relations/index.cjs";
+import { MaybePromise, NullOrDefinedOr } from "../utils.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/loading/loadHints.d.ts
 declare const deepLoad: unique symbol;
 type DeepLoadHint<T extends Entity> = NestedLoadHint<T> & {
   [deepLoad]: true;

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

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

package/build/{loadHints.d.mts → loading/loadHints.d.mts}

@@ -1,17 +1,17 @@
-import { OptsOf } from "./typeMap.mjs";
-import { NormalizeHint } from "./normalizeHints.mjs";
-import { Collection, LoadedCollection } from "./relations/Collection.mjs";
-import { EnumCollection, LoadedEnumCollection } from "./relations/EnumCollection.mjs";
-import { AsyncMethod, LoadedMethod } from "./relations/hasAsyncMethod.mjs";
-import { LoadedProperty, Property } from "./relations/hasProperty.mjs";
-import { LoadedReference, Reference } from "./relations/Reference.mjs";
-import { Relation } from "./relations/Relation.mjs";
-import { LoadedOneToOneReference, OneToOneReference } from "./relations/OneToOneReference.mjs";
-import { LoadedReadOnlyCollection, ReadOnlyCollection } from "./relations/ReadOnlyCollection.mjs";
-import "./relations/index.mjs";
-import { MaybePromise, NullOrDefinedOr } from "./utils.mjs";
-import { Entity } from "./Entity.mjs";
-//#region src/loadHints.d.ts
+import { OptsOf } from "../typeMap.mjs";
+import { NormalizeHint } from "../normalizeHints.mjs";
+import { Collection, LoadedCollection } from "../relations/Collection.mjs";
+import { EnumCollection, LoadedEnumCollection } from "../relations/EnumCollection.mjs";
+import { AsyncMethod, LoadedMethod } from "../relations/hasAsyncMethod.mjs";
+import { LoadedProperty, Property } from "../relations/hasProperty.mjs";
+import { LoadedReference, Reference } from "../relations/Reference.mjs";
+import { Relation } from "../relations/Relation.mjs";
+import { LoadedOneToOneReference, OneToOneReference } from "../relations/OneToOneReference.mjs";
+import { LoadedReadOnlyCollection, ReadOnlyCollection } from "../relations/ReadOnlyCollection.mjs";
+import "../relations/index.mjs";
+import { MaybePromise, NullOrDefinedOr } from "../utils.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/loading/loadHints.d.ts
 declare const deepLoad: unique symbol;
 type DeepLoadHint<T extends Entity> = NestedLoadHint<T> & {
   [deepLoad]: true;

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

@@ -0,0 +1 @@
+{"version":3,"file":"loadHints.d.mts","names":[],"sources":["../../src/loading/loadHints.ts"],"mappings":";;;;;;;;;;;;;;cAuBM;KACD,aAAa,UAAU,UAAU,eAAe;GAAQ;;KAUxD;;KAGO,WAAW,UAAU,QAAQ,GAAG,WAC1C,UAAU,eAAe,qBAAqB,KAC1C,qBAAqB,GAAG,KACxB,UAAU,kBAAkB,qBAAqB,KAC/C,wBAAwB,GAAG,OAAO,GAAG,OACrC,UAAU,UAAU,qBAAqB,SAAS,KAChD,gBAAgB,GAAG,OAAO,GAAG,KAAK,KAClC,UAAU,WAAW,qBAAqB,KACxC,iBAAiB,GAAG,OAAO,GAAG,OAC9B,UAAU,mBAAmB,qBAAqB,KAChD,yBAAyB,GAAG,OAAO,GAAG,OACtC,UAAU,SAAS,qBAAqB,MAErC,mBAAmB,UAAU,uBACxC,eAAe,GAAG,OAAO,GAAG,MAAM,QAAQ,GAAG,MAC7C,0BAA0B,UAAU,YACpC,eAAe,GAAG,OAAO,GAAG,SAC5B,eAAe,GAAG,KACR,UAAU,YAAY,SAAS,SAAS,KACtC,aAAa,GAAG,GAAG;;KAIhC,eAAe,UAAU,QAAQ,KACpC,UAAU,eAAe,qBAAqB,KAC1C,qBAAqB,GAAG,KACxB,UAAU,kBAAkB,qBAAqB,KAC/C,wBAAwB,GAAG,OAAO,GAAG,aAAa,OAClD,UAAU,UAAU,qBAAqB,SAAS,KAChD,gBAAgB,GAAG,OAAO,GAAG,aAAa,KAAK,KAC/C,UAAU,WAAW,qBAAqB,KACxC,iBAAiB,GAAG,OAAO,GAAG,aAAa,OAC3C,UAAU,mBAAmB,qBAAqB,KAChD,yBAAyB,GAAG,OAAO,GAAG,aAAa,OACnD,UAAU,SAAS,qBAAqB,MAErC,mBAAmB,UAAU,uBACxC,eAAe,GAAG,OAAO,GAAG,aAAa,MAAM,QAAQ,GAAG,MAC1D,0BAA0B,UAAU,YACpC,eAAe,GAAG,OAAO,GAAG,aAAa,SACzC,eAAe,GAAG,KACR,UAAU,YAAY,SAAS,SAAS,KACtC,aAAa,GAAG,GAAG;;;;;;;;;;;;;;KAgBhC,iBAAiB,UAAU,QAAQ,GAAG,gBAAgB,UAAU,KACnE,EAAE,WAAW,sBAAsB,MAC/B,WAAW,SACT,EAAE,WAAW,kBAAkB,SAAS,KACtC,wBAAwB,GAAG,KAC3B,EAAE,WAAW,UAAU,SAAS,SAAS,KACvC,gBAAgB,GAAG,IAAI,aAE3B,WAAW,YAAY,MACrB,WAAW,SACT,EAAE,WAAW,WAAW,SAAS,KAC/B,iBAAiB,GAAG,cAEtB,EAAE,KACJ,EAAE;;;;;;;;KAUA,IAAI,UAAU,QAAQ,UAAU,OAAO,KAAK,OAAO,MAAM,OASlE,WAAW,IAAI,gBAAgB,IAAI,iBAAiB,GAAG,GAAG,KAAK,WAAW,GAAG,EAAE;;;;;KAOtE,QAAQ,UAAU,UAAU,OAAO,GAAG,aAAa;;iBAG/C,MAAM,UAAU,QAAQ,GAAG,IAAI,KAAK,IAAI;;;;;;;;KAW5C,SAAS,UAAU,uBAClB,WAAW,KAAK,cAAc,EAAE,4BAA4B,IAAI,cAAc,EAAE;;;;;;;;;KAWjF,cAAc,KACxB,UAAU,0BAA0B,KAChC,IACA,UAAU,qBAAqB,UAC7B,IACA,UAAU,sBAAsB,KAC9B,IACA,UAAU,8BAA8B,KACtC,IACA,UAAU,4BAA4B,KACpC,IACA,UAAU,oBAAoB,KAG5B,iBAAiB,UAAU,sBAAsB,IAAI;;;;;;;;KAUzD,SAAS,UAAU,iBACpB,SAAS,eAChB,oBAAoB,SAAS,eAC7B,eAAe;KAEP,eAAe,UAAU,aAElC,WAAW,SAAS,MAAM,SAAS,GAAG,kBAAiB,UAAU,UAAS,SAAS;;KAI1E,OAAO,UAAU,QAAQ,KAAK,OACvC,WAAW,UAAU,cAAc,KAAK,UAAU,aAAa,KAC5D,eAAe,GAAG,EAAE,MACpB,WAAW,GAAG,EAAE,IAAI,cAAc,GAAG;;iBAI3B,SAAS,UAAU,QAAQ,UAAU,SAAS,IAAI,QAAQ,GAAG,MAAM,IAAI,UAAU,OAAO,GAAG;;;;;;;;;iBAwC3F,oBAAoB,UAAU,QAAQ,UAAU,SAAS,IACvE,QAAQ,GACR,MAAM,IACL,UAAU,OAAO,GAAG;iBA6BP,kBAAkB,UAAU,QAAQ,UAAU,SAAS,IAAI,GACzE,QAAQ,GACR,MAAM,GACN,KAAK,QAAQ,OAAO,GAAG,OAAO,IAC7B,aAAa;;;;;;iBASA,aAAa,UAAU,cAAc,UAAU,SAAS,IACtE,QAAQ,GACR,MAAM,YACG,UAAU,OAAO,GAAG;;;;;;iBASf,aAAa,UAAU,cAAc,UAAU,SAAS,IAAI,QAAQ,GAAG,MAAM,IAAI,OAAO,GAAG;;;;;;iBAU3F,aAAa,UAAU,cAAc,UAAU,SAAS,IAAI,QAAQ,GAAG,MAAM,IAAI,OAAO,GAAG;;KAK/F,YAAY,UAAU,UAAU,QAAQ,GAAG;KAGlD,QAAQ,GAAG,KAAK,KAAK,MAAM,WAAW,IAAI,EAAE,WAAW,IAAI,mBAAkB"}

package/build/{loadHints.js → loading/loadHints.js}

@@ -1,11 +1,6 @@
-import "./typeMap.js";
-import "./relations/OneToOneReference.js";
-import { getRelationFromMaybePolyKey } from "./reactiveHints.js";
-import "./normalizeHints.js";
-import { fail } from "./utils.js";
-import "./relations/index.js";
-import "./Entity.js";
-//#region src/loadHints.ts
+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;

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/{loadLens.cjs → loading/loadLens.cjs}

@@ -1,13 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_relations_AbstractRelationImpl = require("./relations/AbstractRelationImpl.cjs");
-const require_relations_hasProperty = require("./relations/hasProperty.cjs");
-require("./loadHints.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/loadLens.ts
+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.
 *

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/{loadLens.d.cts → loading/loadLens.d.cts}

@@ -1,7 +1,7 @@
 import { LoadHint } from "./loadHints.cjs";
-import { EntityMetadata, Field } from "./EntityMetadata.cjs";
-import { Entity } from "./Entity.cjs";
-//#region src/loadLens.d.ts
+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>;