joist-core 2.3.0 → 2.4.0

package/build/keys.js

@@ -1,197 +1,164 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toIdOf = toIdOf;
-exports.maybeResolveReferenceToId = maybeResolveReferenceToId;
-exports.keyToNumber = keyToNumber;
-exports.keyToTaggedId = keyToTaggedId;
-exports.assertIdsAreTagged = assertIdsAreTagged;
-exports.isTaggedId = isTaggedId;
-exports.assertIdIsTagged = assertIdIsTagged;
-exports.toTaggedId = toTaggedId;
-exports.ensureTagged = ensureTagged;
-exports.tagId = tagId;
-exports.tagIds = tagIds;
-exports.deTagId = deTagId;
-exports.deTagIds = deTagIds;
-exports.unsafeDeTagIds = unsafeDeTagIds;
-exports.tagFromId = tagFromId;
-const BaseEntity_1 = require("./BaseEntity");
-const Entity_1 = require("./Entity");
-const EntityMetadata_1 = require("./EntityMetadata");
-const utils_1 = require("./utils");
-const tagDelimiter = ":";
+import "./relations/index.js";
+import { assertNever, fail } from "./utils.js";
+import { getMetadata } from "./EntityMetadata.js";
+import "./EntityManager.js";
+import { isEntity } from "./Entity.js";
+import { BaseEntity } from "./BaseEntity.js";
+//#region src/keys.ts
+let tagDelimiter = ":";
+/** Sets the process-wide tagged-id format during metadata boot. */
+function setTaggedIdDelimiter(delimiter) {
+	tagDelimiter = delimiter;
+}
 /** Converts our internal/always-tagged `id` to the domain entity's `id` type (could be a number or uuid). */
 function toIdOf(meta, id) {
-    if (!id)
-        return undefined;
-    switch (meta.idType) {
-        case "number":
-            return Number(deTagId(meta, id));
-        case "tagged-string":
-            return id;
-        case "untagged-string":
-            return deTagId(meta, id);
-        default:
-            return (0, utils_1.assertNever)(meta.idType);
-    }
-}
-// Before a referred-to object is saved, we keep its instance in our data
-// map, and then assume it will be persisted before we're asked to persist
+	if (!id) return void 0;
+	switch (meta.idType) {
+		case "number": return Number(deTagId(meta, id));
+		case "tagged-string": return id;
+		case "untagged-string": return deTagId(meta, id);
+		default: return assertNever(meta.idType);
+	}
+}
 function maybeResolveReferenceToId(value) {
-    return typeof value === "string" ? value : value?.idTaggedMaybe;
+	return typeof value === "string" ? value : value?.idTaggedMaybe;
 }
 function keyToNumber(meta, value) {
-    if (value === undefined || value === null) {
-        return undefined;
-    }
-    else if (typeof value === "number") {
-        return value;
-    }
-    else if (typeof value === "string") {
-        const [tag, id] = value.split(tagDelimiter);
-        if (id === undefined) {
-            return maybeNumberUnlessUuid(meta, value);
-        }
-        if (tag !== meta.tagName) {
-            throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${value}`);
-        }
-        return maybeNumberUnlessUuid(meta, id);
-    }
-    else {
-        throw new Error(`Invalid key ${value}`);
-    }
-}
-// If we're using UUIDs, just lie to the type system and pretend they're numbers.
+	if (value === void 0 || value === null) return;
+	else if (typeof value === "number") return value;
+	else if (typeof value === "string") {
+		if (tagDelimiter === void 0) return maybeNumberUnlessUuid(meta, value.startsWith(meta.tagName) ? value.slice(meta.tagName.length) : value);
+		const delimiterIndex = value.indexOf(tagDelimiter);
+		if (delimiterIndex === -1) return maybeNumberUnlessUuid(meta, value);
+		if (value.slice(0, delimiterIndex) !== meta.tagName) throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${value}`);
+		return maybeNumberUnlessUuid(meta, value.slice(delimiterIndex + tagDelimiter.length));
+	} else throw new Error(`Invalid key ${value}`);
+}
 function maybeNumberUnlessUuid(meta, key) {
-    switch (meta.idDbType) {
-        case "uuid":
-        case "text":
-            return key;
-        case "int":
-        case "bigint":
-            return Number(key);
-        default:
-            (0, utils_1.assertNever)(meta.idDbType);
-    }
+	switch (meta.idDbType) {
+		case "bigint":
+		case "uuid":
+		case "text": return key;
+		case "int": return Number(key);
+		default: assertNever(meta.idDbType);
+	}
 }
 /** Converts `dbValue` (big int, int, uuid) to a tagged string, unless its undefined. */
 function keyToTaggedId(meta, dbValue) {
-    return dbValue === undefined || dbValue === null ? undefined : `${meta.tagName}:${dbValue}`;
+	if (dbValue === void 0 || dbValue === null) return void 0;
+	return `${taggedIdPrefix(meta)}${dbValue}`;
+}
+/** Returns the entity tag followed by the configured ID delimiter. */
+function taggedIdPrefix(meta) {
+	return `${meta.tagName}${tagDelimiter ?? ""}`;
 }
-/** Fails if any keys are tagged; used by internal functions b/c we still allow most direct API input to be untagged. */
+/** Fails if any keys are untagged; internal batch-loader keys must always be tagged. */
 function assertIdsAreTagged(keys) {
-    for (const key of keys) {
-        if (key.indexOf(tagDelimiter) === -1)
-            throw new Error(`Key ${key} is missing a tag`);
-    }
-}
-// Either `tag:int` or `tag:uuid`.
-const validId = /[a-z]+:([0-9a-z\-]+)/;
-// Not super strict to allow uuid-ish ides
-const uuidIshId = /[0-9a-z\-]+/i;
+	for (const key of keys) if (!(tagDelimiter === void 0 ? validSlugId.test(key) : key.indexOf(tagDelimiter) !== -1)) throw new Error(`Key ${key} is missing a tag`);
+}
+const validSlugId = /^([a-z]+)(\d+)$/i;
+const uuidIshId = /[0-9a-z-]+/i;
 function isTaggedId(metaOrId, id) {
-    if (typeof metaOrId === "number") {
-        return false;
-    }
-    else if (typeof metaOrId === "string") {
-        return validId.test(metaOrId);
-    }
-    else {
-        const [tag, _id] = id.split(tagDelimiter);
-        if (metaOrId.tagName !== tag)
-            return false;
-        // With meta available, we can do more strict number or uuid checking
-        if (metaOrId.idDbType === "int" || metaOrId.idDbType === "bigint") {
-            return !Number.isNaN(Number(_id));
-        }
-        else if (metaOrId.idDbType === "uuid") {
-            return uuidIshId.test(_id);
-        }
-        else if (metaOrId.idDbType === "text") {
-            return true; // We should ask the IdAssigner what it thinks?
-        }
-        else {
-            return (0, utils_1.assertNever)(metaOrId.idDbType);
-        }
-    }
+	if (typeof metaOrId === "number") return false;
+	else if (typeof metaOrId === "string") return tagDelimiter === void 0 ? validSlugId.test(metaOrId) : hasTagDelimiter(metaOrId);
+	else return isTaggedIdForMeta(metaOrId, id);
 }
 function assertIdIsTagged(id) {
-    if (!isTaggedId(id)) {
-        throw new Error(`Key is not tagged ${id}`);
-    }
+	if (!isTaggedId(id)) throw new Error(`Key is not tagged ${id}`);
 }
 function toTaggedId(meta, id) {
-    if (typeof id === "number") {
-        return `${meta.tagName}${tagDelimiter}${id}`;
-    }
-    else if (typeof id === "string") {
-        // This seems odd, but is covered by a unit test, so I guess we need it?
-        if (id === "")
-            return undefined;
-        const i = id.indexOf(tagDelimiter);
-        if (i === -1)
-            return `${meta.tagName}${tagDelimiter}${id}`;
-        const tag = id.slice(0, i);
-        if (tag !== meta.tagName)
-            throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${id}`);
-    }
-    return id;
+	if (typeof id === "number") return `${meta.tagName}${tagDelimiter ?? ""}${id}`;
+	else if (typeof id === "string") {
+		if (id === "") return void 0;
+		if (tagDelimiter === void 0) {
+			const tag = validSlugId.exec(id)?.[1];
+			if (tag && tag !== meta.tagName) throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${id}`);
+			return tag ? id : `${meta.tagName}${id}`;
+		} else {
+			const i = id.indexOf(tagDelimiter);
+			if (i === -1) return `${meta.tagName}${tagDelimiter}${id}`;
+			if (id.slice(0, i) !== meta.tagName) throw new Error(`Invalid tagged id, expected tag ${meta.tagName}, got ${id}`);
+		}
+	}
+	return id;
 }
 /** Similar to `toTaggedId`, but we accept an entity for handling relations to not-yet-saved entities. */
 function ensureTagged(meta, value) {
-    return (0, Entity_1.isEntity)(value) ? value : toTaggedId(meta, value);
+	return isEntity(value) ? value : toTaggedId(meta, value);
 }
 function tagId(metaOrCstr, id) {
-    const tag = tagName(metaOrCstr);
-    if (typeof id === "number") {
-        return `${tag}${tagDelimiter}${id}`;
-    }
-    if (id === null || id === undefined) {
-        return undefined;
-    }
-    // Avoid using includes/split, for a faster indexOf + length + startsWith
-    const delimiterIndex = id.indexOf(tagDelimiter);
-    if (delimiterIndex !== -1) {
-        if (delimiterIndex !== tag.length || !id.startsWith(tag)) {
-            throw new Error(`Invalid tagged id, expected tag ${tag}, got ${id}`);
-        }
-        return id;
-    }
-    return `${tag}${tagDelimiter}${id}`;
+	const tag = metadata(metaOrCstr).tagName;
+	if (typeof id === "number") return `${tag}${tagDelimiter ?? ""}${id}`;
+	if (id === null || id === void 0) return;
+	if (tagDelimiter === void 0) {
+		const existingTag = validSlugId.exec(id)?.[1];
+		if (existingTag && existingTag !== tag) throw new Error(`Invalid tagged id, expected tag ${tag}, got ${id}`);
+		return existingTag ? id : `${tag}${id}`;
+	}
+	const delimiterIndex = id.indexOf(tagDelimiter);
+	if (delimiterIndex !== -1) {
+		if (delimiterIndex !== tag.length || !id.startsWith(tag)) throw new Error(`Invalid tagged id, expected tag ${tag}, got ${id}`);
+		return id;
+	}
+	return `${tag}${tagDelimiter}${id}`;
 }
 function tagIds(metaOrCstr, keys) {
-    return keys.map((k) => tagId(metaOrCstr, k));
+	return keys.map((k) => tagId(metaOrCstr, k));
 }
 function deTagId(entityOrMeta, id) {
-    const meta = entityOrMeta instanceof BaseEntity_1.BaseEntity ? (0, EntityMetadata_1.getMetadata)(entityOrMeta) : entityOrMeta;
-    id = id ?? entityOrMeta.id;
-    return id === undefined ? undefined : keyToNumber(meta, id).toString();
+	const meta = entityOrMeta instanceof BaseEntity ? getMetadata(entityOrMeta) : entityOrMeta;
+	id = id ?? entityOrMeta.id;
+	return id === void 0 ? void 0 : keyToNumber(meta, id).toString();
 }
 /** Removes the tag prefixes so we can use the keys for SQL operations. */
 function deTagIds(meta, keys) {
-    const deTagged = Array(keys.length);
-    for (let i = 0; i < keys.length; i++)
-        deTagged[i] = deTagId(meta, keys[i]);
-    return deTagged;
+	const deTagged = Array(keys.length);
+	for (let i = 0; i < keys.length; i++) deTagged[i] = deTagId(meta, keys[i]);
+	return deTagged;
 }
 /** Removes the tag prefixes so we can use the keys for SQL operations. */
 function unsafeDeTagIds(keys) {
-    const deTagged = Array(keys.length);
-    for (let i = 0; i < keys.length; i++) {
-        const maybeTagged = keys[i].split(tagDelimiter);
-        deTagged[i] = maybeTagged.length === 0 ? maybeTagged[0] : maybeTagged[1];
-    }
-    return deTagged;
+	const deTagged = Array(keys.length);
+	for (let i = 0; i < keys.length; i++) if (tagDelimiter === void 0) deTagged[i] = validSlugId.exec(keys[i])?.[2];
+	else {
+		const delimiterIndex = keys[i].indexOf(tagDelimiter);
+		deTagged[i] = delimiterIndex === -1 ? void 0 : keys[i].slice(delimiterIndex + tagDelimiter.length);
+	}
+	return deTagged;
 }
 /** Given a tagged id, returns its tag. */
 function tagFromId(id) {
-    const parts = id.split(tagDelimiter);
-    if (parts.length !== 2) {
-        (0, utils_1.fail)(`Unknown tagged id format: "${id}"`);
-    }
-    return parts[0];
-}
-function tagName(metaOrCstr) {
-    return typeof metaOrCstr === "function" ? (0, EntityMetadata_1.getMetadata)(metaOrCstr).tagName : metaOrCstr.tagName;
-}
+	if (tagDelimiter === void 0) return validSlugId.exec(id)?.[1] ?? fail(`Unknown tagged id format: "${id}"`);
+	const delimiterIndex = id.indexOf(tagDelimiter);
+	return delimiterIndex > 0 && delimiterIndex + tagDelimiter.length < id.length ? id.slice(0, delimiterIndex) : fail(`Unknown tagged id format: "${id}"`);
+}
+/** Returns the metadata needed to format an id. */
+function metadata(metaOrCstr) {
+	return typeof metaOrCstr === "function" ? getMetadata(metaOrCstr) : metaOrCstr;
+}
+/** Returns whether `id` has the tag and database id shape required by `meta`. */
+function isTaggedIdForMeta(meta, id) {
+	if (tagDelimiter === void 0) return validSlugId.exec(id)?.[1] === meta.tagName;
+	const delimiterIndex = id.indexOf(tagDelimiter);
+	if (delimiterIndex === -1) return false;
+	const tag = id.slice(0, delimiterIndex);
+	const untaggedId = id.slice(delimiterIndex + tagDelimiter.length);
+	if (meta.tagName !== tag) return false;
+	switch (meta.idDbType) {
+		case "int":
+		case "bigint": return !Number.isNaN(Number(untaggedId));
+		case "uuid": return uuidIshId.test(untaggedId);
+		case "text": return true;
+		default: return assertNever(meta.idDbType);
+	}
+}
+/** Returns whether `id` has a non-empty tag and value separated by the configured delimiter. */
+function hasTagDelimiter(id) {
+	if (tagDelimiter === void 0) return false;
+	const delimiterIndex = id.indexOf(tagDelimiter);
+	return delimiterIndex > 0 && delimiterIndex + tagDelimiter.length < id.length;
+}
+//#endregion
+export { assertIdIsTagged, assertIdsAreTagged, deTagId, deTagIds, ensureTagged, isTaggedId, keyToNumber, keyToTaggedId, maybeResolveReferenceToId, setTaggedIdDelimiter, tagFromId, tagId, tagIds, taggedIdPrefix, toIdOf, toTaggedId, unsafeDeTagIds };
+
 //# sourceMappingURL=keys.js.map

package/build/keys.js.map

@@ -1 +1 @@
-{"version":3,"file":"keys.js","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"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 `${taggedIdPrefix(meta)}${dbValue}`;\n}\n\n/** Returns the entity tag followed by the configured ID delimiter. */\nexport function taggedIdPrefix(meta: Pick<HasTagName, \"tagName\">): string {\n  return `${meta.tagName}${tagDelimiter ?? \"\"}`;\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":";;;;;;;AAOA,IAAI,eAAmC;;AAGvC,SAAgB,qBAAqB,WAAqC;CACxE,eAAe;AACjB;;AAWA,SAAgB,OAAyB,MAAyB,IAA+C;CAC/G,IAAI,CAAC,IAAI,OAAO,KAAA;CAChB,QAAQ,KAAK,QAAb;EACE,KAAK,UACH,OAAO,OAAO,QAAQ,MAAM,EAAE,CAAC;EACjC,KAAK,iBACH,OAAO;EACT,KAAK,mBACH,OAAO,QAAQ,MAAM,EAAE;EACzB,SACE,OAAO,YAAY,KAAK,MAAM;CAClC;AACF;AAIA,SAAgB,0BACd,OACsB;CACtB,OAAO,OAAO,UAAU,WAAW,QAAQ,OAAO;AACpD;AAKA,SAAgB,YAAY,MAAkB,OAAgC;CAC5E,IAAI,UAAU,KAAA,KAAa,UAAU,MACnC;MACK,IAAI,OAAO,UAAU,UAC1B,OAAO;MACF,IAAI,OAAO,UAAU,UAAU;EACpC,IAAI,iBAAiB,KAAA,GAEnB,OAAO,sBAAsB,MADlB,MAAM,WAAW,KAAK,OAAO,IAAI,MAAM,MAAM,KAAK,QAAQ,MAAM,IAAI,KAC1C;EAEvC,MAAM,iBAAiB,MAAM,QAAQ,YAAY;EACjD,IAAI,mBAAmB,IACrB,OAAO,sBAAsB,MAAM,KAAK;EAG1C,IADY,MAAM,MAAM,GAAG,cACrB,MAAM,KAAK,SACf,MAAM,IAAI,MAAM,mCAAmC,KAAK,QAAQ,QAAQ,OAAO;EAEjF,OAAO,sBAAsB,MAAM,MAAM,MAAM,iBAAiB,aAAa,MAAM,CAAC;CACtF,OACE,MAAM,IAAI,MAAM,eAAe,OAAO;AAE1C;AAGA,SAAS,sBAAsB,MAAkB,KAAqB;CACpE,QAAQ,KAAK,UAAb;EACE,KAAK;EACL,KAAK;EACL,KAAK,QACH,OAAO;EACT,KAAK,OACH,OAAO,OAAO,GAAG;EACnB,SACE,YAAY,KAAK,QAAQ;CAC7B;AACF;;AAGA,SAAgB,cAAc,MAAkB,SAAgD;CAC9F,IAAI,YAAY,KAAA,KAAa,YAAY,MAAM,OAAO,KAAA;CACtD,OAAO,GAAG,eAAe,IAAI,IAAI;AACnC;;AAGA,SAAgB,eAAe,MAA2C;CACxE,OAAO,GAAG,KAAK,UAAU,gBAAgB;AAC3C;;AAGA,SAAgB,mBAAmB,MAA+B;CAChE,KAAK,MAAM,OAAO,MAEhB,IAAI,EADa,iBAAiB,KAAA,IAAY,YAAY,KAAK,GAAG,IAAI,IAAI,QAAQ,YAAY,MAAM,KACrF,MAAM,IAAI,MAAM,OAAO,IAAI,kBAAkB;AAEhE;AAEA,MAAM,cAAc;AACpB,MAAM,YAAY;AAMlB,SAAgB,WAAW,UAAwC,IAAsB;CACvF,IAAI,OAAO,aAAa,UAEtB,OAAO;MACF,IAAI,OAAO,aAAa,UAE7B,OAAO,iBAAiB,KAAA,IAAY,YAAY,KAAK,QAAQ,IAAI,gBAAgB,QAAQ;MAGzF,OAAO,kBAAkB,UAAU,EAAG;AAE1C;AAEA,SAAgB,iBAAiB,IAAkB;CACjD,IAAI,CAAC,WAAW,EAAE,GAChB,MAAM,IAAI,MAAM,qBAAqB,IAAI;AAE7C;AAKA,SAAgB,WAAW,MAAkB,IAA8C;CACzF,IAAI,OAAO,OAAO,UAChB,OAAO,GAAG,KAAK,UAAU,gBAAgB,KAAK;MACzC,IAAI,OAAO,OAAO,UAAU;EAEjC,IAAI,OAAO,IAAI,OAAO,KAAA;EACtB,IAAI,iBAAiB,KAAA,GAAW;GAC9B,MAAM,MAAM,YAAY,KAAK,EAAE,CAAC,GAAG;GACnC,IAAI,OAAO,QAAQ,KAAK,SACtB,MAAM,IAAI,MAAM,mCAAmC,KAAK,QAAQ,QAAQ,IAAI;GAE9E,OAAO,MAAM,KAAK,GAAG,KAAK,UAAU;EACtC,OAAO;GACL,MAAM,IAAI,GAAG,QAAQ,YAAY;GACjC,IAAI,MAAM,IAAI,OAAO,GAAG,KAAK,UAAU,eAAe;GAEtD,IADY,GAAG,MAAM,GAAG,CAClB,MAAM,KAAK,SACf,MAAM,IAAI,MAAM,mCAAmC,KAAK,QAAQ,QAAQ,IAAI;EAEhF;CACF;CACA,OAAO;AACT;;AAGA,SAAgB,aACd,MACA,OAC0B;CAC1B,OAAO,SAAS,KAAK,IAAI,QAAQ,WAAW,MAAM,KAAK;AACzD;AAOA,SAAgB,MACd,YACA,IACoB;CAEpB,MAAM,MADO,SAAS,UACP,CAAC,CAAC;CACjB,IAAI,OAAO,OAAO,UAChB,OAAO,GAAG,MAAM,gBAAgB,KAAK;CAEvC,IAAI,OAAO,QAAQ,OAAO,KAAA,GACxB;CAEF,IAAI,iBAAiB,KAAA,GAAW;EAC9B,MAAM,cAAc,YAAY,KAAK,EAAE,CAAC,GAAG;EAC3C,IAAI,eAAe,gBAAgB,KACjC,MAAM,IAAI,MAAM,mCAAmC,IAAI,QAAQ,IAAI;EAErE,OAAO,cAAc,KAAK,GAAG,MAAM;CACrC;CAEA,MAAM,iBAAiB,GAAG,QAAQ,YAAY;CAC9C,IAAI,mBAAmB,IAAI;EACzB,IAAI,mBAAmB,IAAI,UAAU,CAAC,GAAG,WAAW,GAAG,GACrD,MAAM,IAAI,MAAM,mCAAmC,IAAI,QAAQ,IAAI;EAErE,OAAO;CACT;CACA,OAAO,GAAG,MAAM,eAAe;AACjC;AAKA,SAAgB,OACd,YACA,MACmB;CACnB,OAAO,KAAK,KAAK,MAAM,MAAM,YAAmB,CAAC,CAAC;AACpD;AAKA,SAAgB,QAAQ,cAAmC,IAA0C;CACnG,MAAM,OAAO,wBAAwB,aAAa,YAAY,YAAY,IAAK;CAC/E,KAAK,MAAO,aAAwB;CACpC,OAAO,OAAO,KAAA,IAAY,KAAA,IAAY,YAAY,MAAM,EAAE,CAAC,CAAC,SAAS;AACvE;;AAGA,SAAgB,SAAS,MAAkB,MAA4C;CACrF,MAAM,WAAW,MAAM,KAAK,MAAM;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,SAAS,KAAK,QAAQ,MAAM,KAAK,EAAE;CACzE,OAAO;AACT;;AAGA,SAAgB,eAAe,MAA4C;CACzE,MAAM,WAAW,MAAM,KAAK,MAAM;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,IAAI,iBAAiB,KAAA,GACnB,SAAS,KAAK,YAAY,KAAK,KAAK,EAAE,CAAC,GAAG;MACrC;EACL,MAAM,iBAAiB,KAAK,EAAE,CAAC,QAAQ,YAAY;EACnD,SAAS,KAAK,mBAAmB,KAAK,KAAA,IAAY,KAAK,EAAE,CAAC,MAAM,iBAAiB,aAAa,MAAM;CACtG;CAEF,OAAO;AACT;;AAGA,SAAgB,UAAU,IAAoB;CAC5C,IAAI,iBAAiB,KAAA,GACnB,OAAO,YAAY,KAAK,EAAE,CAAC,GAAG,MAAM,KAAK,8BAA8B,GAAG,EAAE;CAE9E,MAAM,iBAAiB,GAAG,QAAQ,YAAY;CAC9C,OAAO,iBAAiB,KAAK,iBAAiB,aAAa,SAAS,GAAG,SACnE,GAAG,MAAM,GAAG,cAAc,IAC1B,KAAK,8BAA8B,GAAG,EAAE;AAC9C;;AAGA,SAAS,SAAS,YAA6D;CAC7E,OAAO,OAAO,eAAe,aAAa,YAAY,UAAU,IAAI;AACtE;;AAGA,SAAS,kBAAkB,MAAkB,IAAqB;CAChE,IAAI,iBAAiB,KAAA,GACnB,OAAO,YAAY,KAAK,EAAE,CAAC,GAAG,OAAO,KAAK;CAE5C,MAAM,iBAAiB,GAAG,QAAQ,YAAY;CAC9C,IAAI,mBAAmB,IAAI,OAAO;CAClC,MAAM,MAAM,GAAG,MAAM,GAAG,cAAc;CACtC,MAAM,aAAa,GAAG,MAAM,iBAAiB,aAAa,MAAM;CAChE,IAAI,KAAK,YAAY,KAAK,OAAO;CACjC,QAAQ,KAAK,UAAb;EACE,KAAK;EACL,KAAK,UACH,OAAO,CAAC,OAAO,MAAM,OAAO,UAAU,CAAC;EACzC,KAAK,QACH,OAAO,UAAU,KAAK,UAAU;EAClC,KAAK,QACH,OAAO;EACT,SACE,OAAO,YAAY,KAAK,QAAQ;CACpC;AACF;;AAGA,SAAS,gBAAgB,IAAqB;CAC5C,IAAI,iBAAiB,KAAA,GAAW,OAAO;CACvC,MAAM,iBAAiB,GAAG,QAAQ,YAAY;CAC9C,OAAO,iBAAiB,KAAK,iBAAiB,aAAa,SAAS,GAAG;AACzE"}

package/build/loading/HintTree.cjs

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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
+* of which entities requested each specific node of the tree.
+*
+* I.e. if we're populating three publishers, two with `{ authors: "books" }` and one with
+* `{ authors: "reviews" }`, we'll end up with a tree like:
+*
+* ```
+*  {
+*    authors: {
+*      entities: [p1, p2, p3],
+*      hints: {
+*        books: { entities: [p1, p2], hints: {} },
+*        reviews: { entities: [p3], hints: {} },
+*      }
+*    }
+*  }
+* ```
+*
+* Which will let us preload `authors` for all three publishers, but `books` only for the
+* first two, and `reviews` only for the third, i.e. we can prevent over-fetching.
+*/
+function buildHintTree(hints) {
+	if (Array.isArray(hints)) {
+		if (hints.length > 0 && typeof hints[0] === "string") {
+			const root = {
+				entitiesKind: "none",
+				entities: /* @__PURE__ */ new Set(),
+				hints: {}
+			};
+			addHintNode(root, void 0, hints);
+			return root;
+		} else {
+			const root = {
+				entitiesKind: typeof hints[0].entity === "string" ? "ids" : "instances",
+				entities: /* @__PURE__ */ new Set(),
+				hints: {}
+			};
+			for (const { entity, hint } of hints) addHintNode(root, entity, hint);
+			return root;
+		}
+	} else {
+		const root = {
+			entitiesKind: "none",
+			entities: /* @__PURE__ */ new Set(),
+			hints: {}
+		};
+		addHintNode(root, void 0, hints);
+		return root;
+	}
+}
+function addHintNode(node, entity, hint) {
+	if (entity) node.entities.add(entity);
+	if (hint) for (const [key, nestedHint] of Object.entries(require_normalizeHints.normalizeHint(hint))) addHintNode(node.hints[key] ??= {
+		entitiesKind: node.entitiesKind,
+		entities: /* @__PURE__ */ new Set(),
+		hints: {}
+	}, entity, nestedHint);
+}
+//#endregion
+exports.buildHintTree = buildHintTree;
+
+//# sourceMappingURL=HintTree.cjs.map

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/loading/HintTree.d.cts

@@ -0,0 +1,45 @@
+import { LoadHint } from "./loadHints.cjs";
+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. */
+  entities: Set<E>;
+  /** A runtime indication of the type of `E`. */
+  entitiesKind: "instances" | "ids" | "none";
+  /** The hints to preload at this node, i.e. if `E` is `Author`, the `books: "reviews` or just `comments: {}`. */
+  hints: {
+    [key: string]: HintNode<E>;
+  };
+};
+/**
+ * Given a number of potentially overlapping load hints, i.e. `{ authors: "books" }` and
+ * `{ authors: "reviews" }`, combines them into a single `HintNode` tree, with bookkeeping
+ * of which entities requested each specific node of the tree.
+ *
+ * I.e. if we're populating three publishers, two with `{ authors: "books" }` and one with
+ * `{ authors: "reviews" }`, we'll end up with a tree like:
+ *
+ * ```
+ *  {
+ *    authors: {
+ *      entities: [p1, p2, p3],
+ *      hints: {
+ *        books: { entities: [p1, p2], hints: {} },
+ *        reviews: { entities: [p3], hints: {} },
+ *      }
+ *    }
+ *  }
+ * ```
+ *
+ * Which will let us preload `authors` for all three publishers, but `books` only for the
+ * first two, and `reviews` only for the third, i.e. we can prevent over-fetching.
+ */
+declare function buildHintTree<E extends EntityOrId>(hints: readonly {
+  entity: E;
+  hint: LoadHint<any> | undefined;
+}[] | LoadHint<any>): HintNode<E>;
+//#endregion
+export { EntityOrId, HintNode, buildHintTree };
+//# sourceMappingURL=HintTree.d.cts.map

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/loading/HintTree.d.mts

@@ -0,0 +1,45 @@
+import { LoadHint } from "./loadHints.mjs";
+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. */
+  entities: Set<E>;
+  /** A runtime indication of the type of `E`. */
+  entitiesKind: "instances" | "ids" | "none";
+  /** The hints to preload at this node, i.e. if `E` is `Author`, the `books: "reviews` or just `comments: {}`. */
+  hints: {
+    [key: string]: HintNode<E>;
+  };
+};
+/**
+ * Given a number of potentially overlapping load hints, i.e. `{ authors: "books" }` and
+ * `{ authors: "reviews" }`, combines them into a single `HintNode` tree, with bookkeeping
+ * of which entities requested each specific node of the tree.
+ *
+ * I.e. if we're populating three publishers, two with `{ authors: "books" }` and one with
+ * `{ authors: "reviews" }`, we'll end up with a tree like:
+ *
+ * ```
+ *  {
+ *    authors: {
+ *      entities: [p1, p2, p3],
+ *      hints: {
+ *        books: { entities: [p1, p2], hints: {} },
+ *        reviews: { entities: [p3], hints: {} },
+ *      }
+ *    }
+ *  }
+ * ```
+ *
+ * Which will let us preload `authors` for all three publishers, but `books` only for the
+ * first two, and `reviews` only for the third, i.e. we can prevent over-fetching.
+ */
+declare function buildHintTree<E extends EntityOrId>(hints: readonly {
+  entity: E;
+  hint: LoadHint<any> | undefined;
+}[] | LoadHint<any>): HintNode<E>;
+//#endregion
+export { EntityOrId, HintNode, buildHintTree };
+//# sourceMappingURL=HintTree.d.mts.map

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/loading/HintTree.js

@@ -0,0 +1,66 @@
+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
+* of which entities requested each specific node of the tree.
+*
+* I.e. if we're populating three publishers, two with `{ authors: "books" }` and one with
+* `{ authors: "reviews" }`, we'll end up with a tree like:
+*
+* ```
+*  {
+*    authors: {
+*      entities: [p1, p2, p3],
+*      hints: {
+*        books: { entities: [p1, p2], hints: {} },
+*        reviews: { entities: [p3], hints: {} },
+*      }
+*    }
+*  }
+* ```
+*
+* Which will let us preload `authors` for all three publishers, but `books` only for the
+* first two, and `reviews` only for the third, i.e. we can prevent over-fetching.
+*/
+function buildHintTree(hints) {
+	if (Array.isArray(hints)) {
+		if (hints.length > 0 && typeof hints[0] === "string") {
+			const root = {
+				entitiesKind: "none",
+				entities: /* @__PURE__ */ new Set(),
+				hints: {}
+			};
+			addHintNode(root, void 0, hints);
+			return root;
+		} else {
+			const root = {
+				entitiesKind: typeof hints[0].entity === "string" ? "ids" : "instances",
+				entities: /* @__PURE__ */ new Set(),
+				hints: {}
+			};
+			for (const { entity, hint } of hints) addHintNode(root, entity, hint);
+			return root;
+		}
+	} else {
+		const root = {
+			entitiesKind: "none",
+			entities: /* @__PURE__ */ new Set(),
+			hints: {}
+		};
+		addHintNode(root, void 0, hints);
+		return root;
+	}
+}
+function addHintNode(node, entity, hint) {
+	if (entity) node.entities.add(entity);
+	if (hint) for (const [key, nestedHint] of Object.entries(normalizeHint(hint))) addHintNode(node.hints[key] ??= {
+		entitiesKind: node.entitiesKind,
+		entities: /* @__PURE__ */ new Set(),
+		hints: {}
+	}, entity, nestedHint);
+}
+//#endregion
+export { buildHintTree };
+
+//# sourceMappingURL=HintTree.js.map

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"}