joist-core 2.3.0 → 2.4.0-next.2

package/build/EntityMetadata.cjs

@@ -0,0 +1,75 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_configure = require("./configure.cjs");
+require("./config.cjs");
+require("./EntityManager.cjs");
+const require_Entity = require("./Entity.cjs");
+const require_BaseEntity = require("./BaseEntity.cjs");
+//#region src/EntityMetadata.ts
+function getMetadata(param) {
+	if (!param) throw new Error(`Cannot getMetadata of ${param}`);
+	return typeof param === "function" ? param.metadata : "cstr" in param ? param : require_BaseEntity.getInstanceData(param).metadata;
+}
+/** Returns the metadata layer that declares `fieldName`, i.e. `Task.tags` for `TaskOld.tags`. */
+function getMetadataForField(meta, fieldName) {
+	if (!meta.allFields[fieldName]) throw new Error(`Field '${fieldName}' not found on ${meta.type}`);
+	while (!(fieldName in meta.fields) && meta.allFields[fieldName]?.specialized !== true && meta.baseType) meta = require_configure.getMetadataForType(meta.baseType);
+	return meta;
+}
+function isOneToManyField(ormField) {
+	return ormField.kind === "o2m";
+}
+function isManyToOneField(ormField) {
+	return ormField.kind === "m2o";
+}
+function isManyToManyField(ormField) {
+	return ormField.kind === "m2m";
+}
+function isManyToManyEnumField(ormField) {
+	return ormField.kind === "m2mEnum";
+}
+function isOneToOneField(ormField) {
+	return ormField.kind === "o2o";
+}
+function isPolymorphicField(ormField) {
+	return ormField.kind === "poly";
+}
+function isReferenceField(ormField) {
+	return ormField.kind === "m2o" || ormField.kind === "o2o" || ormField.kind === "poly";
+}
+function isCollectionField(ormField) {
+	return ormField.kind === "o2m" || ormField.kind === "m2m";
+}
+function getBaseAndSelfMetas(param) {
+	return require_Entity.isEntity(param) ? getBaseSelfAndSubMetas(getMetadata(param)) : param.baseSelfMetas ?? [...param.baseTypes, param];
+}
+function getBaseSelfAndSubMetas(meta) {
+	return meta.baseSelfAndSubMetas ?? [
+		...meta.baseTypes,
+		meta,
+		...meta.subTypes
+	];
+}
+function getSubMetas(meta) {
+	return meta.subTypes;
+}
+function getBaseMeta(meta) {
+	if (!meta.baseType) return meta;
+	else return meta.baseTypes[0];
+}
+//#endregion
+exports.getBaseAndSelfMetas = getBaseAndSelfMetas;
+exports.getBaseMeta = getBaseMeta;
+exports.getBaseSelfAndSubMetas = getBaseSelfAndSubMetas;
+exports.getMetadata = getMetadata;
+exports.getMetadataForField = getMetadataForField;
+exports.getSubMetas = getSubMetas;
+exports.isCollectionField = isCollectionField;
+exports.isManyToManyEnumField = isManyToManyEnumField;
+exports.isManyToManyField = isManyToManyField;
+exports.isManyToOneField = isManyToOneField;
+exports.isOneToManyField = isOneToManyField;
+exports.isOneToOneField = isOneToOneField;
+exports.isPolymorphicField = isPolymorphicField;
+exports.isReferenceField = isReferenceField;
+
+//# sourceMappingURL=EntityMetadata.cjs.map

package/build/EntityMetadata.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityMetadata.cjs","names":["getInstanceData","getMetadataForType","isEntity"],"sources":["../src/EntityMetadata.ts"],"sourcesContent":["import { getInstanceData } from \"src/BaseEntity.ts\";\nimport { type ConfigApi, type Reactable, type ReactiveRule } from \"src/config.ts\";\nimport { getMetadataForType } from \"src/configure.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\nimport { type EntityManager, type MaybeAbstractEntityConstructor, type TimestampFields } from \"src/EntityManager.ts\";\nimport { type EnumMetadata } from \"src/EnumMetadata.ts\";\nimport type { DeepNew } from \"src/loading/loadHints.ts\";\nimport type { Column, ColumnDescriptors } from \"src/serde/columns.ts\";\nimport type { FieldSerde, PolymorphicKeySerde } from \"src/serde/fieldSerde.ts\";\n\nexport function getMetadata<T extends Entity>(entity: T): EntityMetadata<T>;\nexport function getMetadata<T extends Entity>(type: MaybeAbstractEntityConstructor<T>): EntityMetadata<T>;\nexport function getMetadata<T extends Entity>(meta: EntityMetadata): EntityMetadata;\nexport function getMetadata<T extends Entity>(\n  param: T | MaybeAbstractEntityConstructor<T> | EntityMetadata,\n): EntityMetadata {\n  if (!param) throw new Error(`Cannot getMetadata of ${param}`);\n  return (\n    typeof param === \"function\" ? (param as any).metadata : \"cstr\" in param ? param : getInstanceData(param).metadata\n  ) as EntityMetadata;\n}\n\n/** Returns the metadata layer that declares `fieldName`, i.e. `Task.tags` for `TaskOld.tags`. */\nexport function getMetadataForField(meta: EntityMetadata, fieldName: string): EntityMetadata {\n  if (!meta.allFields[fieldName]) throw new Error(`Field '${fieldName}' not found on ${meta.type}`);\n  // I.e. `TaskOld.tags` is an STI-inherited `Task.tags` and should walk up, but `SmallPublisherGroup.publishers`\n  // is a CTI-specialized `PublisherGroup.publishers` and should stay on `SmallPublisherGroup`.\n  while (!(fieldName in meta.fields) && meta.allFields[fieldName]?.specialized !== true && meta.baseType) {\n    meta = getMetadataForType(meta.baseType);\n  }\n  return meta;\n}\n\n/**\n * Runtime metadata about an entity.\n *\n * The `joist-codegen` step will generate this by reading the database schema at build/codegen\n * time, along with any customizations in `joist-config.json`.\n *\n * Note: This has no generic, like `T extends Entity`, because `Entity<IdType>` i.e. with\n * an unknown string/id type, causes issues when we want to generically mix `EntityMetadata`\n * of different types, that even liberally using `EntityMetadata<any>` did not avoid.\n */\nexport interface EntityMetadata<T extends Entity = any> {\n  cstr: MaybeAbstractEntityConstructor<T>;\n  type: string;\n  /** How the domain entity's id is represented. */\n  idType: \"tagged-string\" | \"untagged-string\" | \"number\";\n  /** The database column type, i.e. used to do `::type` casts in Postgres. */\n  idDbType: \"bigint\" | \"int\" | \"uuid\" | \"text\";\n  tableName: string;\n  /** Whether codegen verified this table is a supported SQL mutation target; does not gate reads. */\n  supportsEmExecute?: boolean;\n  /** If we're a subtype, our immediate base type's name, e.g. for `SmallPublisher` this would be `Publisher`. */\n  baseType: string | undefined;\n  inheritanceType?: \"sti\" | \"cti\" | undefined;\n  /** Indicates the field to use to derive which subtype to instantiate; only set on the base meta. */\n  stiDiscriminatorField?: string;\n  /** The discriminator enum value for this subtype; only set on sub metas. */\n  stiDiscriminatorValue?: number;\n  /** Whether this type is abstract (cannot be instantiated directly). */\n  ctiAbstract?: boolean;\n  tagName: string;\n  fields: Record<string, Field>;\n  /** Physical storage descriptors, without CTI base columns; STI metadata shares its base table. */\n  columns: ColumnDescriptors;\n  allFields: Record<string, Field & { aliasSuffix: string; specialized?: true }>;\n  /** Usually polys are in `allFields`, but we pull the components out for comp-specific finds, like `parentBook`. */\n  polyComponentFields?: Record<string, Field & { aliasSuffix: string }>;\n  // Using `any` to avoid type errors between BaseType.metadata & SubType.metadata static fields\n  config: ConfigApi<any, any>;\n  /** The lazy list of non-read-only reactables for this metadata and its base types. */\n  reactables?: Reactable[];\n  /** The lazy lookup of non-read-only reactables by source field name. */\n  reactablesByField?: ReadonlyMap<string, Reactable[]>;\n  /** The lazy list of all reactables for this metadata and its base types. */\n  reactablesIncludingReadOnly?: Reactable[];\n  /** The lazy lookup of all reactables by source field name. */\n  reactablesIncludingReadOnlyByField?: ReadonlyMap<string, Reactable[]>;\n  /** The lazy list of reactive validation rules for this metadata and its subtypes. */\n  reactiveRules?: ReactiveRule[];\n  /** The lazy list of reactive *commit* rules (post-flush/pre-commit) for this metadata and its subtypes. */\n  reactiveCommitRules?: ReactiveRule[];\n  /** Lazily-cached: whether flushing an entity of this type could trigger any `addCommitRule` work. */\n  hasCommitRules?: boolean;\n  /** The lazily-cached set of own `lazy` primitive field names, i.e. columns excluded from the default SELECT. */\n  lazyFieldNames?: ReadonlySet<string>;\n  /** The lazily-cached list of sync-derived (`hasReactiveField`-less) field names, recalced during flush. */\n  syncDerivedFields?: string[];\n  /** Lazily-cached: whether this entity has any `lazy` columns, i.e. so the default SELECT lists columns explicitly. */\n  hasLazyColumns?: boolean;\n  orderBy: string | undefined;\n  /** Flat field names that can be used to find existing rows before creating. I.e. [[\"email\"], [\"author\", \"title\"]]. */\n  uniqueBy?: string[][];\n  timestampFields: TimestampFields | undefined;\n  // Ideally this would be the application-specific EntityManager (to avoid anys), but it doesn't really matter\n  factory: (em: EntityManager<any, any, any>, opts?: any) => DeepNew<T>;\n  /** The list of base types for this subtype, e.g. for Dog it'd be [Animal, Mammal]. */\n  baseTypes: EntityMetadata[];\n  /** The list of subtypes for this base type, e.g. for Animal it'd be `[Mammal, Dog]`. */\n  subTypes: EntityMetadata[];\n  /** Cached `[...baseTypes, this]` set up by `configureMetadata`, so hot paths avoid re-allocating it. */\n  baseSelfMetas?: EntityMetadata[];\n  /** Cached `[...baseTypes, this, ...subTypes]` set up by `configureMetadata`, so hot paths avoid re-allocating it. */\n  baseSelfAndSubMetas?: EntityMetadata[];\n  /** The lazy lookup of subtypes by type name, i.e. `Animal.metadata.subTypesByType.get(\"Dog\")`. */\n  subTypesByType?: ReadonlyMap<string, EntityMetadata>;\n  /** The lazy lookup of STI subtypes by discriminator value, i.e. `Task.metadata.subTypesByStiValue.get(1)`. */\n  subTypesByStiValue?: ReadonlyMap<unknown, EntityMetadata>;\n  /** The lazy STI discriminator column name, i.e. `Task.metadata.stiDiscriminatorColumnName`. */\n  stiDiscriminatorColumnName?: string;\n  /** If the schema is lacking deferred FKs, this is our insertion order. */\n  nonDeferredFkOrder?: number;\n}\n\nexport type Field =\n  | PrimaryKeyField\n  | PrimitiveField\n  | EnumField\n  | OneToManyField\n  | LargeOneToManyField\n  | ManyToOneField\n  | ManyToManyField\n  | ManyToManyEnumField\n  | OneToOneField\n  | PolymorphicField;\n\n// Only the fields that have defined `serde` keys; should be a mapped type of Field\nexport type SerdeField = PrimaryKeyField | PrimitiveField | EnumField | ManyToOneField | PolymorphicField;\n\nexport type PrimaryKeyField = {\n  kind: \"primaryKey\";\n  fieldName: string;\n  fieldIdName: undefined;\n  required: true;\n  serde: FieldSerde;\n  immutable: true;\n};\n\nexport type PrimitiveField = {\n  kind: \"primitive\";\n  fieldName: string;\n  fieldIdName: undefined;\n  required: boolean;\n  derived: \"orm\" | \"sync\" | \"async\" | false;\n  protected: boolean;\n  type: string | Function;\n  serde: FieldSerde;\n  immutable: boolean;\n  citext?: boolean;\n  default?: \"schema\" | \"config\";\n  sanitize?: boolean;\n  /** When true, this column is excluded from the entity's default SELECT and lazy-loaded via a `LazyField`. */\n  lazy?: boolean;\n};\n\nexport type EnumField = {\n  kind: \"enum\";\n  fieldName: string;\n  fieldIdName: undefined;\n  required: boolean;\n  derived: \"sync\" | \"async\" | false;\n  enumDetailType: { getValues(): ReadonlyArray<unknown>; findById(id: any): unknown };\n  serde: FieldSerde;\n  immutable: boolean;\n  default?: \"schema\" | \"config\";\n};\n\nexport type OneToManyField = {\n  kind: \"o2m\";\n  fieldName: string;\n  fieldIdName: string;\n  required: boolean;\n  otherMetadata: () => EntityMetadata;\n  otherFieldName: string;\n  /** Useful when our other side is a poly, to find which component points back to us. */\n  otherColumnName: string;\n  serde: undefined;\n  immutable: false;\n  orderBy?: { field: string; direction: \"ASC\" | \"DESC\" };\n  /** When `\"include\"`, this collection's `.get`/`.load` returns soft-deleted entities instead of hiding them. */\n  softDeletes?: \"include\" | \"exclude\";\n};\n\nexport type LargeOneToManyField = {\n  kind: \"lo2m\";\n  fieldName: string;\n  fieldIdName: string;\n  required: boolean;\n  otherMetadata: () => EntityMetadata;\n  otherFieldName: string;\n  /** Useful when our other side is a poly, to find which component points back to us. */\n  otherColumnName: string;\n  serde: undefined;\n  immutable: false;\n};\n\nexport type ManyToOneField = {\n  kind: \"m2o\";\n  fieldName: string;\n  fieldIdName: string;\n  required: boolean;\n  otherMetadata: () => EntityMetadata;\n  otherFieldName: string;\n  serde: FieldSerde;\n  immutable: boolean;\n  derived: \"async\" | false;\n  default?: \"schema\" | \"config\";\n};\n\nexport type ManyToManyField = {\n  kind: \"m2m\";\n  fieldName: string;\n  fieldIdName: string;\n  required: boolean;\n  derived: \"async\" | \"otherSide\" | false;\n  otherMetadata: () => EntityMetadata;\n  otherFieldName: string;\n  serde: undefined;\n  immutable: false;\n  joinTableName: string;\n  columnNames: [string, string];\n  /** Whether the join table has a surrogate `id` PK; if false the FK pair is the composite PK. */\n  hasJoinTableId: boolean;\n  /** When `\"include\"`, this collection's `.get`/`.load` returns soft-deleted entities instead of hiding them. */\n  softDeletes?: \"include\" | \"exclude\";\n};\n\n/**\n * A many-to-many between an entity and an enum \"table\", e.g. `Publisher.logoColors` backed by a\n * `publisher_logo_colors` join table joining `publishers` to the `color` enum table.\n *\n * To the user this looks like an array of enum codes (`Color[]`), but unlike an enum-array column it\n * is lazy (needs a load hint) because it lives in its own join table.\n */\nexport type ManyToManyEnumField = {\n  kind: \"m2mEnum\";\n  fieldName: string;\n  fieldIdName: undefined;\n  required: false;\n  derived: false;\n  /** The enum's metadata, used to map enum codes <-> their numeric ids. */\n  enumDetailType: EnumMetadata<any, any, number>;\n  serde: undefined;\n  immutable: false;\n  joinTableName: string;\n  /** `[entityColumn, enumColumn]`, e.g. `[\"publisher_id\", \"color_id\"]`. */\n  columnNames: [string, string];\n  /** Whether the join table has a surrogate `id` PK; if false the FK pair is the composite PK. */\n  hasJoinTableId: boolean;\n};\n\nexport type OneToOneField = {\n  kind: \"o2o\";\n  fieldName: string;\n  fieldIdName: string;\n  required: boolean;\n  otherMetadata: () => EntityMetadata;\n  otherFieldName: string;\n  /** Useful when our other side is a poly, to find which component points back to us. */\n  otherColumnName: string;\n  serde: undefined;\n  immutable: false;\n};\n\nexport type PolymorphicField = {\n  kind: \"poly\";\n  fieldName: string; // eg `parent`\n  fieldIdName: string; // `parentId`\n  required: boolean;\n  components: PolymorphicFieldComponent[];\n  serde: PolymorphicKeySerde;\n  immutable: boolean;\n};\n\nexport type PolymorphicFieldComponent = {\n  otherMetadata: () => EntityMetadata;\n  otherFieldName: string; // eg `comment` or `comments`\n  columnName: string; // eg `parent_book_id` or `parent_book_review_id`\n  column: Column;\n};\n\nexport function isOneToManyField(ormField: Field): ormField is OneToManyField {\n  return ormField.kind === \"o2m\";\n}\n\nexport function isManyToOneField(ormField: Field): ormField is ManyToOneField {\n  return ormField.kind === \"m2o\";\n}\n\nexport function isManyToManyField(ormField: Field): ormField is ManyToManyField {\n  return ormField.kind === \"m2m\";\n}\n\nexport function isManyToManyEnumField(ormField: Field): ormField is ManyToManyEnumField {\n  return ormField.kind === \"m2mEnum\";\n}\n\nexport function isOneToOneField(ormField: Field): ormField is OneToOneField {\n  return ormField.kind === \"o2o\";\n}\n\nexport function isPolymorphicField(ormField: Field): ormField is PolymorphicField {\n  return ormField.kind === \"poly\";\n}\n\nexport function isReferenceField(ormField: Field): ormField is ManyToOneField | OneToOneField | PolymorphicField {\n  return ormField.kind === \"m2o\" || ormField.kind === \"o2o\" || ormField.kind === \"poly\";\n}\n\nexport function isCollectionField(ormField: Field): ormField is OneToManyField | ManyToManyField {\n  return ormField.kind === \"o2m\" || ormField.kind === \"m2m\";\n}\n\nexport function getBaseAndSelfMetas(meta: EntityMetadata): EntityMetadata[];\nexport function getBaseAndSelfMetas(entity: Entity): EntityMetadata[];\nexport function getBaseAndSelfMetas(param: Entity | EntityMetadata): EntityMetadata[] {\n  return isEntity(param)\n    ? getBaseSelfAndSubMetas(getMetadata(param))\n    : (param.baseSelfMetas ?? [...param.baseTypes, param]);\n}\n\nexport function getBaseSelfAndSubMetas(meta: EntityMetadata): EntityMetadata[] {\n  return meta.baseSelfAndSubMetas ?? [...meta.baseTypes, meta, ...meta.subTypes];\n}\n\nexport function getSubMetas(meta: EntityMetadata): EntityMetadata[] {\n  // We should do recursion at some point\n  return meta.subTypes;\n}\n\nexport function getBaseMeta(meta: EntityMetadata): EntityMetadata {\n  if (!meta.baseType) {\n    return meta;\n  } else {\n    return meta.baseTypes[0];\n  }\n}\n"],"mappings":";;;;;;;AAaA,SAAgB,YACd,OACgB;CAChB,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,yBAAyB,OAAO;CAC5D,OACE,OAAO,UAAU,aAAc,MAAc,WAAW,UAAU,QAAQ,QAAQA,mBAAAA,gBAAgB,KAAK,CAAC,CAAC;AAE7G;;AAGA,SAAgB,oBAAoB,MAAsB,WAAmC;CAC3F,IAAI,CAAC,KAAK,UAAU,YAAY,MAAM,IAAI,MAAM,UAAU,UAAU,iBAAiB,KAAK,MAAM;CAGhG,OAAO,EAAE,aAAa,KAAK,WAAW,KAAK,UAAU,UAAU,EAAE,gBAAgB,QAAQ,KAAK,UAC5F,OAAOC,kBAAAA,mBAAmB,KAAK,QAAQ;CAEzC,OAAO;AACT;AA2PA,SAAgB,iBAAiB,UAA6C;CAC5E,OAAO,SAAS,SAAS;AAC3B;AAEA,SAAgB,iBAAiB,UAA6C;CAC5E,OAAO,SAAS,SAAS;AAC3B;AAEA,SAAgB,kBAAkB,UAA8C;CAC9E,OAAO,SAAS,SAAS;AAC3B;AAEA,SAAgB,sBAAsB,UAAkD;CACtF,OAAO,SAAS,SAAS;AAC3B;AAEA,SAAgB,gBAAgB,UAA4C;CAC1E,OAAO,SAAS,SAAS;AAC3B;AAEA,SAAgB,mBAAmB,UAA+C;CAChF,OAAO,SAAS,SAAS;AAC3B;AAEA,SAAgB,iBAAiB,UAAgF;CAC/G,OAAO,SAAS,SAAS,SAAS,SAAS,SAAS,SAAS,SAAS,SAAS;AACjF;AAEA,SAAgB,kBAAkB,UAA+D;CAC/F,OAAO,SAAS,SAAS,SAAS,SAAS,SAAS;AACtD;AAIA,SAAgB,oBAAoB,OAAkD;CACpF,OAAOC,eAAAA,SAAS,KAAK,IACjB,uBAAuB,YAAY,KAAK,CAAC,IACxC,MAAM,iBAAiB,CAAC,GAAG,MAAM,WAAW,KAAK;AACxD;AAEA,SAAgB,uBAAuB,MAAwC;CAC7E,OAAO,KAAK,uBAAuB;EAAC,GAAG,KAAK;EAAW;EAAM,GAAG,KAAK;CAAQ;AAC/E;AAEA,SAAgB,YAAY,MAAwC;CAElE,OAAO,KAAK;AACd;AAEA,SAAgB,YAAY,MAAsC;CAChE,IAAI,CAAC,KAAK,UACR,OAAO;MAEP,OAAO,KAAK,UAAU;AAE1B"}

package/build/EntityMetadata.d.cts

@@ -0,0 +1,262 @@
+import { EnumMetadata } from "./EnumMetadata.cjs";
+import { DeepNew } from "./loading/loadHints.cjs";
+import { ConfigApi, Reactable, ReactiveRule } from "./config.cjs";
+import { Column, ColumnDescriptors } from "./serde/columns.cjs";
+import { FieldSerde, PolymorphicKeySerde } from "./serde/fieldSerde.cjs";
+import { EntityManager, MaybeAbstractEntityConstructor, TimestampFields } from "./EntityManager.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/EntityMetadata.d.ts
+declare function getMetadata<T extends Entity>(entity: T): EntityMetadata<T>;
+declare function getMetadata<T extends Entity>(type: MaybeAbstractEntityConstructor<T>): EntityMetadata<T>;
+declare function getMetadata<T extends Entity>(meta: EntityMetadata): EntityMetadata;
+/** Returns the metadata layer that declares `fieldName`, i.e. `Task.tags` for `TaskOld.tags`. */
+declare function getMetadataForField(meta: EntityMetadata, fieldName: string): EntityMetadata;
+/**
+ * Runtime metadata about an entity.
+ *
+ * The `joist-codegen` step will generate this by reading the database schema at build/codegen
+ * time, along with any customizations in `joist-config.json`.
+ *
+ * Note: This has no generic, like `T extends Entity`, because `Entity<IdType>` i.e. with
+ * an unknown string/id type, causes issues when we want to generically mix `EntityMetadata`
+ * of different types, that even liberally using `EntityMetadata<any>` did not avoid.
+ */
+interface EntityMetadata<T extends Entity = any> {
+  cstr: MaybeAbstractEntityConstructor<T>;
+  type: string;
+  /** How the domain entity's id is represented. */
+  idType: "tagged-string" | "untagged-string" | "number";
+  /** The database column type, i.e. used to do `::type` casts in Postgres. */
+  idDbType: "bigint" | "int" | "uuid" | "text";
+  tableName: string;
+  /** Whether codegen verified this table is a supported SQL mutation target; does not gate reads. */
+  supportsEmExecute?: boolean;
+  /** If we're a subtype, our immediate base type's name, e.g. for `SmallPublisher` this would be `Publisher`. */
+  baseType: string | undefined;
+  inheritanceType?: "sti" | "cti" | undefined;
+  /** Indicates the field to use to derive which subtype to instantiate; only set on the base meta. */
+  stiDiscriminatorField?: string;
+  /** The discriminator enum value for this subtype; only set on sub metas. */
+  stiDiscriminatorValue?: number;
+  /** Whether this type is abstract (cannot be instantiated directly). */
+  ctiAbstract?: boolean;
+  tagName: string;
+  fields: Record<string, Field>;
+  /** Physical storage descriptors, without CTI base columns; STI metadata shares its base table. */
+  columns: ColumnDescriptors;
+  allFields: Record<string, Field & {
+    aliasSuffix: string;
+    specialized?: true;
+  }>;
+  /** Usually polys are in `allFields`, but we pull the components out for comp-specific finds, like `parentBook`. */
+  polyComponentFields?: Record<string, Field & {
+    aliasSuffix: string;
+  }>;
+  config: ConfigApi<any, any>;
+  /** The lazy list of non-read-only reactables for this metadata and its base types. */
+  reactables?: Reactable[];
+  /** The lazy lookup of non-read-only reactables by source field name. */
+  reactablesByField?: ReadonlyMap<string, Reactable[]>;
+  /** The lazy list of all reactables for this metadata and its base types. */
+  reactablesIncludingReadOnly?: Reactable[];
+  /** The lazy lookup of all reactables by source field name. */
+  reactablesIncludingReadOnlyByField?: ReadonlyMap<string, Reactable[]>;
+  /** The lazy list of reactive validation rules for this metadata and its subtypes. */
+  reactiveRules?: ReactiveRule[];
+  /** The lazy list of reactive *commit* rules (post-flush/pre-commit) for this metadata and its subtypes. */
+  reactiveCommitRules?: ReactiveRule[];
+  /** Lazily-cached: whether flushing an entity of this type could trigger any `addCommitRule` work. */
+  hasCommitRules?: boolean;
+  /** The lazily-cached set of own `lazy` primitive field names, i.e. columns excluded from the default SELECT. */
+  lazyFieldNames?: ReadonlySet<string>;
+  /** The lazily-cached list of sync-derived (`hasReactiveField`-less) field names, recalced during flush. */
+  syncDerivedFields?: string[];
+  /** Lazily-cached: whether this entity has any `lazy` columns, i.e. so the default SELECT lists columns explicitly. */
+  hasLazyColumns?: boolean;
+  orderBy: string | undefined;
+  /** Flat field names that can be used to find existing rows before creating. I.e. [["email"], ["author", "title"]]. */
+  uniqueBy?: string[][];
+  timestampFields: TimestampFields | undefined;
+  factory: (em: EntityManager<any, any, any>, opts?: any) => DeepNew<T>;
+  /** The list of base types for this subtype, e.g. for Dog it'd be [Animal, Mammal]. */
+  baseTypes: EntityMetadata[];
+  /** The list of subtypes for this base type, e.g. for Animal it'd be `[Mammal, Dog]`. */
+  subTypes: EntityMetadata[];
+  /** Cached `[...baseTypes, this]` set up by `configureMetadata`, so hot paths avoid re-allocating it. */
+  baseSelfMetas?: EntityMetadata[];
+  /** Cached `[...baseTypes, this, ...subTypes]` set up by `configureMetadata`, so hot paths avoid re-allocating it. */
+  baseSelfAndSubMetas?: EntityMetadata[];
+  /** The lazy lookup of subtypes by type name, i.e. `Animal.metadata.subTypesByType.get("Dog")`. */
+  subTypesByType?: ReadonlyMap<string, EntityMetadata>;
+  /** The lazy lookup of STI subtypes by discriminator value, i.e. `Task.metadata.subTypesByStiValue.get(1)`. */
+  subTypesByStiValue?: ReadonlyMap<unknown, EntityMetadata>;
+  /** The lazy STI discriminator column name, i.e. `Task.metadata.stiDiscriminatorColumnName`. */
+  stiDiscriminatorColumnName?: string;
+  /** If the schema is lacking deferred FKs, this is our insertion order. */
+  nonDeferredFkOrder?: number;
+}
+type Field = PrimaryKeyField | PrimitiveField | EnumField | OneToManyField | LargeOneToManyField | ManyToOneField | ManyToManyField | ManyToManyEnumField | OneToOneField | PolymorphicField;
+type SerdeField = PrimaryKeyField | PrimitiveField | EnumField | ManyToOneField | PolymorphicField;
+type PrimaryKeyField = {
+  kind: "primaryKey";
+  fieldName: string;
+  fieldIdName: undefined;
+  required: true;
+  serde: FieldSerde;
+  immutable: true;
+};
+type PrimitiveField = {
+  kind: "primitive";
+  fieldName: string;
+  fieldIdName: undefined;
+  required: boolean;
+  derived: "orm" | "sync" | "async" | false;
+  protected: boolean;
+  type: string | Function;
+  serde: FieldSerde;
+  immutable: boolean;
+  citext?: boolean;
+  default?: "schema" | "config";
+  sanitize?: boolean;
+  /** When true, this column is excluded from the entity's default SELECT and lazy-loaded via a `LazyField`. */
+  lazy?: boolean;
+};
+type EnumField = {
+  kind: "enum";
+  fieldName: string;
+  fieldIdName: undefined;
+  required: boolean;
+  derived: "sync" | "async" | false;
+  enumDetailType: {
+    getValues(): ReadonlyArray<unknown>;
+    findById(id: any): unknown;
+  };
+  serde: FieldSerde;
+  immutable: boolean;
+  default?: "schema" | "config";
+};
+type OneToManyField = {
+  kind: "o2m";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  /** Useful when our other side is a poly, to find which component points back to us. */
+  otherColumnName: string;
+  serde: undefined;
+  immutable: false;
+  orderBy?: {
+    field: string;
+    direction: "ASC" | "DESC";
+  };
+  /** When `"include"`, this collection's `.get`/`.load` returns soft-deleted entities instead of hiding them. */
+  softDeletes?: "include" | "exclude";
+};
+type LargeOneToManyField = {
+  kind: "lo2m";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  /** Useful when our other side is a poly, to find which component points back to us. */
+  otherColumnName: string;
+  serde: undefined;
+  immutable: false;
+};
+type ManyToOneField = {
+  kind: "m2o";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  serde: FieldSerde;
+  immutable: boolean;
+  derived: "async" | false;
+  default?: "schema" | "config";
+};
+type ManyToManyField = {
+  kind: "m2m";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  derived: "async" | "otherSide" | false;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  serde: undefined;
+  immutable: false;
+  joinTableName: string;
+  columnNames: [string, string];
+  /** Whether the join table has a surrogate `id` PK; if false the FK pair is the composite PK. */
+  hasJoinTableId: boolean;
+  /** When `"include"`, this collection's `.get`/`.load` returns soft-deleted entities instead of hiding them. */
+  softDeletes?: "include" | "exclude";
+};
+/**
+ * A many-to-many between an entity and an enum "table", e.g. `Publisher.logoColors` backed by a
+ * `publisher_logo_colors` join table joining `publishers` to the `color` enum table.
+ *
+ * To the user this looks like an array of enum codes (`Color[]`), but unlike an enum-array column it
+ * is lazy (needs a load hint) because it lives in its own join table.
+ */
+type ManyToManyEnumField = {
+  kind: "m2mEnum";
+  fieldName: string;
+  fieldIdName: undefined;
+  required: false;
+  derived: false;
+  /** The enum's metadata, used to map enum codes <-> their numeric ids. */
+  enumDetailType: EnumMetadata<any, any, number>;
+  serde: undefined;
+  immutable: false;
+  joinTableName: string;
+  /** `[entityColumn, enumColumn]`, e.g. `["publisher_id", "color_id"]`. */
+  columnNames: [string, string];
+  /** Whether the join table has a surrogate `id` PK; if false the FK pair is the composite PK. */
+  hasJoinTableId: boolean;
+};
+type OneToOneField = {
+  kind: "o2o";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  /** Useful when our other side is a poly, to find which component points back to us. */
+  otherColumnName: string;
+  serde: undefined;
+  immutable: false;
+};
+type PolymorphicField = {
+  kind: "poly";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  components: PolymorphicFieldComponent[];
+  serde: PolymorphicKeySerde;
+  immutable: boolean;
+};
+type PolymorphicFieldComponent = {
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  columnName: string;
+  column: Column;
+};
+declare function isOneToManyField(ormField: Field): ormField is OneToManyField;
+declare function isManyToOneField(ormField: Field): ormField is ManyToOneField;
+declare function isManyToManyField(ormField: Field): ormField is ManyToManyField;
+declare function isManyToManyEnumField(ormField: Field): ormField is ManyToManyEnumField;
+declare function isOneToOneField(ormField: Field): ormField is OneToOneField;
+declare function isPolymorphicField(ormField: Field): ormField is PolymorphicField;
+declare function isReferenceField(ormField: Field): ormField is ManyToOneField | OneToOneField | PolymorphicField;
+declare function isCollectionField(ormField: Field): ormField is OneToManyField | ManyToManyField;
+declare function getBaseAndSelfMetas(meta: EntityMetadata): EntityMetadata[];
+declare function getBaseAndSelfMetas(entity: Entity): EntityMetadata[];
+declare function getBaseSelfAndSubMetas(meta: EntityMetadata): EntityMetadata[];
+declare function getSubMetas(meta: EntityMetadata): EntityMetadata[];
+declare function getBaseMeta(meta: EntityMetadata): EntityMetadata;
+//#endregion
+export { EntityMetadata, EnumField, Field, LargeOneToManyField, ManyToManyEnumField, ManyToManyField, ManyToOneField, OneToManyField, OneToOneField, PolymorphicField, PolymorphicFieldComponent, PrimaryKeyField, PrimitiveField, SerdeField, getBaseAndSelfMetas, getBaseMeta, getBaseSelfAndSubMetas, getMetadata, getMetadataForField, getSubMetas, isCollectionField, isManyToManyEnumField, isManyToManyField, isManyToOneField, isOneToManyField, isOneToOneField, isPolymorphicField, isReferenceField };
+//# sourceMappingURL=EntityMetadata.d.cts.map

package/build/EntityMetadata.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityMetadata.d.cts","names":[],"sources":["../src/EntityMetadata.ts"],"mappings":";;;;;;;;iBAUgB,YAAY,UAAU,QAAQ,QAAQ,IAAI,eAAe;iBACzD,YAAY,UAAU,QAAQ,MAAM,+BAA+B,KAAK,eAAe;iBACvF,YAAY,UAAU,QAAQ,MAAM,iBAAiB;;iBAWrD,oBAAoB,MAAM,gBAAgB,oBAAoB;;;;;;;;;;;UAoB7D,eAAe,UAAU;EACxC,MAAM,+BAA+B;EACrC;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;EACA;EACA,QAAQ,eAAe;;EAEvB,SAAS;EACT,WAAW,eAAe;IAAU;IAAqB;;;EAEzD,sBAAsB,eAAe;IAAU;;EAE/C,QAAQ;;EAER,aAAa;;EAEb,oBAAoB,oBAAoB;;EAExC,8BAA8B;;EAE9B,qCAAqC,oBAAoB;;EAEzD,gBAAgB;;EAEhB,sBAAsB;;EAEtB;;EAEA,iBAAiB;;EAEjB;;EAEA;EACA;;EAEA;EACA,iBAAiB;EAEjB,UAAU,IAAI,8BAA8B,eAAe,QAAQ;;EAEnE,WAAW;;EAEX,UAAU;;EAEV,gBAAgB;;EAEhB,sBAAsB;;EAEtB,iBAAiB,oBAAoB;;EAErC,qBAAqB,qBAAqB;;EAE1C;;EAEA;;KAGU,QACR,kBACA,iBACA,YACA,iBACA,sBACA,iBACA,kBACA,sBACA,gBACA;KAGQ,aAAa,kBAAkB,iBAAiB,YAAY,iBAAiB;KAE7E;EACV;EACA;EACA;EACA;EACA,OAAO;EACP;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA,eAAe;EACf,OAAO;EACP;EACA;EACA;EACA;;EAEA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;IAAkB,aAAa;IAAwB,SAAS;;EAChE,OAAO;EACP;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA,qBAAqB;EACrB;;EAEA;EACA;EACA;EACA;IAAY;IAAe;;;EAE3B;;KAGU;EACV;EACA;EACA;EACA;EACA,qBAAqB;EACrB;;EAEA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA,qBAAqB;EACrB;EACA,OAAO;EACP;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA,qBAAqB;EACrB;EACA;EACA;EACA;EACA;;EAEA;;EAEA;;;;;;;;;KAUU;EACV;EACA;EACA;EACA;EACA;;EAEA,gBAAgB;EAChB;EACA;EACA;;EAEA;;EAEA;;KAGU;EACV;EACA;EACA;EACA;EACA,qBAAqB;EACrB;;EAEA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA,YAAY;EACZ,OAAO;EACP;;KAGU;EACV,qBAAqB;EACrB;EACA;EACA,QAAQ;;iBAGM,iBAAiB,UAAU,QAAQ,YAAY;iBAI/C,iBAAiB,UAAU,QAAQ,YAAY;iBAI/C,kBAAkB,UAAU,QAAQ,YAAY;iBAIhD,sBAAsB,UAAU,QAAQ,YAAY;iBAIpD,gBAAgB,UAAU,QAAQ,YAAY;iBAI9C,mBAAmB,UAAU,QAAQ,YAAY;iBAIjD,iBAAiB,UAAU,QAAQ,YAAY,iBAAiB,gBAAgB;iBAIhF,kBAAkB,UAAU,QAAQ,YAAY,iBAAiB;iBAIjE,oBAAoB,MAAM,iBAAiB;iBAC3C,oBAAoB,QAAQ,SAAS;iBAOrC,uBAAuB,MAAM,iBAAiB;iBAI9C,YAAY,MAAM,iBAAiB;iBAKnC,YAAY,MAAM,iBAAiB"}

package/build/EntityMetadata.d.mts

@@ -0,0 +1,262 @@
+import { EnumMetadata } from "./EnumMetadata.mjs";
+import { DeepNew } from "./loading/loadHints.mjs";
+import { ConfigApi, Reactable, ReactiveRule } from "./config.mjs";
+import { Column, ColumnDescriptors } from "./serde/columns.mjs";
+import { FieldSerde, PolymorphicKeySerde } from "./serde/fieldSerde.mjs";
+import { EntityManager, MaybeAbstractEntityConstructor, TimestampFields } from "./EntityManager.mjs";
+import { Entity } from "./Entity.mjs";
+//#region src/EntityMetadata.d.ts
+declare function getMetadata<T extends Entity>(entity: T): EntityMetadata<T>;
+declare function getMetadata<T extends Entity>(type: MaybeAbstractEntityConstructor<T>): EntityMetadata<T>;
+declare function getMetadata<T extends Entity>(meta: EntityMetadata): EntityMetadata;
+/** Returns the metadata layer that declares `fieldName`, i.e. `Task.tags` for `TaskOld.tags`. */
+declare function getMetadataForField(meta: EntityMetadata, fieldName: string): EntityMetadata;
+/**
+ * Runtime metadata about an entity.
+ *
+ * The `joist-codegen` step will generate this by reading the database schema at build/codegen
+ * time, along with any customizations in `joist-config.json`.
+ *
+ * Note: This has no generic, like `T extends Entity`, because `Entity<IdType>` i.e. with
+ * an unknown string/id type, causes issues when we want to generically mix `EntityMetadata`
+ * of different types, that even liberally using `EntityMetadata<any>` did not avoid.
+ */
+interface EntityMetadata<T extends Entity = any> {
+  cstr: MaybeAbstractEntityConstructor<T>;
+  type: string;
+  /** How the domain entity's id is represented. */
+  idType: "tagged-string" | "untagged-string" | "number";
+  /** The database column type, i.e. used to do `::type` casts in Postgres. */
+  idDbType: "bigint" | "int" | "uuid" | "text";
+  tableName: string;
+  /** Whether codegen verified this table is a supported SQL mutation target; does not gate reads. */
+  supportsEmExecute?: boolean;
+  /** If we're a subtype, our immediate base type's name, e.g. for `SmallPublisher` this would be `Publisher`. */
+  baseType: string | undefined;
+  inheritanceType?: "sti" | "cti" | undefined;
+  /** Indicates the field to use to derive which subtype to instantiate; only set on the base meta. */
+  stiDiscriminatorField?: string;
+  /** The discriminator enum value for this subtype; only set on sub metas. */
+  stiDiscriminatorValue?: number;
+  /** Whether this type is abstract (cannot be instantiated directly). */
+  ctiAbstract?: boolean;
+  tagName: string;
+  fields: Record<string, Field>;
+  /** Physical storage descriptors, without CTI base columns; STI metadata shares its base table. */
+  columns: ColumnDescriptors;
+  allFields: Record<string, Field & {
+    aliasSuffix: string;
+    specialized?: true;
+  }>;
+  /** Usually polys are in `allFields`, but we pull the components out for comp-specific finds, like `parentBook`. */
+  polyComponentFields?: Record<string, Field & {
+    aliasSuffix: string;
+  }>;
+  config: ConfigApi<any, any>;
+  /** The lazy list of non-read-only reactables for this metadata and its base types. */
+  reactables?: Reactable[];
+  /** The lazy lookup of non-read-only reactables by source field name. */
+  reactablesByField?: ReadonlyMap<string, Reactable[]>;
+  /** The lazy list of all reactables for this metadata and its base types. */
+  reactablesIncludingReadOnly?: Reactable[];
+  /** The lazy lookup of all reactables by source field name. */
+  reactablesIncludingReadOnlyByField?: ReadonlyMap<string, Reactable[]>;
+  /** The lazy list of reactive validation rules for this metadata and its subtypes. */
+  reactiveRules?: ReactiveRule[];
+  /** The lazy list of reactive *commit* rules (post-flush/pre-commit) for this metadata and its subtypes. */
+  reactiveCommitRules?: ReactiveRule[];
+  /** Lazily-cached: whether flushing an entity of this type could trigger any `addCommitRule` work. */
+  hasCommitRules?: boolean;
+  /** The lazily-cached set of own `lazy` primitive field names, i.e. columns excluded from the default SELECT. */
+  lazyFieldNames?: ReadonlySet<string>;
+  /** The lazily-cached list of sync-derived (`hasReactiveField`-less) field names, recalced during flush. */
+  syncDerivedFields?: string[];
+  /** Lazily-cached: whether this entity has any `lazy` columns, i.e. so the default SELECT lists columns explicitly. */
+  hasLazyColumns?: boolean;
+  orderBy: string | undefined;
+  /** Flat field names that can be used to find existing rows before creating. I.e. [["email"], ["author", "title"]]. */
+  uniqueBy?: string[][];
+  timestampFields: TimestampFields | undefined;
+  factory: (em: EntityManager<any, any, any>, opts?: any) => DeepNew<T>;
+  /** The list of base types for this subtype, e.g. for Dog it'd be [Animal, Mammal]. */
+  baseTypes: EntityMetadata[];
+  /** The list of subtypes for this base type, e.g. for Animal it'd be `[Mammal, Dog]`. */
+  subTypes: EntityMetadata[];
+  /** Cached `[...baseTypes, this]` set up by `configureMetadata`, so hot paths avoid re-allocating it. */
+  baseSelfMetas?: EntityMetadata[];
+  /** Cached `[...baseTypes, this, ...subTypes]` set up by `configureMetadata`, so hot paths avoid re-allocating it. */
+  baseSelfAndSubMetas?: EntityMetadata[];
+  /** The lazy lookup of subtypes by type name, i.e. `Animal.metadata.subTypesByType.get("Dog")`. */
+  subTypesByType?: ReadonlyMap<string, EntityMetadata>;
+  /** The lazy lookup of STI subtypes by discriminator value, i.e. `Task.metadata.subTypesByStiValue.get(1)`. */
+  subTypesByStiValue?: ReadonlyMap<unknown, EntityMetadata>;
+  /** The lazy STI discriminator column name, i.e. `Task.metadata.stiDiscriminatorColumnName`. */
+  stiDiscriminatorColumnName?: string;
+  /** If the schema is lacking deferred FKs, this is our insertion order. */
+  nonDeferredFkOrder?: number;
+}
+type Field = PrimaryKeyField | PrimitiveField | EnumField | OneToManyField | LargeOneToManyField | ManyToOneField | ManyToManyField | ManyToManyEnumField | OneToOneField | PolymorphicField;
+type SerdeField = PrimaryKeyField | PrimitiveField | EnumField | ManyToOneField | PolymorphicField;
+type PrimaryKeyField = {
+  kind: "primaryKey";
+  fieldName: string;
+  fieldIdName: undefined;
+  required: true;
+  serde: FieldSerde;
+  immutable: true;
+};
+type PrimitiveField = {
+  kind: "primitive";
+  fieldName: string;
+  fieldIdName: undefined;
+  required: boolean;
+  derived: "orm" | "sync" | "async" | false;
+  protected: boolean;
+  type: string | Function;
+  serde: FieldSerde;
+  immutable: boolean;
+  citext?: boolean;
+  default?: "schema" | "config";
+  sanitize?: boolean;
+  /** When true, this column is excluded from the entity's default SELECT and lazy-loaded via a `LazyField`. */
+  lazy?: boolean;
+};
+type EnumField = {
+  kind: "enum";
+  fieldName: string;
+  fieldIdName: undefined;
+  required: boolean;
+  derived: "sync" | "async" | false;
+  enumDetailType: {
+    getValues(): ReadonlyArray<unknown>;
+    findById(id: any): unknown;
+  };
+  serde: FieldSerde;
+  immutable: boolean;
+  default?: "schema" | "config";
+};
+type OneToManyField = {
+  kind: "o2m";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  /** Useful when our other side is a poly, to find which component points back to us. */
+  otherColumnName: string;
+  serde: undefined;
+  immutable: false;
+  orderBy?: {
+    field: string;
+    direction: "ASC" | "DESC";
+  };
+  /** When `"include"`, this collection's `.get`/`.load` returns soft-deleted entities instead of hiding them. */
+  softDeletes?: "include" | "exclude";
+};
+type LargeOneToManyField = {
+  kind: "lo2m";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  /** Useful when our other side is a poly, to find which component points back to us. */
+  otherColumnName: string;
+  serde: undefined;
+  immutable: false;
+};
+type ManyToOneField = {
+  kind: "m2o";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  serde: FieldSerde;
+  immutable: boolean;
+  derived: "async" | false;
+  default?: "schema" | "config";
+};
+type ManyToManyField = {
+  kind: "m2m";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  derived: "async" | "otherSide" | false;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  serde: undefined;
+  immutable: false;
+  joinTableName: string;
+  columnNames: [string, string];
+  /** Whether the join table has a surrogate `id` PK; if false the FK pair is the composite PK. */
+  hasJoinTableId: boolean;
+  /** When `"include"`, this collection's `.get`/`.load` returns soft-deleted entities instead of hiding them. */
+  softDeletes?: "include" | "exclude";
+};
+/**
+ * A many-to-many between an entity and an enum "table", e.g. `Publisher.logoColors` backed by a
+ * `publisher_logo_colors` join table joining `publishers` to the `color` enum table.
+ *
+ * To the user this looks like an array of enum codes (`Color[]`), but unlike an enum-array column it
+ * is lazy (needs a load hint) because it lives in its own join table.
+ */
+type ManyToManyEnumField = {
+  kind: "m2mEnum";
+  fieldName: string;
+  fieldIdName: undefined;
+  required: false;
+  derived: false;
+  /** The enum's metadata, used to map enum codes <-> their numeric ids. */
+  enumDetailType: EnumMetadata<any, any, number>;
+  serde: undefined;
+  immutable: false;
+  joinTableName: string;
+  /** `[entityColumn, enumColumn]`, e.g. `["publisher_id", "color_id"]`. */
+  columnNames: [string, string];
+  /** Whether the join table has a surrogate `id` PK; if false the FK pair is the composite PK. */
+  hasJoinTableId: boolean;
+};
+type OneToOneField = {
+  kind: "o2o";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  /** Useful when our other side is a poly, to find which component points back to us. */
+  otherColumnName: string;
+  serde: undefined;
+  immutable: false;
+};
+type PolymorphicField = {
+  kind: "poly";
+  fieldName: string;
+  fieldIdName: string;
+  required: boolean;
+  components: PolymorphicFieldComponent[];
+  serde: PolymorphicKeySerde;
+  immutable: boolean;
+};
+type PolymorphicFieldComponent = {
+  otherMetadata: () => EntityMetadata;
+  otherFieldName: string;
+  columnName: string;
+  column: Column;
+};
+declare function isOneToManyField(ormField: Field): ormField is OneToManyField;
+declare function isManyToOneField(ormField: Field): ormField is ManyToOneField;
+declare function isManyToManyField(ormField: Field): ormField is ManyToManyField;
+declare function isManyToManyEnumField(ormField: Field): ormField is ManyToManyEnumField;
+declare function isOneToOneField(ormField: Field): ormField is OneToOneField;
+declare function isPolymorphicField(ormField: Field): ormField is PolymorphicField;
+declare function isReferenceField(ormField: Field): ormField is ManyToOneField | OneToOneField | PolymorphicField;
+declare function isCollectionField(ormField: Field): ormField is OneToManyField | ManyToManyField;
+declare function getBaseAndSelfMetas(meta: EntityMetadata): EntityMetadata[];
+declare function getBaseAndSelfMetas(entity: Entity): EntityMetadata[];
+declare function getBaseSelfAndSubMetas(meta: EntityMetadata): EntityMetadata[];
+declare function getSubMetas(meta: EntityMetadata): EntityMetadata[];
+declare function getBaseMeta(meta: EntityMetadata): EntityMetadata;
+//#endregion
+export { EntityMetadata, EnumField, Field, LargeOneToManyField, ManyToManyEnumField, ManyToManyField, ManyToOneField, OneToManyField, OneToOneField, PolymorphicField, PolymorphicFieldComponent, PrimaryKeyField, PrimitiveField, SerdeField, getBaseAndSelfMetas, getBaseMeta, getBaseSelfAndSubMetas, getMetadata, getMetadataForField, getSubMetas, isCollectionField, isManyToManyEnumField, isManyToManyField, isManyToOneField, isOneToManyField, isOneToOneField, isPolymorphicField, isReferenceField };
+//# sourceMappingURL=EntityMetadata.d.mts.map

package/build/EntityMetadata.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityMetadata.d.mts","names":[],"sources":["../src/EntityMetadata.ts"],"mappings":";;;;;;;;iBAUgB,YAAY,UAAU,QAAQ,QAAQ,IAAI,eAAe;iBACzD,YAAY,UAAU,QAAQ,MAAM,+BAA+B,KAAK,eAAe;iBACvF,YAAY,UAAU,QAAQ,MAAM,iBAAiB;;iBAWrD,oBAAoB,MAAM,gBAAgB,oBAAoB;;;;;;;;;;;UAoB7D,eAAe,UAAU;EACxC,MAAM,+BAA+B;EACrC;;EAEA;;EAEA;EACA;;EAEA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;EACA;EACA,QAAQ,eAAe;;EAEvB,SAAS;EACT,WAAW,eAAe;IAAU;IAAqB;;;EAEzD,sBAAsB,eAAe;IAAU;;EAE/C,QAAQ;;EAER,aAAa;;EAEb,oBAAoB,oBAAoB;;EAExC,8BAA8B;;EAE9B,qCAAqC,oBAAoB;;EAEzD,gBAAgB;;EAEhB,sBAAsB;;EAEtB;;EAEA,iBAAiB;;EAEjB;;EAEA;EACA;;EAEA;EACA,iBAAiB;EAEjB,UAAU,IAAI,8BAA8B,eAAe,QAAQ;;EAEnE,WAAW;;EAEX,UAAU;;EAEV,gBAAgB;;EAEhB,sBAAsB;;EAEtB,iBAAiB,oBAAoB;;EAErC,qBAAqB,qBAAqB;;EAE1C;;EAEA;;KAGU,QACR,kBACA,iBACA,YACA,iBACA,sBACA,iBACA,kBACA,sBACA,gBACA;KAGQ,aAAa,kBAAkB,iBAAiB,YAAY,iBAAiB;KAE7E;EACV;EACA;EACA;EACA;EACA,OAAO;EACP;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA,eAAe;EACf,OAAO;EACP;EACA;EACA;EACA;;EAEA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;IAAkB,aAAa;IAAwB,SAAS;;EAChE,OAAO;EACP;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA,qBAAqB;EACrB;;EAEA;EACA;EACA;EACA;IAAY;IAAe;;;EAE3B;;KAGU;EACV;EACA;EACA;EACA;EACA,qBAAqB;EACrB;;EAEA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA,qBAAqB;EACrB;EACA,OAAO;EACP;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA,qBAAqB;EACrB;EACA;EACA;EACA;EACA;;EAEA;;EAEA;;;;;;;;;KAUU;EACV;EACA;EACA;EACA;EACA;;EAEA,gBAAgB;EAChB;EACA;EACA;;EAEA;;EAEA;;KAGU;EACV;EACA;EACA;EACA;EACA,qBAAqB;EACrB;;EAEA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA,YAAY;EACZ,OAAO;EACP;;KAGU;EACV,qBAAqB;EACrB;EACA;EACA,QAAQ;;iBAGM,iBAAiB,UAAU,QAAQ,YAAY;iBAI/C,iBAAiB,UAAU,QAAQ,YAAY;iBAI/C,kBAAkB,UAAU,QAAQ,YAAY;iBAIhD,sBAAsB,UAAU,QAAQ,YAAY;iBAIpD,gBAAgB,UAAU,QAAQ,YAAY;iBAI9C,mBAAmB,UAAU,QAAQ,YAAY;iBAIjD,iBAAiB,UAAU,QAAQ,YAAY,iBAAiB,gBAAgB;iBAIhF,kBAAkB,UAAU,QAAQ,YAAY,iBAAiB;iBAIjE,oBAAoB,MAAM,iBAAiB;iBAC3C,oBAAoB,QAAQ,SAAS;iBAOrC,uBAAuB,MAAM,iBAAiB;iBAI9C,YAAY,MAAM,iBAAiB;iBAKnC,YAAY,MAAM,iBAAiB"}