joist-core 2.4.0-next.2 → 2.4.0-next.21

package/build/EntityMetadata.cjs

@@ -1,6 +1,5 @@
 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");

package/build/EntityMetadata.cjs.map

@@ -1 +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"}
+{"version":3,"file":"EntityMetadata.cjs","names":["getInstanceData","getMetadataForType","isEntity"],"sources":["../src/EntityMetadata.ts"],"sourcesContent":["import { getInstanceData } from \"src/BaseEntity.ts\";\nimport type { ConfigApi, Reactable, 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\";\nimport type { FieldTransitions } from \"src/transitions.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 lookup of transition config by field, including config from base types. */\n  transitions?: ReadonlyMap<string, FieldTransitions>;\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: EnumMetadata<any, { name: string }>;\n  /** The enum object, i.e. `{ Draft: \"DRAFT\" }`. */\n  enumType: Record<string, 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":";;;;;;AAcA,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;AA+PA,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

@@ -1,5 +1,6 @@
 import { EnumMetadata } from "./EnumMetadata.cjs";
 import { DeepNew } from "./loading/loadHints.cjs";
+import { FieldTransitions } from "./transitions.cjs";
 import { ConfigApi, Reactable, ReactiveRule } from "./config.cjs";
 import { Column, ColumnDescriptors } from "./serde/columns.cjs";
 import { FieldSerde, PolymorphicKeySerde } from "./serde/fieldSerde.cjs";
@@ -53,6 +54,8 @@ interface EntityMetadata<T extends Entity = any> {
     aliasSuffix: string;
   }>;
   config: ConfigApi<any, any>;
+  /** The lazy lookup of transition config by field, including config from base types. */
+  transitions?: ReadonlyMap<string, FieldTransitions>;
   /** 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. */
@@ -127,10 +130,11 @@ type EnumField = {
   fieldIdName: undefined;
   required: boolean;
   derived: "sync" | "async" | false;
-  enumDetailType: {
-    getValues(): ReadonlyArray<unknown>;
-    findById(id: any): unknown;
-  };
+  enumDetailType: EnumMetadata<any, {
+    name: string;
+  }>;
+  /** The enum object, i.e. `{ Draft: "DRAFT" }`. */
+  enumType: Record<string, unknown>;
   serde: FieldSerde;
   immutable: boolean;
   default?: "schema" | "config";

package/build/EntityMetadata.d.cts.map

@@ -1 +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"}
+{"version":3,"file":"EntityMetadata.d.cts","names":[],"sources":["../src/EntityMetadata.ts"],"mappings":";;;;;;;;;iBAWgB,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,cAAc,oBAAoB;;EAElC,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,gBAAgB;IAAoB;;;EAEpC,UAAU;EACV,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

@@ -1,5 +1,6 @@
 import { EnumMetadata } from "./EnumMetadata.mjs";
 import { DeepNew } from "./loading/loadHints.mjs";
+import { FieldTransitions } from "./transitions.mjs";
 import { ConfigApi, Reactable, ReactiveRule } from "./config.mjs";
 import { Column, ColumnDescriptors } from "./serde/columns.mjs";
 import { FieldSerde, PolymorphicKeySerde } from "./serde/fieldSerde.mjs";
@@ -53,6 +54,8 @@ interface EntityMetadata<T extends Entity = any> {
     aliasSuffix: string;
   }>;
   config: ConfigApi<any, any>;
+  /** The lazy lookup of transition config by field, including config from base types. */
+  transitions?: ReadonlyMap<string, FieldTransitions>;
   /** 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. */
@@ -127,10 +130,11 @@ type EnumField = {
   fieldIdName: undefined;
   required: boolean;
   derived: "sync" | "async" | false;
-  enumDetailType: {
-    getValues(): ReadonlyArray<unknown>;
-    findById(id: any): unknown;
-  };
+  enumDetailType: EnumMetadata<any, {
+    name: string;
+  }>;
+  /** The enum object, i.e. `{ Draft: "DRAFT" }`. */
+  enumType: Record<string, unknown>;
   serde: FieldSerde;
   immutable: boolean;
   default?: "schema" | "config";

package/build/EntityMetadata.d.mts.map

@@ -1 +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"}
+{"version":3,"file":"EntityMetadata.d.mts","names":[],"sources":["../src/EntityMetadata.ts"],"mappings":";;;;;;;;;iBAWgB,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,cAAc,oBAAoB;;EAElC,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,gBAAgB;IAAoB;;;EAEpC,UAAU;EACV,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.js

@@ -1,5 +1,4 @@
 import { getMetadataForType } from "./configure.js";
-import "./config.js";
 import "./EntityManager.js";
 import { isEntity } from "./Entity.js";
 import { getInstanceData } from "./BaseEntity.js";

package/build/EntityMetadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"EntityMetadata.js","names":[],"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,QAAQ,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,OAAO,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,OAAO,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"}
+{"version":3,"file":"EntityMetadata.js","names":[],"sources":["../src/EntityMetadata.ts"],"sourcesContent":["import { getInstanceData } from \"src/BaseEntity.ts\";\nimport type { ConfigApi, Reactable, 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\";\nimport type { FieldTransitions } from \"src/transitions.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 lookup of transition config by field, including config from base types. */\n  transitions?: ReadonlyMap<string, FieldTransitions>;\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: EnumMetadata<any, { name: string }>;\n  /** The enum object, i.e. `{ Draft: \"DRAFT\" }`. */\n  enumType: Record<string, 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":";;;;;AAcA,SAAgB,YACd,OACgB;CAChB,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,yBAAyB,OAAO;CAC5D,OACE,OAAO,UAAU,aAAc,MAAc,WAAW,UAAU,QAAQ,QAAQ,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,OAAO,mBAAmB,KAAK,QAAQ;CAEzC,OAAO;AACT;AA+PA,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,OAAO,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/IndexManager.cjs

@@ -3,6 +3,7 @@ const require_relations_Reference = require("./relations/Reference.cjs");
 require("./relations/index.cjs");
 const require_utils = require("./utils.cjs");
 const require_EntityMetadata = require("./EntityMetadata.cjs");
+const require_dataloaders_fastWhereFilterHash = require("./dataloaders/fastWhereFilterHash.cjs");
 const require_Entity = require("./Entity.cjs");
 //#region src/IndexManager.ts
 const emptySet = /* @__PURE__ */ new Set();
@@ -80,7 +81,7 @@ var IndexManager = class {
 			if (!entry) {
 				entry = {
 					field,
-					index: new FieldIndex(),
+					index: new FieldIndex(meta.columns[fieldName]?.isArray ?? false),
 					indexedCount: 0
 				};
 				indexes.set(fieldName, entry);
@@ -132,7 +133,12 @@ function getFieldValue(entity, fieldName, field) {
 * - relations not having loaded their instances yet
 */
 var FieldIndex = class {
+	isArray;
 	#valueToEntities = /* @__PURE__ */ new Map();
+	#arrayToEntities = /* @__PURE__ */ new Map();
+	constructor(isArray) {
+		this.isArray = isArray;
+	}
 	/** @return entities that have `value` as their current value for this field. */
 	get(value) {
 		if (require_Entity.isEntity(value) && value.idTaggedMaybe) {
@@ -142,6 +148,8 @@ var FieldIndex = class {
 			return matchId ?? matchInstance;
 		}
 		if (value === null) value = void 0;
+		const arrayKey = this.maybeArrayKey(value);
+		if (arrayKey !== void 0) return this.#arrayToEntities.get(arrayKey);
 		return this.#valueToEntities.get(value);
 	}
 	add(value, entity) {
@@ -153,17 +161,27 @@ var FieldIndex = class {
 		this.doRemove(value, entity);
 	}
 	doAdd(value, entity) {
-		const set = this.#valueToEntities.get(value) ?? /* @__PURE__ */ new Set();
-		if (set.size === 0) this.#valueToEntities.set(value, set);
+		const arrayKey = this.maybeArrayKey(value);
+		const index = arrayKey === void 0 ? this.#valueToEntities : this.#arrayToEntities;
+		const key = arrayKey ?? value;
+		const set = index.get(key) ?? /* @__PURE__ */ new Set();
+		if (set.size === 0) index.set(key, set);
 		set.add(entity);
 	}
 	doRemove(value, entity) {
-		const set = this.#valueToEntities.get(value);
+		const arrayKey = this.maybeArrayKey(value);
+		const index = arrayKey === void 0 ? this.#valueToEntities : this.#arrayToEntities;
+		const key = arrayKey ?? value;
+		const set = index.get(key);
 		if (set) {
 			set.delete(entity);
-			if (set.size === 0) this.#valueToEntities.delete(value);
+			if (set.size === 0) index.delete(key);
 		}
 	}
+	/** Preserves array order and element types, including bigint values that JSON cannot encode. */
+	maybeArrayKey(value) {
+		return this.isArray && Array.isArray(value) ? require_dataloaders_fastWhereFilterHash.fastWhereFilterHash(value) : void 0;
+	}
 };
 function intersectSets(set1, set2) {
 	const [smaller, larger] = set1.size <= set2.size ? [set1, set2] : [set2, set1];

package/build/IndexManager.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"IndexManager.cjs","names":["#indexes","groupBy","getMetadata","isLoadedReference","#valueToEntities","isEntity"],"sources":["../src/IndexManager.ts"],"sourcesContent":["import { type Entity, isEntity } from \"src/Entity.ts\";\nimport { type EntityMetadata, type Field, getMetadata } from \"src/EntityMetadata.ts\";\nimport { type ManyToOneReference, type PolymorphicReference, isLoadedReference } from \"src/relations/index.ts\";\nimport { groupBy } from \"src/utils.ts\";\n\ntype FieldValue = any;\ntype FieldName = string;\ntype EntityTag = string;\ntype FieldIndexEntry = {\n  field: Field;\n  index: FieldIndex;\n  /** Tracks how far into the EM's list-per-tag array this field index has been lazily populated. */\n  indexedCount: number;\n};\nconst emptySet = new Set<Entity>();\n\n// The test reproducing a n^2 with n=500 went from 100ms to 50ms if indexed\nexport const indexThreshold = 500;\n\n/**\n * IndexManager provides field-based indexing for entity queries to avoid O(n) linear scans of `em.entities`.\n *\n * Key features:\n * - Only indexes entity types with >1000 entities to avoid overhead for small datasets\n * - Supports dual indexing for m2o/poly fields (by ID for saved, by instance for unsaved)\n * - Automatically maintains indexes when fields are updated via setField()\n */\nexport class IndexManager {\n  readonly #indexes: Map<EntityTag, Map<FieldName, FieldIndexEntry>> = new Map();\n\n  /** @return if we should index entities of this type/count. */\n  shouldIndexType(entityCount: number): boolean {\n    return entityCount >= indexThreshold;\n  }\n\n  /** Visible for testing. */\n  isIndexed(tagName: string): boolean {\n    return this.#indexes.has(tagName);\n  }\n\n  /** Enables indexing for an entity type and builds indexes for the requested fields. */\n  enableIndexingForType<T extends Entity>(meta: EntityMetadata<T>, entities: T[], where: object): void {\n    const { tagName } = meta;\n    if (!this.#indexes.has(tagName)) {\n      this.#indexes.set(tagName, new Map());\n    }\n\n    const fieldNames = Object.keys(where);\n    const fieldIndexes = this.#indexes.get(tagName)!;\n    const missingFieldNames = fieldNames.filter((fieldName) => !fieldIndexes.has(fieldName));\n    if (missingFieldNames.length === 0) return;\n\n    // If subtypes are involved, group by each subtype\n    if (meta.baseType || meta.subTypes.length > 0) {\n      [...groupBy(entities, (e) => getMetadata(e)).entries()].forEach(([meta, entities]) => {\n        this.addEntitiesToIndex(meta, entities, missingFieldNames);\n      });\n    } else {\n      this.addEntitiesToIndex(meta, entities, missingFieldNames);\n    }\n  }\n\n  /** Updates indexes when a field value changes. */\n  maybeUpdateFieldIndex(entity: Entity, fieldName: string, oldValue: any, newValue: any): void {\n    // Fast return for the common case, which is no indexing\n    if (this.#indexes.size === 0) return;\n\n    const meta = getMetadata(entity);\n    const fieldIndexes = this.#indexes.get(meta.tagName);\n    if (!fieldIndexes) return; // Type not indexed\n\n    const fieldIndex = fieldIndexes.get(fieldName)?.index;\n    if (!fieldIndex) return; // Field is not indexed\n\n    fieldIndex.remove(oldValue, entity);\n    fieldIndex.add(newValue, entity);\n  }\n\n  /**\n   * Finds entities matching the given where clause using indexes.\n   *\n   * Returns the raw candidate set (possibly a live internal index set, so do not mutate it);\n   * the caller applies its own subtype/deleted filtering while building the final array.\n   */\n  findMatching<T extends Entity>(meta: EntityMetadata<T>, entities: T[], where: any): ReadonlySet<T> {\n    const { tagName } = meta;\n    if (!this.#indexes.has(tagName)) {\n      throw new Error(`${meta.type} is not indexed`);\n    }\n    const fieldIndexes = this.#indexes.get(tagName)!;\n    // Start with all entities of the 1st condition, then intersect (AND) each subsequent field in `where`\n    let candidates: Set<Entity> | undefined;\n    for (const [fieldName, value] of Object.entries(where)) {\n      this.indexUnindexedEntities(entities, fieldName);\n      const fieldCandidates = fieldIndexes.get(fieldName)?.index.get(value);\n      if (!candidates) {\n        candidates = fieldCandidates ?? emptySet; // This is the 1st clause\n      } else {\n        candidates = fieldCandidates ? intersectSets(candidates, fieldCandidates) : emptySet;\n      }\n      // Early exit if no candidates remain\n      if (candidates.size === 0) break;\n    }\n    if (candidates === undefined) {\n      throw new Error(`Expected where clause with at least one condition`);\n    }\n    return candidates as unknown as ReadonlySet<T>;\n  }\n\n  // `entities` should all be of the exact same subtype\n  private addEntitiesToIndex(meta: EntityMetadata, entities: Entity[], fieldNames: string[]): void {\n    const { tagName } = meta;\n    const indexes = this.#indexes.get(tagName)!;\n    // Iterate over each field so we can do a shared fieldIndex lookup\n    for (const fieldName of fieldNames) {\n      const field = meta.allFields[fieldName];\n      if (!field) continue;\n      let entry = indexes.get(fieldName);\n      if (!entry) {\n        entry = { field, index: new FieldIndex(), indexedCount: 0 };\n        indexes.set(fieldName, entry);\n      }\n      for (const entity of entities) {\n        // Deleted entities never match, and reading a flushed one's relations throws\n        if (entity.isDeletedEntity) continue;\n        const value = getFieldValue(entity, fieldName, entry.field);\n        entry.index.add(value, entity);\n      }\n      entry.indexedCount = entities.length;\n    }\n  }\n\n  /** Lazily indexes newly-registered entities only for fields that are queried. */\n  private indexUnindexedEntities<T extends Entity>(entities: T[], fieldName: string): void {\n    const first = entities[0];\n    if (first === undefined) return;\n\n    const meta = getMetadata(first);\n    const entry = this.#indexes.get(meta.tagName)?.get(fieldName);\n    if (entry === undefined || entry.indexedCount === entities.length) return;\n\n    for (let i = entry.indexedCount; i < entities.length; i++) {\n      const entity = entities[i];\n      if (entity.isDeletedEntity) continue;\n      const value = getFieldValue(entity, fieldName, entry.field);\n      entry.index.add(value, entity);\n    }\n    entry.indexedCount = entities.length;\n  }\n}\n\n// Use the same field access pattern as entityMatches\nfunction getFieldValue(entity: Entity, fieldName: string, field: Field): any {\n  const fn = fieldName as keyof Entity;\n  switch (field.kind) {\n    case \"primaryKey\":\n      return entity.idTaggedMaybe;\n    case \"enum\":\n    case \"primitive\":\n      return (entity as any)[fn];\n    case \"m2o\":\n    case \"poly\":\n      const relation = (entity as any)[fn] as\n        | ManyToOneReference<Entity, any, any>\n        | PolymorphicReference<Entity, any, any>;\n      if (isLoadedReference(relation)) {\n        return relation.get;\n      } else if (relation.isSet) {\n        return relation.id;\n      } else {\n        return undefined;\n      }\n    default:\n      return undefined;\n  }\n}\n\n/**\n * For a given field, like `firstName`, holds the reverse index of value `bob` -> entities `[a1, a2]`.\n *\n * This also handles indexes `Entity` values as both instances & IDs, to handle both:\n * - new/unpersisted entities not yet having IDs, and\n * - relations not having loaded their instances yet\n */\nclass FieldIndex {\n  readonly #valueToEntities = new Map<FieldValue, Set<Entity>>();\n\n  /** @return entities that have `value` as their current value for this field. */\n  get(value: any): Set<Entity> | undefined {\n    if (isEntity(value) && value.idTaggedMaybe) {\n      // If `value` is a persisted entity like `a:1`, and entities could have indexed their `author_id=a:1` field\n      // values as the unloaded \"just an a:1 string id\" value, before `a:1` was loaded into memory.\n      const matchId = this.#valueToEntities.get(value.idTaggedMaybe);\n      // But other entities could also have indexes `a:1` as an instance, so go ahead and check both\n      const matchInstance = this.#valueToEntities.get(value);\n      if (matchId && matchInstance) {\n        return new Set([...matchId, ...matchInstance]);\n      }\n      return matchId ?? matchInstance;\n    }\n    // Treat null and undefined as equivalent for unset relations\n    if (value === null) value = undefined;\n    return this.#valueToEntities.get(value);\n  }\n\n  add(value: any, entity: Entity): void {\n    // If this is an entity, store both the entity itself & its ID\n    if (isEntity(value) && value.idTaggedMaybe) {\n      this.doAdd(value.idTaggedMaybe, entity);\n    }\n    this.doAdd(value, entity);\n  }\n\n  remove(value: any, entity: Entity): void {\n    if (isEntity(value) && value.idTaggedMaybe) {\n      this.doRemove(value.idTaggedMaybe, entity);\n    }\n    this.doRemove(value, entity);\n  }\n\n  private doAdd(value: any, entity: Entity): void {\n    const set = this.#valueToEntities.get(value) ?? new Set();\n    if (set.size === 0) this.#valueToEntities.set(value, set);\n    set.add(entity);\n  }\n\n  private doRemove(value: any, entity: Entity): void {\n    const set = this.#valueToEntities.get(value);\n    if (set) {\n      set.delete(entity);\n      if (set.size === 0) {\n        this.#valueToEntities.delete(value);\n      }\n    }\n  }\n}\n\nfunction intersectSets<T>(set1: Set<T>, set2: Set<T>): Set<T> {\n  const [smaller, larger] = set1.size <= set2.size ? [set1, set2] : [set2, set1];\n  const result = new Set<T>();\n  for (const item of smaller) {\n    if (larger.has(item)) {\n      result.add(item);\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}
+{"version":3,"file":"IndexManager.cjs","names":["#indexes","groupBy","getMetadata","isLoadedReference","#valueToEntities","#arrayToEntities","isEntity","fastWhereFilterHash"],"sources":["../src/IndexManager.ts"],"sourcesContent":["import { fastWhereFilterHash } from \"src/dataloaders/fastWhereFilterHash.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\nimport { type EntityMetadata, type Field, getMetadata } from \"src/EntityMetadata.ts\";\nimport { type ManyToOneReference, type PolymorphicReference, isLoadedReference } from \"src/relations/index.ts\";\nimport { groupBy } from \"src/utils.ts\";\n\ntype FieldValue = any;\ntype FieldName = string;\ntype EntityTag = string;\ntype FieldIndexEntry = {\n  field: Field;\n  index: FieldIndex;\n  /** Tracks how far into the EM's list-per-tag array this field index has been lazily populated. */\n  indexedCount: number;\n};\nconst emptySet = new Set<Entity>();\n\n// The test reproducing a n^2 with n=500 went from 100ms to 50ms if indexed\nexport const indexThreshold = 500;\n\n/**\n * IndexManager provides field-based indexing for entity queries to avoid O(n) linear scans of `em.entities`.\n *\n * Key features:\n * - Only indexes entity types with >1000 entities to avoid overhead for small datasets\n * - Supports dual indexing for m2o/poly fields (by ID for saved, by instance for unsaved)\n * - Automatically maintains indexes when fields are updated via setField()\n */\nexport class IndexManager {\n  readonly #indexes: Map<EntityTag, Map<FieldName, FieldIndexEntry>> = new Map();\n\n  /** @return if we should index entities of this type/count. */\n  shouldIndexType(entityCount: number): boolean {\n    return entityCount >= indexThreshold;\n  }\n\n  /** Visible for testing. */\n  isIndexed(tagName: string): boolean {\n    return this.#indexes.has(tagName);\n  }\n\n  /** Enables indexing for an entity type and builds indexes for the requested fields. */\n  enableIndexingForType<T extends Entity>(meta: EntityMetadata<T>, entities: T[], where: object): void {\n    const { tagName } = meta;\n    if (!this.#indexes.has(tagName)) {\n      this.#indexes.set(tagName, new Map());\n    }\n\n    const fieldNames = Object.keys(where);\n    const fieldIndexes = this.#indexes.get(tagName)!;\n    const missingFieldNames = fieldNames.filter((fieldName) => !fieldIndexes.has(fieldName));\n    if (missingFieldNames.length === 0) return;\n\n    // If subtypes are involved, group by each subtype\n    if (meta.baseType || meta.subTypes.length > 0) {\n      [...groupBy(entities, (e) => getMetadata(e)).entries()].forEach(([meta, entities]) => {\n        this.addEntitiesToIndex(meta, entities, missingFieldNames);\n      });\n    } else {\n      this.addEntitiesToIndex(meta, entities, missingFieldNames);\n    }\n  }\n\n  /** Updates indexes when a field value changes. */\n  maybeUpdateFieldIndex(entity: Entity, fieldName: string, oldValue: any, newValue: any): void {\n    // Fast return for the common case, which is no indexing\n    if (this.#indexes.size === 0) return;\n\n    const meta = getMetadata(entity);\n    const fieldIndexes = this.#indexes.get(meta.tagName);\n    if (!fieldIndexes) return; // Type not indexed\n\n    const fieldIndex = fieldIndexes.get(fieldName)?.index;\n    if (!fieldIndex) return; // Field is not indexed\n\n    fieldIndex.remove(oldValue, entity);\n    fieldIndex.add(newValue, entity);\n  }\n\n  /**\n   * Finds entities matching the given where clause using indexes.\n   *\n   * Returns the raw candidate set (possibly a live internal index set, so do not mutate it);\n   * the caller applies its own subtype/deleted filtering while building the final array.\n   */\n  findMatching<T extends Entity>(meta: EntityMetadata<T>, entities: T[], where: any): ReadonlySet<T> {\n    const { tagName } = meta;\n    if (!this.#indexes.has(tagName)) {\n      throw new Error(`${meta.type} is not indexed`);\n    }\n    const fieldIndexes = this.#indexes.get(tagName)!;\n    // Start with all entities of the 1st condition, then intersect (AND) each subsequent field in `where`\n    let candidates: Set<Entity> | undefined;\n    for (const [fieldName, value] of Object.entries(where)) {\n      this.indexUnindexedEntities(entities, fieldName);\n      const fieldCandidates = fieldIndexes.get(fieldName)?.index.get(value);\n      if (!candidates) {\n        candidates = fieldCandidates ?? emptySet; // This is the 1st clause\n      } else {\n        candidates = fieldCandidates ? intersectSets(candidates, fieldCandidates) : emptySet;\n      }\n      // Early exit if no candidates remain\n      if (candidates.size === 0) break;\n    }\n    if (candidates === undefined) {\n      throw new Error(`Expected where clause with at least one condition`);\n    }\n    return candidates as unknown as ReadonlySet<T>;\n  }\n\n  // `entities` should all be of the exact same subtype\n  private addEntitiesToIndex(meta: EntityMetadata, entities: Entity[], fieldNames: string[]): void {\n    const { tagName } = meta;\n    const indexes = this.#indexes.get(tagName)!;\n    // Iterate over each field so we can do a shared fieldIndex lookup\n    for (const fieldName of fieldNames) {\n      const field = meta.allFields[fieldName];\n      if (!field) continue;\n      let entry = indexes.get(fieldName);\n      if (!entry) {\n        entry = { field, index: new FieldIndex(meta.columns[fieldName]?.isArray ?? false), indexedCount: 0 };\n        indexes.set(fieldName, entry);\n      }\n      for (const entity of entities) {\n        // Deleted entities never match, and reading a flushed one's relations throws\n        if (entity.isDeletedEntity) continue;\n        const value = getFieldValue(entity, fieldName, entry.field);\n        entry.index.add(value, entity);\n      }\n      entry.indexedCount = entities.length;\n    }\n  }\n\n  /** Lazily indexes newly-registered entities only for fields that are queried. */\n  private indexUnindexedEntities<T extends Entity>(entities: T[], fieldName: string): void {\n    const first = entities[0];\n    if (first === undefined) return;\n\n    const meta = getMetadata(first);\n    const entry = this.#indexes.get(meta.tagName)?.get(fieldName);\n    if (entry === undefined || entry.indexedCount === entities.length) return;\n\n    for (let i = entry.indexedCount; i < entities.length; i++) {\n      const entity = entities[i];\n      if (entity.isDeletedEntity) continue;\n      const value = getFieldValue(entity, fieldName, entry.field);\n      entry.index.add(value, entity);\n    }\n    entry.indexedCount = entities.length;\n  }\n}\n\n// Use the same field access pattern as entityMatches\nfunction getFieldValue(entity: Entity, fieldName: string, field: Field): any {\n  const fn = fieldName as keyof Entity;\n  switch (field.kind) {\n    case \"primaryKey\":\n      return entity.idTaggedMaybe;\n    case \"enum\":\n    case \"primitive\":\n      return (entity as any)[fn];\n    case \"m2o\":\n    case \"poly\":\n      const relation = (entity as any)[fn] as\n        | ManyToOneReference<Entity, any, any>\n        | PolymorphicReference<Entity, any, any>;\n      if (isLoadedReference(relation)) {\n        return relation.get;\n      } else if (relation.isSet) {\n        return relation.id;\n      } else {\n        return undefined;\n      }\n    default:\n      return undefined;\n  }\n}\n\n/**\n * For a given field, like `firstName`, holds the reverse index of value `bob` -> entities `[a1, a2]`.\n *\n * This also handles indexes `Entity` values as both instances & IDs, to handle both:\n * - new/unpersisted entities not yet having IDs, and\n * - relations not having loaded their instances yet\n */\nclass FieldIndex {\n  readonly #valueToEntities = new Map<FieldValue, Set<Entity>>();\n  // Keep serialized arrays separate so their keys cannot collide with scalar string values.\n  readonly #arrayToEntities = new Map<string, Set<Entity>>();\n\n  constructor(private readonly isArray: boolean) {}\n\n  /** @return entities that have `value` as their current value for this field. */\n  get(value: any): Set<Entity> | undefined {\n    if (isEntity(value) && value.idTaggedMaybe) {\n      // If `value` is a persisted entity like `a:1`, and entities could have indexed their `author_id=a:1` field\n      // values as the unloaded \"just an a:1 string id\" value, before `a:1` was loaded into memory.\n      const matchId = this.#valueToEntities.get(value.idTaggedMaybe);\n      // But other entities could also have indexes `a:1` as an instance, so go ahead and check both\n      const matchInstance = this.#valueToEntities.get(value);\n      if (matchId && matchInstance) {\n        return new Set([...matchId, ...matchInstance]);\n      }\n      return matchId ?? matchInstance;\n    }\n    // Treat null and undefined as equivalent for unset relations\n    if (value === null) value = undefined;\n    const arrayKey = this.maybeArrayKey(value);\n    if (arrayKey !== undefined) return this.#arrayToEntities.get(arrayKey);\n    return this.#valueToEntities.get(value);\n  }\n\n  add(value: any, entity: Entity): void {\n    // If this is an entity, store both the entity itself & its ID\n    if (isEntity(value) && value.idTaggedMaybe) {\n      this.doAdd(value.idTaggedMaybe, entity);\n    }\n    this.doAdd(value, entity);\n  }\n\n  remove(value: any, entity: Entity): void {\n    if (isEntity(value) && value.idTaggedMaybe) {\n      this.doRemove(value.idTaggedMaybe, entity);\n    }\n    this.doRemove(value, entity);\n  }\n\n  private doAdd(value: any, entity: Entity): void {\n    const arrayKey = this.maybeArrayKey(value);\n    const index = arrayKey === undefined ? this.#valueToEntities : this.#arrayToEntities;\n    const key = arrayKey ?? value;\n    const set = index.get(key) ?? new Set();\n    if (set.size === 0) index.set(key, set);\n    set.add(entity);\n  }\n\n  private doRemove(value: any, entity: Entity): void {\n    const arrayKey = this.maybeArrayKey(value);\n    const index = arrayKey === undefined ? this.#valueToEntities : this.#arrayToEntities;\n    const key = arrayKey ?? value;\n    const set = index.get(key);\n    if (set) {\n      set.delete(entity);\n      if (set.size === 0) {\n        index.delete(key);\n      }\n    }\n  }\n\n  /** Preserves array order and element types, including bigint values that JSON cannot encode. */\n  private maybeArrayKey(value: unknown): string | undefined {\n    return this.isArray && Array.isArray(value) ? fastWhereFilterHash(value) : undefined;\n  }\n}\n\nfunction intersectSets<T>(set1: Set<T>, set2: Set<T>): Set<T> {\n  const [smaller, larger] = set1.size <= set2.size ? [set1, set2] : [set2, set1];\n  const result = new Set<T>();\n  for (const item of smaller) {\n    if (larger.has(item)) {\n      result.add(item);\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}

package/build/IndexManager.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"IndexManager.d.cts","names":[],"sources":["../src/IndexManager.ts"],"mappings":";;;cAiBa;;;;;;;;;cAUA;;;EAIX,gBAAgB;;EAKhB,UAAU;;EAKV,sBAAsB,UAAU,QAAQ,MAAM,eAAe,IAAI,UAAU,KAAK;;EAsBhF,sBAAsB,QAAQ,QAAQ,mBAAmB,eAAe;;;;;;;EAqBxE,aAAa,UAAU,QAAQ,MAAM,eAAe,IAAI,UAAU,KAAK,aAAa,YAAY;UA0BxF;;UAuBA"}
+{"version":3,"file":"IndexManager.d.cts","names":[],"sources":["../src/IndexManager.ts"],"mappings":";;;cAkBa;;;;;;;;;cAUA;;;EAIX,gBAAgB;;EAKhB,UAAU;;EAKV,sBAAsB,UAAU,QAAQ,MAAM,eAAe,IAAI,UAAU,KAAK;;EAsBhF,sBAAsB,QAAQ,QAAQ,mBAAmB,eAAe;;;;;;;EAqBxE,aAAa,UAAU,QAAQ,MAAM,eAAe,IAAI,UAAU,KAAK,aAAa,YAAY;UA0BxF;;UAuBA"}

package/build/IndexManager.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"IndexManager.d.mts","names":[],"sources":["../src/IndexManager.ts"],"mappings":";;;cAiBa;;;;;;;;;cAUA;;;EAIX,gBAAgB;;EAKhB,UAAU;;EAKV,sBAAsB,UAAU,QAAQ,MAAM,eAAe,IAAI,UAAU,KAAK;;EAsBhF,sBAAsB,QAAQ,QAAQ,mBAAmB,eAAe;;;;;;;EAqBxE,aAAa,UAAU,QAAQ,MAAM,eAAe,IAAI,UAAU,KAAK,aAAa,YAAY;UA0BxF;;UAuBA"}
+{"version":3,"file":"IndexManager.d.mts","names":[],"sources":["../src/IndexManager.ts"],"mappings":";;;cAkBa;;;;;;;;;cAUA;;;EAIX,gBAAgB;;EAKhB,UAAU;;EAKV,sBAAsB,UAAU,QAAQ,MAAM,eAAe,IAAI,UAAU,KAAK;;EAsBhF,sBAAsB,QAAQ,QAAQ,mBAAmB,eAAe;;;;;;;EAqBxE,aAAa,UAAU,QAAQ,MAAM,eAAe,IAAI,UAAU,KAAK,aAAa,YAAY;UA0BxF;;UAuBA"}

package/build/IndexManager.js

@@ -2,6 +2,7 @@ import { isLoadedReference } from "./relations/Reference.js";
 import "./relations/index.js";
 import { groupBy } from "./utils.js";
 import { getMetadata } from "./EntityMetadata.js";
+import { fastWhereFilterHash } from "./dataloaders/fastWhereFilterHash.js";
 import { isEntity } from "./Entity.js";
 //#region src/IndexManager.ts
 const emptySet = /* @__PURE__ */ new Set();
@@ -79,7 +80,7 @@ var IndexManager = class {
 			if (!entry) {
 				entry = {
 					field,
-					index: new FieldIndex(),
+					index: new FieldIndex(meta.columns[fieldName]?.isArray ?? false),
 					indexedCount: 0
 				};
 				indexes.set(fieldName, entry);
@@ -131,7 +132,12 @@ function getFieldValue(entity, fieldName, field) {
 * - relations not having loaded their instances yet
 */
 var FieldIndex = class {
+	isArray;
 	#valueToEntities = /* @__PURE__ */ new Map();
+	#arrayToEntities = /* @__PURE__ */ new Map();
+	constructor(isArray) {
+		this.isArray = isArray;
+	}
 	/** @return entities that have `value` as their current value for this field. */
 	get(value) {
 		if (isEntity(value) && value.idTaggedMaybe) {
@@ -141,6 +147,8 @@ var FieldIndex = class {
 			return matchId ?? matchInstance;
 		}
 		if (value === null) value = void 0;
+		const arrayKey = this.maybeArrayKey(value);
+		if (arrayKey !== void 0) return this.#arrayToEntities.get(arrayKey);
 		return this.#valueToEntities.get(value);
 	}
 	add(value, entity) {
@@ -152,17 +160,27 @@ var FieldIndex = class {
 		this.doRemove(value, entity);
 	}
 	doAdd(value, entity) {
-		const set = this.#valueToEntities.get(value) ?? /* @__PURE__ */ new Set();
-		if (set.size === 0) this.#valueToEntities.set(value, set);
+		const arrayKey = this.maybeArrayKey(value);
+		const index = arrayKey === void 0 ? this.#valueToEntities : this.#arrayToEntities;
+		const key = arrayKey ?? value;
+		const set = index.get(key) ?? /* @__PURE__ */ new Set();
+		if (set.size === 0) index.set(key, set);
 		set.add(entity);
 	}
 	doRemove(value, entity) {
-		const set = this.#valueToEntities.get(value);
+		const arrayKey = this.maybeArrayKey(value);
+		const index = arrayKey === void 0 ? this.#valueToEntities : this.#arrayToEntities;
+		const key = arrayKey ?? value;
+		const set = index.get(key);
 		if (set) {
 			set.delete(entity);
-			if (set.size === 0) this.#valueToEntities.delete(value);
+			if (set.size === 0) index.delete(key);
 		}
 	}
+	/** Preserves array order and element types, including bigint values that JSON cannot encode. */
+	maybeArrayKey(value) {
+		return this.isArray && Array.isArray(value) ? fastWhereFilterHash(value) : void 0;
+	}
 };
 function intersectSets(set1, set2) {
 	const [smaller, larger] = set1.size <= set2.size ? [set1, set2] : [set2, set1];

package/build/IndexManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"IndexManager.js","names":["#indexes","#valueToEntities"],"sources":["../src/IndexManager.ts"],"sourcesContent":["import { type Entity, isEntity } from \"src/Entity.ts\";\nimport { type EntityMetadata, type Field, getMetadata } from \"src/EntityMetadata.ts\";\nimport { type ManyToOneReference, type PolymorphicReference, isLoadedReference } from \"src/relations/index.ts\";\nimport { groupBy } from \"src/utils.ts\";\n\ntype FieldValue = any;\ntype FieldName = string;\ntype EntityTag = string;\ntype FieldIndexEntry = {\n  field: Field;\n  index: FieldIndex;\n  /** Tracks how far into the EM's list-per-tag array this field index has been lazily populated. */\n  indexedCount: number;\n};\nconst emptySet = new Set<Entity>();\n\n// The test reproducing a n^2 with n=500 went from 100ms to 50ms if indexed\nexport const indexThreshold = 500;\n\n/**\n * IndexManager provides field-based indexing for entity queries to avoid O(n) linear scans of `em.entities`.\n *\n * Key features:\n * - Only indexes entity types with >1000 entities to avoid overhead for small datasets\n * - Supports dual indexing for m2o/poly fields (by ID for saved, by instance for unsaved)\n * - Automatically maintains indexes when fields are updated via setField()\n */\nexport class IndexManager {\n  readonly #indexes: Map<EntityTag, Map<FieldName, FieldIndexEntry>> = new Map();\n\n  /** @return if we should index entities of this type/count. */\n  shouldIndexType(entityCount: number): boolean {\n    return entityCount >= indexThreshold;\n  }\n\n  /** Visible for testing. */\n  isIndexed(tagName: string): boolean {\n    return this.#indexes.has(tagName);\n  }\n\n  /** Enables indexing for an entity type and builds indexes for the requested fields. */\n  enableIndexingForType<T extends Entity>(meta: EntityMetadata<T>, entities: T[], where: object): void {\n    const { tagName } = meta;\n    if (!this.#indexes.has(tagName)) {\n      this.#indexes.set(tagName, new Map());\n    }\n\n    const fieldNames = Object.keys(where);\n    const fieldIndexes = this.#indexes.get(tagName)!;\n    const missingFieldNames = fieldNames.filter((fieldName) => !fieldIndexes.has(fieldName));\n    if (missingFieldNames.length === 0) return;\n\n    // If subtypes are involved, group by each subtype\n    if (meta.baseType || meta.subTypes.length > 0) {\n      [...groupBy(entities, (e) => getMetadata(e)).entries()].forEach(([meta, entities]) => {\n        this.addEntitiesToIndex(meta, entities, missingFieldNames);\n      });\n    } else {\n      this.addEntitiesToIndex(meta, entities, missingFieldNames);\n    }\n  }\n\n  /** Updates indexes when a field value changes. */\n  maybeUpdateFieldIndex(entity: Entity, fieldName: string, oldValue: any, newValue: any): void {\n    // Fast return for the common case, which is no indexing\n    if (this.#indexes.size === 0) return;\n\n    const meta = getMetadata(entity);\n    const fieldIndexes = this.#indexes.get(meta.tagName);\n    if (!fieldIndexes) return; // Type not indexed\n\n    const fieldIndex = fieldIndexes.get(fieldName)?.index;\n    if (!fieldIndex) return; // Field is not indexed\n\n    fieldIndex.remove(oldValue, entity);\n    fieldIndex.add(newValue, entity);\n  }\n\n  /**\n   * Finds entities matching the given where clause using indexes.\n   *\n   * Returns the raw candidate set (possibly a live internal index set, so do not mutate it);\n   * the caller applies its own subtype/deleted filtering while building the final array.\n   */\n  findMatching<T extends Entity>(meta: EntityMetadata<T>, entities: T[], where: any): ReadonlySet<T> {\n    const { tagName } = meta;\n    if (!this.#indexes.has(tagName)) {\n      throw new Error(`${meta.type} is not indexed`);\n    }\n    const fieldIndexes = this.#indexes.get(tagName)!;\n    // Start with all entities of the 1st condition, then intersect (AND) each subsequent field in `where`\n    let candidates: Set<Entity> | undefined;\n    for (const [fieldName, value] of Object.entries(where)) {\n      this.indexUnindexedEntities(entities, fieldName);\n      const fieldCandidates = fieldIndexes.get(fieldName)?.index.get(value);\n      if (!candidates) {\n        candidates = fieldCandidates ?? emptySet; // This is the 1st clause\n      } else {\n        candidates = fieldCandidates ? intersectSets(candidates, fieldCandidates) : emptySet;\n      }\n      // Early exit if no candidates remain\n      if (candidates.size === 0) break;\n    }\n    if (candidates === undefined) {\n      throw new Error(`Expected where clause with at least one condition`);\n    }\n    return candidates as unknown as ReadonlySet<T>;\n  }\n\n  // `entities` should all be of the exact same subtype\n  private addEntitiesToIndex(meta: EntityMetadata, entities: Entity[], fieldNames: string[]): void {\n    const { tagName } = meta;\n    const indexes = this.#indexes.get(tagName)!;\n    // Iterate over each field so we can do a shared fieldIndex lookup\n    for (const fieldName of fieldNames) {\n      const field = meta.allFields[fieldName];\n      if (!field) continue;\n      let entry = indexes.get(fieldName);\n      if (!entry) {\n        entry = { field, index: new FieldIndex(), indexedCount: 0 };\n        indexes.set(fieldName, entry);\n      }\n      for (const entity of entities) {\n        // Deleted entities never match, and reading a flushed one's relations throws\n        if (entity.isDeletedEntity) continue;\n        const value = getFieldValue(entity, fieldName, entry.field);\n        entry.index.add(value, entity);\n      }\n      entry.indexedCount = entities.length;\n    }\n  }\n\n  /** Lazily indexes newly-registered entities only for fields that are queried. */\n  private indexUnindexedEntities<T extends Entity>(entities: T[], fieldName: string): void {\n    const first = entities[0];\n    if (first === undefined) return;\n\n    const meta = getMetadata(first);\n    const entry = this.#indexes.get(meta.tagName)?.get(fieldName);\n    if (entry === undefined || entry.indexedCount === entities.length) return;\n\n    for (let i = entry.indexedCount; i < entities.length; i++) {\n      const entity = entities[i];\n      if (entity.isDeletedEntity) continue;\n      const value = getFieldValue(entity, fieldName, entry.field);\n      entry.index.add(value, entity);\n    }\n    entry.indexedCount = entities.length;\n  }\n}\n\n// Use the same field access pattern as entityMatches\nfunction getFieldValue(entity: Entity, fieldName: string, field: Field): any {\n  const fn = fieldName as keyof Entity;\n  switch (field.kind) {\n    case \"primaryKey\":\n      return entity.idTaggedMaybe;\n    case \"enum\":\n    case \"primitive\":\n      return (entity as any)[fn];\n    case \"m2o\":\n    case \"poly\":\n      const relation = (entity as any)[fn] as\n        | ManyToOneReference<Entity, any, any>\n        | PolymorphicReference<Entity, any, any>;\n      if (isLoadedReference(relation)) {\n        return relation.get;\n      } else if (relation.isSet) {\n        return relation.id;\n      } else {\n        return undefined;\n      }\n    default:\n      return undefined;\n  }\n}\n\n/**\n * For a given field, like `firstName`, holds the reverse index of value `bob` -> entities `[a1, a2]`.\n *\n * This also handles indexes `Entity` values as both instances & IDs, to handle both:\n * - new/unpersisted entities not yet having IDs, and\n * - relations not having loaded their instances yet\n */\nclass FieldIndex {\n  readonly #valueToEntities = new Map<FieldValue, Set<Entity>>();\n\n  /** @return entities that have `value` as their current value for this field. */\n  get(value: any): Set<Entity> | undefined {\n    if (isEntity(value) && value.idTaggedMaybe) {\n      // If `value` is a persisted entity like `a:1`, and entities could have indexed their `author_id=a:1` field\n      // values as the unloaded \"just an a:1 string id\" value, before `a:1` was loaded into memory.\n      const matchId = this.#valueToEntities.get(value.idTaggedMaybe);\n      // But other entities could also have indexes `a:1` as an instance, so go ahead and check both\n      const matchInstance = this.#valueToEntities.get(value);\n      if (matchId && matchInstance) {\n        return new Set([...matchId, ...matchInstance]);\n      }\n      return matchId ?? matchInstance;\n    }\n    // Treat null and undefined as equivalent for unset relations\n    if (value === null) value = undefined;\n    return this.#valueToEntities.get(value);\n  }\n\n  add(value: any, entity: Entity): void {\n    // If this is an entity, store both the entity itself & its ID\n    if (isEntity(value) && value.idTaggedMaybe) {\n      this.doAdd(value.idTaggedMaybe, entity);\n    }\n    this.doAdd(value, entity);\n  }\n\n  remove(value: any, entity: Entity): void {\n    if (isEntity(value) && value.idTaggedMaybe) {\n      this.doRemove(value.idTaggedMaybe, entity);\n    }\n    this.doRemove(value, entity);\n  }\n\n  private doAdd(value: any, entity: Entity): void {\n    const set = this.#valueToEntities.get(value) ?? new Set();\n    if (set.size === 0) this.#valueToEntities.set(value, set);\n    set.add(entity);\n  }\n\n  private doRemove(value: any, entity: Entity): void {\n    const set = this.#valueToEntities.get(value);\n    if (set) {\n      set.delete(entity);\n      if (set.size === 0) {\n        this.#valueToEntities.delete(value);\n      }\n    }\n  }\n}\n\nfunction intersectSets<T>(set1: Set<T>, set2: Set<T>): Set<T> {\n  const [smaller, larger] = set1.size <= set2.size ? [set1, set2] : [set2, set1];\n  const result = new Set<T>();\n  for (const item of smaller) {\n    if (larger.has(item)) {\n      result.add(item);\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}
+{"version":3,"file":"IndexManager.js","names":["#indexes","#valueToEntities","#arrayToEntities"],"sources":["../src/IndexManager.ts"],"sourcesContent":["import { fastWhereFilterHash } from \"src/dataloaders/fastWhereFilterHash.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\nimport { type EntityMetadata, type Field, getMetadata } from \"src/EntityMetadata.ts\";\nimport { type ManyToOneReference, type PolymorphicReference, isLoadedReference } from \"src/relations/index.ts\";\nimport { groupBy } from \"src/utils.ts\";\n\ntype FieldValue = any;\ntype FieldName = string;\ntype EntityTag = string;\ntype FieldIndexEntry = {\n  field: Field;\n  index: FieldIndex;\n  /** Tracks how far into the EM's list-per-tag array this field index has been lazily populated. */\n  indexedCount: number;\n};\nconst emptySet = new Set<Entity>();\n\n// The test reproducing a n^2 with n=500 went from 100ms to 50ms if indexed\nexport const indexThreshold = 500;\n\n/**\n * IndexManager provides field-based indexing for entity queries to avoid O(n) linear scans of `em.entities`.\n *\n * Key features:\n * - Only indexes entity types with >1000 entities to avoid overhead for small datasets\n * - Supports dual indexing for m2o/poly fields (by ID for saved, by instance for unsaved)\n * - Automatically maintains indexes when fields are updated via setField()\n */\nexport class IndexManager {\n  readonly #indexes: Map<EntityTag, Map<FieldName, FieldIndexEntry>> = new Map();\n\n  /** @return if we should index entities of this type/count. */\n  shouldIndexType(entityCount: number): boolean {\n    return entityCount >= indexThreshold;\n  }\n\n  /** Visible for testing. */\n  isIndexed(tagName: string): boolean {\n    return this.#indexes.has(tagName);\n  }\n\n  /** Enables indexing for an entity type and builds indexes for the requested fields. */\n  enableIndexingForType<T extends Entity>(meta: EntityMetadata<T>, entities: T[], where: object): void {\n    const { tagName } = meta;\n    if (!this.#indexes.has(tagName)) {\n      this.#indexes.set(tagName, new Map());\n    }\n\n    const fieldNames = Object.keys(where);\n    const fieldIndexes = this.#indexes.get(tagName)!;\n    const missingFieldNames = fieldNames.filter((fieldName) => !fieldIndexes.has(fieldName));\n    if (missingFieldNames.length === 0) return;\n\n    // If subtypes are involved, group by each subtype\n    if (meta.baseType || meta.subTypes.length > 0) {\n      [...groupBy(entities, (e) => getMetadata(e)).entries()].forEach(([meta, entities]) => {\n        this.addEntitiesToIndex(meta, entities, missingFieldNames);\n      });\n    } else {\n      this.addEntitiesToIndex(meta, entities, missingFieldNames);\n    }\n  }\n\n  /** Updates indexes when a field value changes. */\n  maybeUpdateFieldIndex(entity: Entity, fieldName: string, oldValue: any, newValue: any): void {\n    // Fast return for the common case, which is no indexing\n    if (this.#indexes.size === 0) return;\n\n    const meta = getMetadata(entity);\n    const fieldIndexes = this.#indexes.get(meta.tagName);\n    if (!fieldIndexes) return; // Type not indexed\n\n    const fieldIndex = fieldIndexes.get(fieldName)?.index;\n    if (!fieldIndex) return; // Field is not indexed\n\n    fieldIndex.remove(oldValue, entity);\n    fieldIndex.add(newValue, entity);\n  }\n\n  /**\n   * Finds entities matching the given where clause using indexes.\n   *\n   * Returns the raw candidate set (possibly a live internal index set, so do not mutate it);\n   * the caller applies its own subtype/deleted filtering while building the final array.\n   */\n  findMatching<T extends Entity>(meta: EntityMetadata<T>, entities: T[], where: any): ReadonlySet<T> {\n    const { tagName } = meta;\n    if (!this.#indexes.has(tagName)) {\n      throw new Error(`${meta.type} is not indexed`);\n    }\n    const fieldIndexes = this.#indexes.get(tagName)!;\n    // Start with all entities of the 1st condition, then intersect (AND) each subsequent field in `where`\n    let candidates: Set<Entity> | undefined;\n    for (const [fieldName, value] of Object.entries(where)) {\n      this.indexUnindexedEntities(entities, fieldName);\n      const fieldCandidates = fieldIndexes.get(fieldName)?.index.get(value);\n      if (!candidates) {\n        candidates = fieldCandidates ?? emptySet; // This is the 1st clause\n      } else {\n        candidates = fieldCandidates ? intersectSets(candidates, fieldCandidates) : emptySet;\n      }\n      // Early exit if no candidates remain\n      if (candidates.size === 0) break;\n    }\n    if (candidates === undefined) {\n      throw new Error(`Expected where clause with at least one condition`);\n    }\n    return candidates as unknown as ReadonlySet<T>;\n  }\n\n  // `entities` should all be of the exact same subtype\n  private addEntitiesToIndex(meta: EntityMetadata, entities: Entity[], fieldNames: string[]): void {\n    const { tagName } = meta;\n    const indexes = this.#indexes.get(tagName)!;\n    // Iterate over each field so we can do a shared fieldIndex lookup\n    for (const fieldName of fieldNames) {\n      const field = meta.allFields[fieldName];\n      if (!field) continue;\n      let entry = indexes.get(fieldName);\n      if (!entry) {\n        entry = { field, index: new FieldIndex(meta.columns[fieldName]?.isArray ?? false), indexedCount: 0 };\n        indexes.set(fieldName, entry);\n      }\n      for (const entity of entities) {\n        // Deleted entities never match, and reading a flushed one's relations throws\n        if (entity.isDeletedEntity) continue;\n        const value = getFieldValue(entity, fieldName, entry.field);\n        entry.index.add(value, entity);\n      }\n      entry.indexedCount = entities.length;\n    }\n  }\n\n  /** Lazily indexes newly-registered entities only for fields that are queried. */\n  private indexUnindexedEntities<T extends Entity>(entities: T[], fieldName: string): void {\n    const first = entities[0];\n    if (first === undefined) return;\n\n    const meta = getMetadata(first);\n    const entry = this.#indexes.get(meta.tagName)?.get(fieldName);\n    if (entry === undefined || entry.indexedCount === entities.length) return;\n\n    for (let i = entry.indexedCount; i < entities.length; i++) {\n      const entity = entities[i];\n      if (entity.isDeletedEntity) continue;\n      const value = getFieldValue(entity, fieldName, entry.field);\n      entry.index.add(value, entity);\n    }\n    entry.indexedCount = entities.length;\n  }\n}\n\n// Use the same field access pattern as entityMatches\nfunction getFieldValue(entity: Entity, fieldName: string, field: Field): any {\n  const fn = fieldName as keyof Entity;\n  switch (field.kind) {\n    case \"primaryKey\":\n      return entity.idTaggedMaybe;\n    case \"enum\":\n    case \"primitive\":\n      return (entity as any)[fn];\n    case \"m2o\":\n    case \"poly\":\n      const relation = (entity as any)[fn] as\n        | ManyToOneReference<Entity, any, any>\n        | PolymorphicReference<Entity, any, any>;\n      if (isLoadedReference(relation)) {\n        return relation.get;\n      } else if (relation.isSet) {\n        return relation.id;\n      } else {\n        return undefined;\n      }\n    default:\n      return undefined;\n  }\n}\n\n/**\n * For a given field, like `firstName`, holds the reverse index of value `bob` -> entities `[a1, a2]`.\n *\n * This also handles indexes `Entity` values as both instances & IDs, to handle both:\n * - new/unpersisted entities not yet having IDs, and\n * - relations not having loaded their instances yet\n */\nclass FieldIndex {\n  readonly #valueToEntities = new Map<FieldValue, Set<Entity>>();\n  // Keep serialized arrays separate so their keys cannot collide with scalar string values.\n  readonly #arrayToEntities = new Map<string, Set<Entity>>();\n\n  constructor(private readonly isArray: boolean) {}\n\n  /** @return entities that have `value` as their current value for this field. */\n  get(value: any): Set<Entity> | undefined {\n    if (isEntity(value) && value.idTaggedMaybe) {\n      // If `value` is a persisted entity like `a:1`, and entities could have indexed their `author_id=a:1` field\n      // values as the unloaded \"just an a:1 string id\" value, before `a:1` was loaded into memory.\n      const matchId = this.#valueToEntities.get(value.idTaggedMaybe);\n      // But other entities could also have indexes `a:1` as an instance, so go ahead and check both\n      const matchInstance = this.#valueToEntities.get(value);\n      if (matchId && matchInstance) {\n        return new Set([...matchId, ...matchInstance]);\n      }\n      return matchId ?? matchInstance;\n    }\n    // Treat null and undefined as equivalent for unset relations\n    if (value === null) value = undefined;\n    const arrayKey = this.maybeArrayKey(value);\n    if (arrayKey !== undefined) return this.#arrayToEntities.get(arrayKey);\n    return this.#valueToEntities.get(value);\n  }\n\n  add(value: any, entity: Entity): void {\n    // If this is an entity, store both the entity itself & its ID\n    if (isEntity(value) && value.idTaggedMaybe) {\n      this.doAdd(value.idTaggedMaybe, entity);\n    }\n    this.doAdd(value, entity);\n  }\n\n  remove(value: any, entity: Entity): void {\n    if (isEntity(value) && value.idTaggedMaybe) {\n      this.doRemove(value.idTaggedMaybe, entity);\n    }\n    this.doRemove(value, entity);\n  }\n\n  private doAdd(value: any, entity: Entity): void {\n    const arrayKey = this.maybeArrayKey(value);\n    const index = arrayKey === undefined ? this.#valueToEntities : this.#arrayToEntities;\n    const key = arrayKey ?? value;\n    const set = index.get(key) ?? new Set();\n    if (set.size === 0) index.set(key, set);\n    set.add(entity);\n  }\n\n  private doRemove(value: any, entity: Entity): void {\n    const arrayKey = this.maybeArrayKey(value);\n    const index = arrayKey === undefined ? this.#valueToEntities : this.#arrayToEntities;\n    const key = arrayKey ?? value;\n    const set = index.get(key);\n    if (set) {\n      set.delete(entity);\n      if (set.size === 0) {\n        index.delete(key);\n      }\n    }\n  }\n\n  /** Preserves array order and element types, including bigint values that JSON cannot encode. */\n  private maybeArrayKey(value: unknown): string | undefined {\n    return this.isArray && Array.isArray(value) ? fastWhereFilterHash(value) : undefined;\n  }\n}\n\nfunction intersectSets<T>(set1: Set<T>, set2: Set<T>): Set<T> {\n  const [smaller, larger] = set1.size <= set2.size ? [set1, set2] : [set2, set1];\n  const result = new Set<T>();\n  for (const item of smaller) {\n    if (larger.has(item)) {\n      result.add(item);\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}

package/build/batchloaders/populateBatchLoader.cjs

@@ -1,7 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./BatchLoader.cjs");
-const require_normalizeHints = require("../normalizeHints.cjs");
-const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
 const require_keys = require("../keys.cjs");
 const require_queries_sql_keywords = require("../queries/sql/keywords.cjs");
 const require_batchloaders_manyToManyBatchLoader = require("./manyToManyBatchLoader.cjs");
@@ -10,6 +8,8 @@ const require_queries_find_QueryParser = require("../queries/find/QueryParser.cj
 const require_batchloaders_oneToOneBatchLoader = require("./oneToOneBatchLoader.cjs");
 const require_relations_ReactiveField = require("../relations/ReactiveField.cjs");
 const require_utils = require("../utils.cjs");
+const require_normalizeHints = require("../normalizeHints.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
 require("../EntityMetadata.cjs");
 const require_queries_sql_AliasAssigner = require("../queries/sql/AliasAssigner.cjs");
 const require_loading_HintTree = require("../loading/HintTree.cjs");

package/build/batchloaders/populateBatchLoader.js

@@ -1,6 +1,4 @@
 import "./BatchLoader.js";
-import { hintKey } from "../normalizeHints.js";
-import { getRelationFromMaybePolyKey, isPolyHint } from "../reactivity/reactiveHints.js";
 import { keyToNumber } from "../keys.js";
 import { kqDot } from "../queries/sql/keywords.js";
 import { manyToManyBatchLoader } from "./manyToManyBatchLoader.js";
@@ -9,6 +7,8 @@ import { addTablePerClassJoinsAndClassTag } from "../queries/find/QueryParser.js
 import { oneToOneBatchLoader } from "./oneToOneBatchLoader.js";
 import { ReactiveFieldImpl } from "../relations/ReactiveField.js";
 import { indexBy, toArray } from "../utils.js";
+import { hintKey } from "../normalizeHints.js";
+import { getRelationFromMaybePolyKey, isPolyHint } from "../reactivity/reactiveHints.js";
 import "../EntityMetadata.js";
 import { AliasAssigner } from "../queries/sql/AliasAssigner.js";
 import { buildHintTree } from "../loading/HintTree.js";