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

package/build/EntityMetadata.cjs.map

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

package/build/EntityMetadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"EntityMetadata.js","names":[],"sources":["../src/EntityMetadata.ts"],"sourcesContent":["import { getInstanceData } from \"./BaseEntity.ts\";\nimport { type ConfigApi, type Reactable, type ReactiveRule } from \"./config.ts\";\nimport { getMetadataForType } from \"./configure.ts\";\nimport { type Entity, isEntity } from \"./Entity.ts\";\nimport { type EntityManager, type MaybeAbstractEntityConstructor, type TimestampFields } from \"./EntityManager.ts\";\nimport { type EnumMetadata } from \"./EnumMetadata.ts\";\nimport type { DeepNew } from \"./loading/loadHints.ts\";\nimport type { Column, ColumnDescriptors } from \"./serde/columns.ts\";\nimport type { FieldSerde, PolymorphicKeySerde } from \"./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, 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"}

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 \"./Entity.ts\";\nimport { type EntityMetadata, type Field, getMetadata } from \"./EntityMetadata.ts\";\nimport { type ManyToOneReference, type PolymorphicReference, isLoadedReference } from \"./relations/index.ts\";\nimport { groupBy } from \"./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        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      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","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        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      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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"}

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 \"./Entity.ts\";\nimport { type EntityMetadata, type Field, getMetadata } from \"./EntityMetadata.ts\";\nimport { type ManyToOneReference, type PolymorphicReference, isLoadedReference } from \"./relations/index.ts\";\nimport { groupBy } from \"./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        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      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":";;;;;;AAcA,MAAM,2BAAW,IAAI,IAAY;AAGjC,MAAa,iBAAiB;;;;;;;;;AAU9B,IAAa,eAAb,MAA0B;CACxB,2BAAqE,IAAI,IAAI;;CAG7E,gBAAgB,aAA8B;EAC5C,OAAO,eAAA;CACT;;CAGA,UAAU,SAA0B;EAClC,OAAO,KAAKA,SAAS,IAAI,OAAO;CAClC;;CAGA,sBAAwC,MAAyB,UAAe,OAAqB;EACnG,MAAM,EAAE,YAAY;EACpB,IAAI,CAAC,KAAKA,SAAS,IAAI,OAAO,GAC5B,KAAKA,SAAS,IAAI,yBAAS,IAAI,IAAI,CAAC;EAGtC,MAAM,aAAa,OAAO,KAAK,KAAK;EACpC,MAAM,eAAe,KAAKA,SAAS,IAAI,OAAO;EAC9C,MAAM,oBAAoB,WAAW,QAAQ,cAAc,CAAC,aAAa,IAAI,SAAS,CAAC;EACvF,IAAI,kBAAkB,WAAW,GAAG;EAGpC,IAAI,KAAK,YAAY,KAAK,SAAS,SAAS,GAC1C,CAAC,GAAG,QAAQ,WAAW,MAAM,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,cAAc;GACpF,KAAK,mBAAmB,MAAM,UAAU,iBAAiB;EAC3D,CAAC;OAED,KAAK,mBAAmB,MAAM,UAAU,iBAAiB;CAE7D;;CAGA,sBAAsB,QAAgB,WAAmB,UAAe,UAAqB;EAE3F,IAAI,KAAKA,SAAS,SAAS,GAAG;EAE9B,MAAM,OAAO,YAAY,MAAM;EAC/B,MAAM,eAAe,KAAKA,SAAS,IAAI,KAAK,OAAO;EACnD,IAAI,CAAC,cAAc;EAEnB,MAAM,aAAa,aAAa,IAAI,SAAS,CAAC,EAAE;EAChD,IAAI,CAAC,YAAY;EAEjB,WAAW,OAAO,UAAU,MAAM;EAClC,WAAW,IAAI,UAAU,MAAM;CACjC;;;;;;;CAQA,aAA+B,MAAyB,UAAe,OAA4B;EACjG,MAAM,EAAE,YAAY;EACpB,IAAI,CAAC,KAAKA,SAAS,IAAI,OAAO,GAC5B,MAAM,IAAI,MAAM,GAAG,KAAK,KAAK,gBAAgB;EAE/C,MAAM,eAAe,KAAKA,SAAS,IAAI,OAAO;EAE9C,IAAI;EACJ,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,KAAK,GAAG;GACtD,KAAK,uBAAuB,UAAU,SAAS;GAC/C,MAAM,kBAAkB,aAAa,IAAI,SAAS,CAAC,EAAE,MAAM,IAAI,KAAK;GACpE,IAAI,CAAC,YACH,aAAa,mBAAmB;QAEhC,aAAa,kBAAkB,cAAc,YAAY,eAAe,IAAI;GAG9E,IAAI,WAAW,SAAS,GAAG;EAC7B;EACA,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MAAM,mDAAmD;EAErE,OAAO;CACT;CAGA,mBAA2B,MAAsB,UAAoB,YAA4B;EAC/F,MAAM,EAAE,YAAY;EACpB,MAAM,UAAU,KAAKA,SAAS,IAAI,OAAO;EAEzC,KAAK,MAAM,aAAa,YAAY;GAClC,MAAM,QAAQ,KAAK,UAAU;GAC7B,IAAI,CAAC,OAAO;GACZ,IAAI,QAAQ,QAAQ,IAAI,SAAS;GACjC,IAAI,CAAC,OAAO;IACV,QAAQ;KAAE;KAAO,OAAO,IAAI,WAAW;KAAG,cAAc;IAAE;IAC1D,QAAQ,IAAI,WAAW,KAAK;GAC9B;GACA,KAAK,MAAM,UAAU,UAAU;IAC7B,MAAM,QAAQ,cAAc,QAAQ,WAAW,MAAM,KAAK;IAC1D,MAAM,MAAM,IAAI,OAAO,MAAM;GAC/B;GACA,MAAM,eAAe,SAAS;EAChC;CACF;;CAGA,uBAAiD,UAAe,WAAyB;EACvF,MAAM,QAAQ,SAAS;EACvB,IAAI,UAAU,KAAA,GAAW;EAEzB,MAAM,OAAO,YAAY,KAAK;EAC9B,MAAM,QAAQ,KAAKA,SAAS,IAAI,KAAK,OAAO,CAAC,EAAE,IAAI,SAAS;EAC5D,IAAI,UAAU,KAAA,KAAa,MAAM,iBAAiB,SAAS,QAAQ;EAEnE,KAAK,IAAI,IAAI,MAAM,cAAc,IAAI,SAAS,QAAQ,KAAK;GACzD,MAAM,SAAS,SAAS;GACxB,MAAM,QAAQ,cAAc,QAAQ,WAAW,MAAM,KAAK;GAC1D,MAAM,MAAM,IAAI,OAAO,MAAM;EAC/B;EACA,MAAM,eAAe,SAAS;CAChC;AACF;AAGA,SAAS,cAAc,QAAgB,WAAmB,OAAmB;CAC3E,MAAM,KAAK;CACX,QAAQ,MAAM,MAAd;EACE,KAAK,cACH,OAAO,OAAO;EAChB,KAAK;EACL,KAAK,aACH,OAAQ,OAAe;EACzB,KAAK;EACL,KAAK;GACH,MAAM,WAAY,OAAe;GAGjC,IAAI,kBAAkB,QAAQ,GAC5B,OAAO,SAAS;QACX,IAAI,SAAS,OAClB,OAAO,SAAS;QAEhB;EAEJ,SACE;CACJ;AACF;;;;;;;;AASA,IAAM,aAAN,MAAiB;CACf,mCAA4B,IAAI,IAA6B;;CAG7D,IAAI,OAAqC;EACvC,IAAI,SAAS,KAAK,KAAK,MAAM,eAAe;GAG1C,MAAM,UAAU,KAAKC,iBAAiB,IAAI,MAAM,aAAa;GAE7D,MAAM,gBAAgB,KAAKA,iBAAiB,IAAI,KAAK;GACrD,IAAI,WAAW,eACb,uBAAO,IAAI,IAAI,CAAC,GAAG,SAAS,GAAG,aAAa,CAAC;GAE/C,OAAO,WAAW;EACpB;EAEA,IAAI,UAAU,MAAM,QAAQ,KAAA;EAC5B,OAAO,KAAKA,iBAAiB,IAAI,KAAK;CACxC;CAEA,IAAI,OAAY,QAAsB;EAEpC,IAAI,SAAS,KAAK,KAAK,MAAM,eAC3B,KAAK,MAAM,MAAM,eAAe,MAAM;EAExC,KAAK,MAAM,OAAO,MAAM;CAC1B;CAEA,OAAO,OAAY,QAAsB;EACvC,IAAI,SAAS,KAAK,KAAK,MAAM,eAC3B,KAAK,SAAS,MAAM,eAAe,MAAM;EAE3C,KAAK,SAAS,OAAO,MAAM;CAC7B;CAEA,MAAc,OAAY,QAAsB;EAC9C,MAAM,MAAM,KAAKA,iBAAiB,IAAI,KAAK,qBAAK,IAAI,IAAI;EACxD,IAAI,IAAI,SAAS,GAAG,KAAKA,iBAAiB,IAAI,OAAO,GAAG;EACxD,IAAI,IAAI,MAAM;CAChB;CAEA,SAAiB,OAAY,QAAsB;EACjD,MAAM,MAAM,KAAKA,iBAAiB,IAAI,KAAK;EAC3C,IAAI,KAAK;GACP,IAAI,OAAO,MAAM;GACjB,IAAI,IAAI,SAAS,GACf,KAAKA,iBAAiB,OAAO,KAAK;EAEtC;CACF;AACF;AAEA,SAAS,cAAiB,MAAc,MAAsB;CAC5D,MAAM,CAAC,SAAS,UAAU,KAAK,QAAQ,KAAK,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,IAAI;CAC7E,MAAM,yBAAS,IAAI,IAAO;CAC1B,KAAK,MAAM,QAAQ,SACjB,IAAI,OAAO,IAAI,IAAI,GACjB,OAAO,IAAI,IAAI;CAGnB,OAAO;AACT"}
+{"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        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      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":";;;;;;AAcA,MAAM,2BAAW,IAAI,IAAY;AAGjC,MAAa,iBAAiB;;;;;;;;;AAU9B,IAAa,eAAb,MAA0B;CACxB,2BAAqE,IAAI,IAAI;;CAG7E,gBAAgB,aAA8B;EAC5C,OAAO,eAAA;CACT;;CAGA,UAAU,SAA0B;EAClC,OAAO,KAAKA,SAAS,IAAI,OAAO;CAClC;;CAGA,sBAAwC,MAAyB,UAAe,OAAqB;EACnG,MAAM,EAAE,YAAY;EACpB,IAAI,CAAC,KAAKA,SAAS,IAAI,OAAO,GAC5B,KAAKA,SAAS,IAAI,yBAAS,IAAI,IAAI,CAAC;EAGtC,MAAM,aAAa,OAAO,KAAK,KAAK;EACpC,MAAM,eAAe,KAAKA,SAAS,IAAI,OAAO;EAC9C,MAAM,oBAAoB,WAAW,QAAQ,cAAc,CAAC,aAAa,IAAI,SAAS,CAAC;EACvF,IAAI,kBAAkB,WAAW,GAAG;EAGpC,IAAI,KAAK,YAAY,KAAK,SAAS,SAAS,GAC1C,CAAC,GAAG,QAAQ,WAAW,MAAM,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,cAAc;GACpF,KAAK,mBAAmB,MAAM,UAAU,iBAAiB;EAC3D,CAAC;OAED,KAAK,mBAAmB,MAAM,UAAU,iBAAiB;CAE7D;;CAGA,sBAAsB,QAAgB,WAAmB,UAAe,UAAqB;EAE3F,IAAI,KAAKA,SAAS,SAAS,GAAG;EAE9B,MAAM,OAAO,YAAY,MAAM;EAC/B,MAAM,eAAe,KAAKA,SAAS,IAAI,KAAK,OAAO;EACnD,IAAI,CAAC,cAAc;EAEnB,MAAM,aAAa,aAAa,IAAI,SAAS,CAAC,EAAE;EAChD,IAAI,CAAC,YAAY;EAEjB,WAAW,OAAO,UAAU,MAAM;EAClC,WAAW,IAAI,UAAU,MAAM;CACjC;;;;;;;CAQA,aAA+B,MAAyB,UAAe,OAA4B;EACjG,MAAM,EAAE,YAAY;EACpB,IAAI,CAAC,KAAKA,SAAS,IAAI,OAAO,GAC5B,MAAM,IAAI,MAAM,GAAG,KAAK,KAAK,gBAAgB;EAE/C,MAAM,eAAe,KAAKA,SAAS,IAAI,OAAO;EAE9C,IAAI;EACJ,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,KAAK,GAAG;GACtD,KAAK,uBAAuB,UAAU,SAAS;GAC/C,MAAM,kBAAkB,aAAa,IAAI,SAAS,CAAC,EAAE,MAAM,IAAI,KAAK;GACpE,IAAI,CAAC,YACH,aAAa,mBAAmB;QAEhC,aAAa,kBAAkB,cAAc,YAAY,eAAe,IAAI;GAG9E,IAAI,WAAW,SAAS,GAAG;EAC7B;EACA,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,MAAM,mDAAmD;EAErE,OAAO;CACT;CAGA,mBAA2B,MAAsB,UAAoB,YAA4B;EAC/F,MAAM,EAAE,YAAY;EACpB,MAAM,UAAU,KAAKA,SAAS,IAAI,OAAO;EAEzC,KAAK,MAAM,aAAa,YAAY;GAClC,MAAM,QAAQ,KAAK,UAAU;GAC7B,IAAI,CAAC,OAAO;GACZ,IAAI,QAAQ,QAAQ,IAAI,SAAS;GACjC,IAAI,CAAC,OAAO;IACV,QAAQ;KAAE;KAAO,OAAO,IAAI,WAAW;KAAG,cAAc;IAAE;IAC1D,QAAQ,IAAI,WAAW,KAAK;GAC9B;GACA,KAAK,MAAM,UAAU,UAAU;IAC7B,MAAM,QAAQ,cAAc,QAAQ,WAAW,MAAM,KAAK;IAC1D,MAAM,MAAM,IAAI,OAAO,MAAM;GAC/B;GACA,MAAM,eAAe,SAAS;EAChC;CACF;;CAGA,uBAAiD,UAAe,WAAyB;EACvF,MAAM,QAAQ,SAAS;EACvB,IAAI,UAAU,KAAA,GAAW;EAEzB,MAAM,OAAO,YAAY,KAAK;EAC9B,MAAM,QAAQ,KAAKA,SAAS,IAAI,KAAK,OAAO,CAAC,EAAE,IAAI,SAAS;EAC5D,IAAI,UAAU,KAAA,KAAa,MAAM,iBAAiB,SAAS,QAAQ;EAEnE,KAAK,IAAI,IAAI,MAAM,cAAc,IAAI,SAAS,QAAQ,KAAK;GACzD,MAAM,SAAS,SAAS;GACxB,MAAM,QAAQ,cAAc,QAAQ,WAAW,MAAM,KAAK;GAC1D,MAAM,MAAM,IAAI,OAAO,MAAM;EAC/B;EACA,MAAM,eAAe,SAAS;CAChC;AACF;AAGA,SAAS,cAAc,QAAgB,WAAmB,OAAmB;CAC3E,MAAM,KAAK;CACX,QAAQ,MAAM,MAAd;EACE,KAAK,cACH,OAAO,OAAO;EAChB,KAAK;EACL,KAAK,aACH,OAAQ,OAAe;EACzB,KAAK;EACL,KAAK;GACH,MAAM,WAAY,OAAe;GAGjC,IAAI,kBAAkB,QAAQ,GAC5B,OAAO,SAAS;QACX,IAAI,SAAS,OAClB,OAAO,SAAS;QAEhB;EAEJ,SACE;CACJ;AACF;;;;;;;;AASA,IAAM,aAAN,MAAiB;CACf,mCAA4B,IAAI,IAA6B;;CAG7D,IAAI,OAAqC;EACvC,IAAI,SAAS,KAAK,KAAK,MAAM,eAAe;GAG1C,MAAM,UAAU,KAAKC,iBAAiB,IAAI,MAAM,aAAa;GAE7D,MAAM,gBAAgB,KAAKA,iBAAiB,IAAI,KAAK;GACrD,IAAI,WAAW,eACb,uBAAO,IAAI,IAAI,CAAC,GAAG,SAAS,GAAG,aAAa,CAAC;GAE/C,OAAO,WAAW;EACpB;EAEA,IAAI,UAAU,MAAM,QAAQ,KAAA;EAC5B,OAAO,KAAKA,iBAAiB,IAAI,KAAK;CACxC;CAEA,IAAI,OAAY,QAAsB;EAEpC,IAAI,SAAS,KAAK,KAAK,MAAM,eAC3B,KAAK,MAAM,MAAM,eAAe,MAAM;EAExC,KAAK,MAAM,OAAO,MAAM;CAC1B;CAEA,OAAO,OAAY,QAAsB;EACvC,IAAI,SAAS,KAAK,KAAK,MAAM,eAC3B,KAAK,SAAS,MAAM,eAAe,MAAM;EAE3C,KAAK,SAAS,OAAO,MAAM;CAC7B;CAEA,MAAc,OAAY,QAAsB;EAC9C,MAAM,MAAM,KAAKA,iBAAiB,IAAI,KAAK,qBAAK,IAAI,IAAI;EACxD,IAAI,IAAI,SAAS,GAAG,KAAKA,iBAAiB,IAAI,OAAO,GAAG;EACxD,IAAI,IAAI,MAAM;CAChB;CAEA,SAAiB,OAAY,QAAsB;EACjD,MAAM,MAAM,KAAKA,iBAAiB,IAAI,KAAK;EAC3C,IAAI,KAAK;GACP,IAAI,OAAO,MAAM;GACjB,IAAI,IAAI,SAAS,GACf,KAAKA,iBAAiB,OAAO,KAAK;EAEtC;CACF;AACF;AAEA,SAAS,cAAiB,MAAc,MAAsB;CAC5D,MAAM,CAAC,SAAS,UAAU,KAAK,QAAQ,KAAK,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,IAAI;CAC7E,MAAM,yBAAS,IAAI,IAAO;CAC1B,KAAK,MAAM,QAAQ,SACjB,IAAI,OAAO,IAAI,IAAI,GACjB,OAAO,IAAI,IAAI;CAGnB,OAAO;AACT"}

package/build/InstanceData.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"InstanceData.cjs","names":["emptyRowData","#new","#flags","#deleted","#originalData","#referenceHistory","hasAnyKey"],"sources":["../src/InstanceData.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"./EntityManager.ts\";\nimport { type EntityMetadata } from \"./EntityMetadata.ts\";\nimport { type RowData, emptyRowData } from \"./RowData.ts\";\nimport { hasAnyKey } from \"./utils.ts\";\n\n/** The `#orm` metadata field we track on each instance. */\nexport class InstanceData {\n  /** The entity this instance data belongs to. */\n  readonly entity: Entity;\n  /** All entities must be associated to an `EntityManager` to handle lazy loading/etc. */\n  readonly em: EntityManager;\n  /** A pointer to our entity type's metadata. */\n  readonly metadata: EntityMetadata;\n  /** A bag for our lazy-initialized relations, allocated on first relation access. */\n  relations: Record<any, any> | undefined = undefined;\n  /** The as-loaded database row, i.e. our `rowIndex`-th row within our query's `RowData` result. */\n  rowData: RowData = emptyRowData;\n  /** Our row's index within `rowData`; see {@link RowData}. */\n  rowIndex: number = 0;\n  /** The domain-value of fields, lazily converted (if needed) on read from the database columns. */\n  data: Record<string, any>;\n  /** A bag to keep the original values, allocated on first mutation (most entities are never mutated). */\n  #originalData: Record<any, any> | undefined = undefined;\n  /** Reference values that were set during this unit of work, allocated on first m2o/poly change. */\n  #referenceHistory: Record<string, any[]> | undefined = undefined;\n  /** A bag to keep the flushed-to-database values, only for AsyncReactiveField reactivity. */\n  flushedData: Record<any, any> | undefined;\n  /** Packs the new/deleted `Operation`s + isTouched into one slot; see the accessors below. */\n  #flags: number = 0;\n  /** The `a#1`, `a#2` index if we're an em.create-d entity. We never unset this, to keep ids stable across flushes. */\n  createId: string | undefined;\n  /** The zero-based order this entity was registered with its EntityManager. */\n  entityIndex: number = -1;\n\n  /** Whether our entity is new or not. */\n  get #new(): Operation | undefined {\n    const value = this.#flags & 0b11;\n    return value === 0 ? undefined : value;\n  }\n\n  set #new(op: Operation | undefined) {\n    this.#flags = (this.#flags & ~0b11) | (op ?? 0);\n  }\n\n  /**\n   * Whether our entity has been deleted or not.\n   *\n   * - `pending` means we've been marked for deletion via `em.delete` but not issued a `DELETE`\n   * - `flushed` means we've flushed a `DELETE` but `em.flush` hasn't fully completed yet, likely due to AsyncReactiveField calcs\n   * - `deleted` means we've been flushed and `em.flush` has completed\n   */\n  get #deleted(): Operation | undefined {\n    const value = (this.#flags >> 2) & 0b11;\n    return value === 0 ? undefined : value;\n  }\n\n  set #deleted(op: Operation | undefined) {\n    this.#flags = (this.#flags & ~0b1100) | ((op ?? 0) << 2);\n  }\n\n  /** Whether our entity should flush regardless of any other changes. */\n  get isTouched(): boolean {\n    return (this.#flags & 0b10000) !== 0;\n  }\n\n  set isTouched(value: boolean) {\n    this.#flags = value ? this.#flags | 0b10000 : this.#flags & ~0b10000;\n  }\n\n  /** Creates the `#orm` field. */\n  constructor(em: EntityManager, entity: Entity, metadata: EntityMetadata, isNew: boolean) {\n    this.entity = entity;\n    this.em = em;\n    this.metadata = metadata;\n    if (isNew) {\n      this.#new = Operation.Pending;\n      this.data = {};\n      this.flushedData = undefined;\n      if (em) this.markMaybePending();\n    } else {\n      this.#new = undefined;\n      this.data = {};\n      this.flushedData = undefined;\n    }\n  }\n\n  /**\n   * Returns the as-loaded value of `columnName`, i.e. `getColumn(\"rank\")`.\n   *\n   * This saves callers from knowing that `rowData`/`rowIndex` are a pair, but note it is\n   * a snapshot of the query that loaded us, and specifically:\n   *\n   * - The value is driver-level, i.e. numeric enum ids, untagged foreign keys, and temporals\n   *   as strings; use `getField` if you want the domain value, and\n   * - The value is not updated by `em.flush`, so after a flush it is the pre-flush value, and\n   * - New entities have no row, so every column is `undefined`.\n   */\n  getColumn(columnName: string): any {\n    return this.rowData.get(this.rowIndex, columnName);\n  }\n\n  /** If `em.flush` has detected a dirty RQF, reset our internal dirty state, w/o reseting our external-dirty state. */\n  resetForRqfLoop() {\n    this.flushedData = {};\n    if (this.#new === Operation.Pending) this.#new = Operation.Flushed;\n    if (this.#deleted === Operation.Pending) this.#deleted = Operation.Flushed;\n  }\n\n  resetAfterFlushed() {\n    this.#originalData = undefined;\n    this.#referenceHistory = undefined;\n    this.flushedData = undefined;\n    this.isTouched = false;\n    if (this.#new === Operation.Pending || this.#new === Operation.Flushed) {\n      this.#new = Operation.Complete;\n    }\n    if (this.#deleted === Operation.Pending || this.#deleted === Operation.Flushed) {\n      this.#deleted = Operation.Complete;\n    }\n    this.unmarkMaybePending();\n  }\n\n  /** Our public-facing `isNewEntity`. */\n  get isNewEntity(): boolean {\n    return this.#new !== undefined && this.#new !== Operation.Complete;\n  }\n\n  /** Our public-facing `isDeletedEntity`. */\n  get isDeletedEntity(): boolean {\n    return this.#deleted !== undefined;\n  }\n\n  /** The original values of mutated fields; a shared empty object until the entity is actually mutated. */\n  get originalData(): Record<any, any> {\n    return this.#originalData ?? emptyObject;\n  }\n\n  /** Our public-facing `isDirtyEntity`. */\n  get isDirtyEntity(): boolean {\n    return hasAnyKey(this.#originalData);\n  }\n\n  /** This is our internal \"is pending flush\", which is aware of RQF micro-flush loops. */\n  get pendingOperation(): \"insert\" | \"update\" | \"delete\" | \"none\" | \"created-then-deleted\" {\n    if (this.#deleted !== undefined) {\n      // Mark entities that were created and them immediately `em.delete`-d; granted this is\n      // probably rare, but we shouldn't run hooks or have the driver try and delete these.\n      // Note that we return them, instead of skipping entirely, so that fixupCreatedThenDeleted\n      // can later be called.\n      return this.#deleted === Operation.Pending && this.#new === Operation.Pending\n        ? \"created-then-deleted\"\n        : this.#deleted === Operation.Pending\n          ? \"delete\"\n          : \"none\";\n    } else if (this.#new === Operation.Pending) {\n      // Per ^, if `#new === flushed`, we fall through to check if micro-flush UPDATEs are required\n      return \"insert\";\n    } else if (this.flushedData) {\n      return hasAnyKey(this.flushedData) ? \"update\" : \"none\";\n    } else {\n      return this.isTouched || hasAnyKey(this.#originalData) ? \"update\" : \"none\";\n    }\n  }\n\n  get changedFields(): string[] {\n    return Object.keys(this.changedData);\n  }\n\n  /** The changed-fields bag (flushedData during RQF loops, else originalData) without allocating a keys array. */\n  get changedData(): Record<any, any> {\n    return this.flushedData ?? this.#originalData ?? emptyObject;\n  }\n\n  /** Called when an `em.load` tries to find the entity and it's just gone from the db. */\n  markDeletedBecauseNotFound(): void {\n    this.#deleted = Operation.Complete;\n  }\n\n  /** Called by `em.delete`, returns true if this is new information. */\n  markDeleted(): boolean {\n    if (this.#deleted === undefined) {\n      // Let any OneToManyCollection/ReactiveField/ReactiveReference.get caches know that they should recalc\n      // (i.e. their filterDeleted logic) by asserting the `deleteBook.author` field is changing.\n      for (const field of Object.values(this.metadata.allFields)) {\n        // We only do reference/collection fields and skip the primitives, b/c we assume something like\n        // `{ books: \"title\" }` doesn't need `resetIsLoaded(..., \"title\")` b/c the same hint will also\n        // be watching \"did books change\", and so get reset that way.\n        if (field.kind === \"m2o\" || field.kind === \"poly\" || field.kind === \"m2m\" || field.kind === \"m2mEnum\") {\n          getEmInternalApi(this.em).isLoadedCache.resetIsLoaded(this.entity, field.fieldName);\n        } else if (field.kind === \"primitive\" || field.kind === \"enum\" || field.kind === \"primaryKey\") {\n          // Any reactable watching these fields will also be watching reference/collection\n        } else if (field.kind === \"o2m\" || field.kind === \"o2o\") {\n          // Any reactable watching these actually gets triggered by the primary m2o/poly side changing\n        } else if (field.kind === \"lo2m\") {\n          // Doesn't support reactivity\n        } else {\n          throw new Error(`Unhandled field kind ${field}`);\n        }\n      }\n      this.#deleted = Operation.Pending;\n      this.markMaybePending();\n      return true;\n    }\n    return false;\n  }\n\n  fixupCreatedThenDeleted(): void {\n    // Ideally we could do this via `resetAfterFlushed`?\n    this.#deleted = Operation.Complete;\n    this.unmarkMaybePending();\n  }\n\n  /** Marks this entity as needing a flush even if no fields changed. */\n  markTouched(): void {\n    this.isTouched = true;\n    this.markMaybePending();\n  }\n\n  /** Marks a field as dirty with its pre-mutation value. */\n  markFieldDirty(fieldName: string, value: any): void {\n    (this.#originalData ??= {})[fieldName] = value;\n    this.markMaybePending();\n  }\n\n  /** Marks a reverted field as clean again. */\n  markFieldClean(fieldName: string): void {\n    if (this.#originalData) delete this.#originalData[fieldName];\n    this.markMaybePending();\n  }\n\n  /** Marks this entity as a possible flush candidate. */\n  markMaybePending(): void {\n    getEmInternalApi(this.em).markMaybePending(this.entity);\n  }\n\n  /** Removes this entity from the possible flush candidate set. */\n  private unmarkMaybePending(): void {\n    getEmInternalApi(this.em).unmarkMaybePending(this.entity);\n  }\n\n  /** Remembers a reference value that may need to be reverse-walked later. */\n  rememberReferenceValue(fieldName: string, value: any): void {\n    if (value === undefined) return;\n    const values = ((this.#referenceHistory ??= {})[fieldName] ??= []);\n    if (!values.includes(value)) values.push(value);\n  }\n\n  /** Returns reference values that may need to be reverse-walked later. */\n  getReferenceHistory(fieldName: string): readonly any[] {\n    return this.#referenceHistory?.[fieldName] ?? emptyArray;\n  }\n\n  get isDeletedAndFlushed(): boolean {\n    return this.#deleted === Operation.Complete;\n  }\n\n  /**\n   * Returns true if the entity is new or was new in this EM.\n   *\n   * This is primarily used for lazy-initializing relations, i.e. if:\n   *\n   * - A new `Author` is created\n   * - We `em.flush` the author to the database\n   * - Then `a1.books` is accessed for the first time\n   *\n   * We can have a high-confidence that `a1` has no books, because we just\n   * created it, so we can set the OneToManyCollection to loaded.\n   */\n  get isOrWasNew(): boolean {\n    // #new will be left as `complete`\n    return this.#new !== undefined;\n  }\n}\n\n/** An enum to track our insert/delete state progression. */\nenum Operation {\n  Pending = 1,\n  Flushed = 2,\n  Complete = 3,\n}\n\n/** A shared frozen bag for un-mutated entities; strict mode makes accidental writes throw. */\nconst emptyObject: Record<any, any> = Object.freeze({});\n\n/** A shared frozen array for fields with no remembered reference values. */\nconst emptyArray: readonly any[] = Object.freeze([]);\n"],"mappings":"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"}
+{"version":3,"file":"InstanceData.cjs","names":["emptyRowData","#new","#flags","#deleted","#originalData","#referenceHistory","hasAnyKey"],"sources":["../src/InstanceData.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { type RowData, emptyRowData } from \"src/RowData.ts\";\nimport { hasAnyKey } from \"src/utils.ts\";\n\n/** The `#orm` metadata field we track on each instance. */\nexport class InstanceData {\n  /** The entity this instance data belongs to. */\n  readonly entity: Entity;\n  /** All entities must be associated to an `EntityManager` to handle lazy loading/etc. */\n  readonly em: EntityManager;\n  /** A pointer to our entity type's metadata. */\n  readonly metadata: EntityMetadata;\n  /** A bag for our lazy-initialized relations, allocated on first relation access. */\n  relations: Record<any, any> | undefined = undefined;\n  /** The as-loaded database row, i.e. our `rowIndex`-th row within our query's `RowData` result. */\n  rowData: RowData = emptyRowData;\n  /** Our row's index within `rowData`; see {@link RowData}. */\n  rowIndex: number = 0;\n  /** The domain-value of fields, lazily converted (if needed) on read from the database columns. */\n  data: Record<string, any>;\n  /** A bag to keep the original values, allocated on first mutation (most entities are never mutated). */\n  #originalData: Record<any, any> | undefined = undefined;\n  /** Reference values that were set during this unit of work, allocated on first m2o/poly change. */\n  #referenceHistory: Record<string, any[]> | undefined = undefined;\n  /** A bag to keep the flushed-to-database values, only for AsyncReactiveField reactivity. */\n  flushedData: Record<any, any> | undefined;\n  /** Packs the new/deleted `Operation`s + isTouched into one slot; see the accessors below. */\n  #flags: number = 0;\n  /** The `a#1`, `a#2` index if we're an em.create-d entity. We never unset this, to keep ids stable across flushes. */\n  createId: string | undefined;\n  /** The zero-based order this entity was registered with its EntityManager. */\n  entityIndex: number = -1;\n\n  /** Whether our entity is new or not. */\n  get #new(): Operation | undefined {\n    const value = this.#flags & 0b11;\n    return value === 0 ? undefined : value;\n  }\n\n  set #new(op: Operation | undefined) {\n    this.#flags = (this.#flags & ~0b11) | (op ?? 0);\n  }\n\n  /**\n   * Whether our entity has been deleted or not.\n   *\n   * - `pending` means we've been marked for deletion via `em.delete` but not issued a `DELETE`\n   * - `flushed` means we've flushed a `DELETE` but `em.flush` hasn't fully completed yet, likely due to AsyncReactiveField calcs\n   * - `deleted` means we've been flushed and `em.flush` has completed\n   */\n  get #deleted(): Operation | undefined {\n    const value = (this.#flags >> 2) & 0b11;\n    return value === 0 ? undefined : value;\n  }\n\n  set #deleted(op: Operation | undefined) {\n    this.#flags = (this.#flags & ~0b1100) | ((op ?? 0) << 2);\n  }\n\n  /** Whether our entity should flush regardless of any other changes. */\n  get isTouched(): boolean {\n    return (this.#flags & 0b10000) !== 0;\n  }\n\n  set isTouched(value: boolean) {\n    this.#flags = value ? this.#flags | 0b10000 : this.#flags & ~0b10000;\n  }\n\n  /** Creates the `#orm` field. */\n  constructor(em: EntityManager, entity: Entity, metadata: EntityMetadata, isNew: boolean) {\n    this.entity = entity;\n    this.em = em;\n    this.metadata = metadata;\n    if (isNew) {\n      this.#new = Operation.Pending;\n      this.data = {};\n      this.flushedData = undefined;\n      if (em) this.markMaybePending();\n    } else {\n      this.#new = undefined;\n      this.data = {};\n      this.flushedData = undefined;\n    }\n  }\n\n  /**\n   * Returns the as-loaded value of `columnName`, i.e. `getColumn(\"rank\")`.\n   *\n   * This saves callers from knowing that `rowData`/`rowIndex` are a pair, but note it is\n   * a snapshot of the query that loaded us, and specifically:\n   *\n   * - The value is driver-level, i.e. numeric enum ids, untagged foreign keys, and temporals\n   *   as strings; use `getField` if you want the domain value, and\n   * - The value is not updated by `em.flush`, so after a flush it is the pre-flush value, and\n   * - New entities have no row, so every column is `undefined`.\n   */\n  getColumn(columnName: string): any {\n    return this.rowData.get(this.rowIndex, columnName);\n  }\n\n  /** If `em.flush` has detected a dirty RQF, reset our internal dirty state, w/o reseting our external-dirty state. */\n  resetForRqfLoop() {\n    this.flushedData = {};\n    if (this.#new === Operation.Pending) this.#new = Operation.Flushed;\n    if (this.#deleted === Operation.Pending) this.#deleted = Operation.Flushed;\n  }\n\n  resetAfterFlushed() {\n    this.#originalData = undefined;\n    this.#referenceHistory = undefined;\n    this.flushedData = undefined;\n    this.isTouched = false;\n    if (this.#new === Operation.Pending || this.#new === Operation.Flushed) {\n      this.#new = Operation.Complete;\n    }\n    if (this.#deleted === Operation.Pending || this.#deleted === Operation.Flushed) {\n      this.#deleted = Operation.Complete;\n    }\n    this.unmarkMaybePending();\n  }\n\n  /** Our public-facing `isNewEntity`. */\n  get isNewEntity(): boolean {\n    return this.#new !== undefined && this.#new !== Operation.Complete;\n  }\n\n  /** Our public-facing `isDeletedEntity`. */\n  get isDeletedEntity(): boolean {\n    return this.#deleted !== undefined;\n  }\n\n  /** The original values of mutated fields; a shared empty object until the entity is actually mutated. */\n  get originalData(): Record<any, any> {\n    return this.#originalData ?? emptyObject;\n  }\n\n  /** Our public-facing `isDirtyEntity`. */\n  get isDirtyEntity(): boolean {\n    return hasAnyKey(this.#originalData);\n  }\n\n  /** This is our internal \"is pending flush\", which is aware of RQF micro-flush loops. */\n  get pendingOperation(): \"insert\" | \"update\" | \"delete\" | \"none\" | \"created-then-deleted\" {\n    if (this.#deleted !== undefined) {\n      // Mark entities that were created and them immediately `em.delete`-d; granted this is\n      // probably rare, but we shouldn't run hooks or have the driver try and delete these.\n      // Note that we return them, instead of skipping entirely, so that fixupCreatedThenDeleted\n      // can later be called.\n      return this.#deleted === Operation.Pending && this.#new === Operation.Pending\n        ? \"created-then-deleted\"\n        : this.#deleted === Operation.Pending\n          ? \"delete\"\n          : \"none\";\n    } else if (this.#new === Operation.Pending) {\n      // Per ^, if `#new === flushed`, we fall through to check if micro-flush UPDATEs are required\n      return \"insert\";\n    } else if (this.flushedData) {\n      return hasAnyKey(this.flushedData) ? \"update\" : \"none\";\n    } else {\n      return this.isTouched || hasAnyKey(this.#originalData) ? \"update\" : \"none\";\n    }\n  }\n\n  get changedFields(): string[] {\n    return Object.keys(this.changedData);\n  }\n\n  /** The changed-fields bag (flushedData during RQF loops, else originalData) without allocating a keys array. */\n  get changedData(): Record<any, any> {\n    return this.flushedData ?? this.#originalData ?? emptyObject;\n  }\n\n  /** Called when an `em.load` tries to find the entity and it's just gone from the db. */\n  markDeletedBecauseNotFound(): void {\n    this.#deleted = Operation.Complete;\n  }\n\n  /** Called by `em.delete`, returns true if this is new information. */\n  markDeleted(): boolean {\n    if (this.#deleted === undefined) {\n      // Let any OneToManyCollection/ReactiveField/ReactiveReference.get caches know that they should recalc\n      // (i.e. their filterDeleted logic) by asserting the `deleteBook.author` field is changing.\n      for (const field of Object.values(this.metadata.allFields)) {\n        // We only do reference/collection fields and skip the primitives, b/c we assume something like\n        // `{ books: \"title\" }` doesn't need `resetIsLoaded(..., \"title\")` b/c the same hint will also\n        // be watching \"did books change\", and so get reset that way.\n        if (field.kind === \"m2o\" || field.kind === \"poly\" || field.kind === \"m2m\" || field.kind === \"m2mEnum\") {\n          getEmInternalApi(this.em).isLoadedCache.resetIsLoaded(this.entity, field.fieldName);\n        } else if (field.kind === \"primitive\" || field.kind === \"enum\" || field.kind === \"primaryKey\") {\n          // Any reactable watching these fields will also be watching reference/collection\n        } else if (field.kind === \"o2m\" || field.kind === \"o2o\") {\n          // Any reactable watching these actually gets triggered by the primary m2o/poly side changing\n        } else if (field.kind === \"lo2m\") {\n          // Doesn't support reactivity\n        } else {\n          throw new Error(`Unhandled field kind ${field}`);\n        }\n      }\n      this.#deleted = Operation.Pending;\n      this.markMaybePending();\n      return true;\n    }\n    return false;\n  }\n\n  fixupCreatedThenDeleted(): void {\n    // Ideally we could do this via `resetAfterFlushed`?\n    this.#deleted = Operation.Complete;\n    this.unmarkMaybePending();\n  }\n\n  /** Marks this entity as needing a flush even if no fields changed. */\n  markTouched(): void {\n    this.isTouched = true;\n    this.markMaybePending();\n  }\n\n  /** Marks a field as dirty with its pre-mutation value. */\n  markFieldDirty(fieldName: string, value: any): void {\n    (this.#originalData ??= {})[fieldName] = value;\n    this.markMaybePending();\n  }\n\n  /** Marks a reverted field as clean again. */\n  markFieldClean(fieldName: string): void {\n    if (this.#originalData) delete this.#originalData[fieldName];\n    this.markMaybePending();\n  }\n\n  /** Marks this entity as a possible flush candidate. */\n  markMaybePending(): void {\n    getEmInternalApi(this.em).markMaybePending(this.entity);\n  }\n\n  /** Removes this entity from the possible flush candidate set. */\n  private unmarkMaybePending(): void {\n    getEmInternalApi(this.em).unmarkMaybePending(this.entity);\n  }\n\n  /** Remembers a reference value that may need to be reverse-walked later. */\n  rememberReferenceValue(fieldName: string, value: any): void {\n    if (value === undefined) return;\n    const values = ((this.#referenceHistory ??= {})[fieldName] ??= []);\n    if (!values.includes(value)) values.push(value);\n  }\n\n  /** Returns reference values that may need to be reverse-walked later. */\n  getReferenceHistory(fieldName: string): readonly any[] {\n    return this.#referenceHistory?.[fieldName] ?? emptyArray;\n  }\n\n  get isDeletedAndFlushed(): boolean {\n    return this.#deleted === Operation.Complete;\n  }\n\n  /**\n   * Returns true if the entity is new or was new in this EM.\n   *\n   * This is primarily used for lazy-initializing relations, i.e. if:\n   *\n   * - A new `Author` is created\n   * - We `em.flush` the author to the database\n   * - Then `a1.books` is accessed for the first time\n   *\n   * We can have a high-confidence that `a1` has no books, because we just\n   * created it, so we can set the OneToManyCollection to loaded.\n   */\n  get isOrWasNew(): boolean {\n    // #new will be left as `complete`\n    return this.#new !== undefined;\n  }\n}\n\n/** An enum to track our insert/delete state progression. */\nenum Operation {\n  Pending = 1,\n  Flushed = 2,\n  Complete = 3,\n}\n\n/** A shared frozen bag for un-mutated entities; strict mode makes accidental writes throw. */\nconst emptyObject: Record<any, any> = Object.freeze({});\n\n/** A shared frozen array for fields with no remembered reference values. */\nconst emptyArray: readonly any[] = Object.freeze([]);\n"],"mappings":"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"}

package/build/InstanceData.js.map

@@ -1 +1 @@
-{"version":3,"file":"InstanceData.js","names":["#new","#flags","#deleted","#originalData","#referenceHistory"],"sources":["../src/InstanceData.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"./EntityManager.ts\";\nimport { type EntityMetadata } from \"./EntityMetadata.ts\";\nimport { type RowData, emptyRowData } from \"./RowData.ts\";\nimport { hasAnyKey } from \"./utils.ts\";\n\n/** The `#orm` metadata field we track on each instance. */\nexport class InstanceData {\n  /** The entity this instance data belongs to. */\n  readonly entity: Entity;\n  /** All entities must be associated to an `EntityManager` to handle lazy loading/etc. */\n  readonly em: EntityManager;\n  /** A pointer to our entity type's metadata. */\n  readonly metadata: EntityMetadata;\n  /** A bag for our lazy-initialized relations, allocated on first relation access. */\n  relations: Record<any, any> | undefined = undefined;\n  /** The as-loaded database row, i.e. our `rowIndex`-th row within our query's `RowData` result. */\n  rowData: RowData = emptyRowData;\n  /** Our row's index within `rowData`; see {@link RowData}. */\n  rowIndex: number = 0;\n  /** The domain-value of fields, lazily converted (if needed) on read from the database columns. */\n  data: Record<string, any>;\n  /** A bag to keep the original values, allocated on first mutation (most entities are never mutated). */\n  #originalData: Record<any, any> | undefined = undefined;\n  /** Reference values that were set during this unit of work, allocated on first m2o/poly change. */\n  #referenceHistory: Record<string, any[]> | undefined = undefined;\n  /** A bag to keep the flushed-to-database values, only for AsyncReactiveField reactivity. */\n  flushedData: Record<any, any> | undefined;\n  /** Packs the new/deleted `Operation`s + isTouched into one slot; see the accessors below. */\n  #flags: number = 0;\n  /** The `a#1`, `a#2` index if we're an em.create-d entity. We never unset this, to keep ids stable across flushes. */\n  createId: string | undefined;\n  /** The zero-based order this entity was registered with its EntityManager. */\n  entityIndex: number = -1;\n\n  /** Whether our entity is new or not. */\n  get #new(): Operation | undefined {\n    const value = this.#flags & 0b11;\n    return value === 0 ? undefined : value;\n  }\n\n  set #new(op: Operation | undefined) {\n    this.#flags = (this.#flags & ~0b11) | (op ?? 0);\n  }\n\n  /**\n   * Whether our entity has been deleted or not.\n   *\n   * - `pending` means we've been marked for deletion via `em.delete` but not issued a `DELETE`\n   * - `flushed` means we've flushed a `DELETE` but `em.flush` hasn't fully completed yet, likely due to AsyncReactiveField calcs\n   * - `deleted` means we've been flushed and `em.flush` has completed\n   */\n  get #deleted(): Operation | undefined {\n    const value = (this.#flags >> 2) & 0b11;\n    return value === 0 ? undefined : value;\n  }\n\n  set #deleted(op: Operation | undefined) {\n    this.#flags = (this.#flags & ~0b1100) | ((op ?? 0) << 2);\n  }\n\n  /** Whether our entity should flush regardless of any other changes. */\n  get isTouched(): boolean {\n    return (this.#flags & 0b10000) !== 0;\n  }\n\n  set isTouched(value: boolean) {\n    this.#flags = value ? this.#flags | 0b10000 : this.#flags & ~0b10000;\n  }\n\n  /** Creates the `#orm` field. */\n  constructor(em: EntityManager, entity: Entity, metadata: EntityMetadata, isNew: boolean) {\n    this.entity = entity;\n    this.em = em;\n    this.metadata = metadata;\n    if (isNew) {\n      this.#new = Operation.Pending;\n      this.data = {};\n      this.flushedData = undefined;\n      if (em) this.markMaybePending();\n    } else {\n      this.#new = undefined;\n      this.data = {};\n      this.flushedData = undefined;\n    }\n  }\n\n  /**\n   * Returns the as-loaded value of `columnName`, i.e. `getColumn(\"rank\")`.\n   *\n   * This saves callers from knowing that `rowData`/`rowIndex` are a pair, but note it is\n   * a snapshot of the query that loaded us, and specifically:\n   *\n   * - The value is driver-level, i.e. numeric enum ids, untagged foreign keys, and temporals\n   *   as strings; use `getField` if you want the domain value, and\n   * - The value is not updated by `em.flush`, so after a flush it is the pre-flush value, and\n   * - New entities have no row, so every column is `undefined`.\n   */\n  getColumn(columnName: string): any {\n    return this.rowData.get(this.rowIndex, columnName);\n  }\n\n  /** If `em.flush` has detected a dirty RQF, reset our internal dirty state, w/o reseting our external-dirty state. */\n  resetForRqfLoop() {\n    this.flushedData = {};\n    if (this.#new === Operation.Pending) this.#new = Operation.Flushed;\n    if (this.#deleted === Operation.Pending) this.#deleted = Operation.Flushed;\n  }\n\n  resetAfterFlushed() {\n    this.#originalData = undefined;\n    this.#referenceHistory = undefined;\n    this.flushedData = undefined;\n    this.isTouched = false;\n    if (this.#new === Operation.Pending || this.#new === Operation.Flushed) {\n      this.#new = Operation.Complete;\n    }\n    if (this.#deleted === Operation.Pending || this.#deleted === Operation.Flushed) {\n      this.#deleted = Operation.Complete;\n    }\n    this.unmarkMaybePending();\n  }\n\n  /** Our public-facing `isNewEntity`. */\n  get isNewEntity(): boolean {\n    return this.#new !== undefined && this.#new !== Operation.Complete;\n  }\n\n  /** Our public-facing `isDeletedEntity`. */\n  get isDeletedEntity(): boolean {\n    return this.#deleted !== undefined;\n  }\n\n  /** The original values of mutated fields; a shared empty object until the entity is actually mutated. */\n  get originalData(): Record<any, any> {\n    return this.#originalData ?? emptyObject;\n  }\n\n  /** Our public-facing `isDirtyEntity`. */\n  get isDirtyEntity(): boolean {\n    return hasAnyKey(this.#originalData);\n  }\n\n  /** This is our internal \"is pending flush\", which is aware of RQF micro-flush loops. */\n  get pendingOperation(): \"insert\" | \"update\" | \"delete\" | \"none\" | \"created-then-deleted\" {\n    if (this.#deleted !== undefined) {\n      // Mark entities that were created and them immediately `em.delete`-d; granted this is\n      // probably rare, but we shouldn't run hooks or have the driver try and delete these.\n      // Note that we return them, instead of skipping entirely, so that fixupCreatedThenDeleted\n      // can later be called.\n      return this.#deleted === Operation.Pending && this.#new === Operation.Pending\n        ? \"created-then-deleted\"\n        : this.#deleted === Operation.Pending\n          ? \"delete\"\n          : \"none\";\n    } else if (this.#new === Operation.Pending) {\n      // Per ^, if `#new === flushed`, we fall through to check if micro-flush UPDATEs are required\n      return \"insert\";\n    } else if (this.flushedData) {\n      return hasAnyKey(this.flushedData) ? \"update\" : \"none\";\n    } else {\n      return this.isTouched || hasAnyKey(this.#originalData) ? \"update\" : \"none\";\n    }\n  }\n\n  get changedFields(): string[] {\n    return Object.keys(this.changedData);\n  }\n\n  /** The changed-fields bag (flushedData during RQF loops, else originalData) without allocating a keys array. */\n  get changedData(): Record<any, any> {\n    return this.flushedData ?? this.#originalData ?? emptyObject;\n  }\n\n  /** Called when an `em.load` tries to find the entity and it's just gone from the db. */\n  markDeletedBecauseNotFound(): void {\n    this.#deleted = Operation.Complete;\n  }\n\n  /** Called by `em.delete`, returns true if this is new information. */\n  markDeleted(): boolean {\n    if (this.#deleted === undefined) {\n      // Let any OneToManyCollection/ReactiveField/ReactiveReference.get caches know that they should recalc\n      // (i.e. their filterDeleted logic) by asserting the `deleteBook.author` field is changing.\n      for (const field of Object.values(this.metadata.allFields)) {\n        // We only do reference/collection fields and skip the primitives, b/c we assume something like\n        // `{ books: \"title\" }` doesn't need `resetIsLoaded(..., \"title\")` b/c the same hint will also\n        // be watching \"did books change\", and so get reset that way.\n        if (field.kind === \"m2o\" || field.kind === \"poly\" || field.kind === \"m2m\" || field.kind === \"m2mEnum\") {\n          getEmInternalApi(this.em).isLoadedCache.resetIsLoaded(this.entity, field.fieldName);\n        } else if (field.kind === \"primitive\" || field.kind === \"enum\" || field.kind === \"primaryKey\") {\n          // Any reactable watching these fields will also be watching reference/collection\n        } else if (field.kind === \"o2m\" || field.kind === \"o2o\") {\n          // Any reactable watching these actually gets triggered by the primary m2o/poly side changing\n        } else if (field.kind === \"lo2m\") {\n          // Doesn't support reactivity\n        } else {\n          throw new Error(`Unhandled field kind ${field}`);\n        }\n      }\n      this.#deleted = Operation.Pending;\n      this.markMaybePending();\n      return true;\n    }\n    return false;\n  }\n\n  fixupCreatedThenDeleted(): void {\n    // Ideally we could do this via `resetAfterFlushed`?\n    this.#deleted = Operation.Complete;\n    this.unmarkMaybePending();\n  }\n\n  /** Marks this entity as needing a flush even if no fields changed. */\n  markTouched(): void {\n    this.isTouched = true;\n    this.markMaybePending();\n  }\n\n  /** Marks a field as dirty with its pre-mutation value. */\n  markFieldDirty(fieldName: string, value: any): void {\n    (this.#originalData ??= {})[fieldName] = value;\n    this.markMaybePending();\n  }\n\n  /** Marks a reverted field as clean again. */\n  markFieldClean(fieldName: string): void {\n    if (this.#originalData) delete this.#originalData[fieldName];\n    this.markMaybePending();\n  }\n\n  /** Marks this entity as a possible flush candidate. */\n  markMaybePending(): void {\n    getEmInternalApi(this.em).markMaybePending(this.entity);\n  }\n\n  /** Removes this entity from the possible flush candidate set. */\n  private unmarkMaybePending(): void {\n    getEmInternalApi(this.em).unmarkMaybePending(this.entity);\n  }\n\n  /** Remembers a reference value that may need to be reverse-walked later. */\n  rememberReferenceValue(fieldName: string, value: any): void {\n    if (value === undefined) return;\n    const values = ((this.#referenceHistory ??= {})[fieldName] ??= []);\n    if (!values.includes(value)) values.push(value);\n  }\n\n  /** Returns reference values that may need to be reverse-walked later. */\n  getReferenceHistory(fieldName: string): readonly any[] {\n    return this.#referenceHistory?.[fieldName] ?? emptyArray;\n  }\n\n  get isDeletedAndFlushed(): boolean {\n    return this.#deleted === Operation.Complete;\n  }\n\n  /**\n   * Returns true if the entity is new or was new in this EM.\n   *\n   * This is primarily used for lazy-initializing relations, i.e. if:\n   *\n   * - A new `Author` is created\n   * - We `em.flush` the author to the database\n   * - Then `a1.books` is accessed for the first time\n   *\n   * We can have a high-confidence that `a1` has no books, because we just\n   * created it, so we can set the OneToManyCollection to loaded.\n   */\n  get isOrWasNew(): boolean {\n    // #new will be left as `complete`\n    return this.#new !== undefined;\n  }\n}\n\n/** An enum to track our insert/delete state progression. */\nenum Operation {\n  Pending = 1,\n  Flushed = 2,\n  Complete = 3,\n}\n\n/** A shared frozen bag for un-mutated entities; strict mode makes accidental writes throw. */\nconst emptyObject: Record<any, any> = Object.freeze({});\n\n/** A shared frozen array for fields with no remembered reference values. */\nconst emptyArray: readonly any[] = Object.freeze([]);\n"],"mappings":"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"}
+{"version":3,"file":"InstanceData.js","names":["#new","#flags","#deleted","#originalData","#referenceHistory"],"sources":["../src/InstanceData.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { type RowData, emptyRowData } from \"src/RowData.ts\";\nimport { hasAnyKey } from \"src/utils.ts\";\n\n/** The `#orm` metadata field we track on each instance. */\nexport class InstanceData {\n  /** The entity this instance data belongs to. */\n  readonly entity: Entity;\n  /** All entities must be associated to an `EntityManager` to handle lazy loading/etc. */\n  readonly em: EntityManager;\n  /** A pointer to our entity type's metadata. */\n  readonly metadata: EntityMetadata;\n  /** A bag for our lazy-initialized relations, allocated on first relation access. */\n  relations: Record<any, any> | undefined = undefined;\n  /** The as-loaded database row, i.e. our `rowIndex`-th row within our query's `RowData` result. */\n  rowData: RowData = emptyRowData;\n  /** Our row's index within `rowData`; see {@link RowData}. */\n  rowIndex: number = 0;\n  /** The domain-value of fields, lazily converted (if needed) on read from the database columns. */\n  data: Record<string, any>;\n  /** A bag to keep the original values, allocated on first mutation (most entities are never mutated). */\n  #originalData: Record<any, any> | undefined = undefined;\n  /** Reference values that were set during this unit of work, allocated on first m2o/poly change. */\n  #referenceHistory: Record<string, any[]> | undefined = undefined;\n  /** A bag to keep the flushed-to-database values, only for AsyncReactiveField reactivity. */\n  flushedData: Record<any, any> | undefined;\n  /** Packs the new/deleted `Operation`s + isTouched into one slot; see the accessors below. */\n  #flags: number = 0;\n  /** The `a#1`, `a#2` index if we're an em.create-d entity. We never unset this, to keep ids stable across flushes. */\n  createId: string | undefined;\n  /** The zero-based order this entity was registered with its EntityManager. */\n  entityIndex: number = -1;\n\n  /** Whether our entity is new or not. */\n  get #new(): Operation | undefined {\n    const value = this.#flags & 0b11;\n    return value === 0 ? undefined : value;\n  }\n\n  set #new(op: Operation | undefined) {\n    this.#flags = (this.#flags & ~0b11) | (op ?? 0);\n  }\n\n  /**\n   * Whether our entity has been deleted or not.\n   *\n   * - `pending` means we've been marked for deletion via `em.delete` but not issued a `DELETE`\n   * - `flushed` means we've flushed a `DELETE` but `em.flush` hasn't fully completed yet, likely due to AsyncReactiveField calcs\n   * - `deleted` means we've been flushed and `em.flush` has completed\n   */\n  get #deleted(): Operation | undefined {\n    const value = (this.#flags >> 2) & 0b11;\n    return value === 0 ? undefined : value;\n  }\n\n  set #deleted(op: Operation | undefined) {\n    this.#flags = (this.#flags & ~0b1100) | ((op ?? 0) << 2);\n  }\n\n  /** Whether our entity should flush regardless of any other changes. */\n  get isTouched(): boolean {\n    return (this.#flags & 0b10000) !== 0;\n  }\n\n  set isTouched(value: boolean) {\n    this.#flags = value ? this.#flags | 0b10000 : this.#flags & ~0b10000;\n  }\n\n  /** Creates the `#orm` field. */\n  constructor(em: EntityManager, entity: Entity, metadata: EntityMetadata, isNew: boolean) {\n    this.entity = entity;\n    this.em = em;\n    this.metadata = metadata;\n    if (isNew) {\n      this.#new = Operation.Pending;\n      this.data = {};\n      this.flushedData = undefined;\n      if (em) this.markMaybePending();\n    } else {\n      this.#new = undefined;\n      this.data = {};\n      this.flushedData = undefined;\n    }\n  }\n\n  /**\n   * Returns the as-loaded value of `columnName`, i.e. `getColumn(\"rank\")`.\n   *\n   * This saves callers from knowing that `rowData`/`rowIndex` are a pair, but note it is\n   * a snapshot of the query that loaded us, and specifically:\n   *\n   * - The value is driver-level, i.e. numeric enum ids, untagged foreign keys, and temporals\n   *   as strings; use `getField` if you want the domain value, and\n   * - The value is not updated by `em.flush`, so after a flush it is the pre-flush value, and\n   * - New entities have no row, so every column is `undefined`.\n   */\n  getColumn(columnName: string): any {\n    return this.rowData.get(this.rowIndex, columnName);\n  }\n\n  /** If `em.flush` has detected a dirty RQF, reset our internal dirty state, w/o reseting our external-dirty state. */\n  resetForRqfLoop() {\n    this.flushedData = {};\n    if (this.#new === Operation.Pending) this.#new = Operation.Flushed;\n    if (this.#deleted === Operation.Pending) this.#deleted = Operation.Flushed;\n  }\n\n  resetAfterFlushed() {\n    this.#originalData = undefined;\n    this.#referenceHistory = undefined;\n    this.flushedData = undefined;\n    this.isTouched = false;\n    if (this.#new === Operation.Pending || this.#new === Operation.Flushed) {\n      this.#new = Operation.Complete;\n    }\n    if (this.#deleted === Operation.Pending || this.#deleted === Operation.Flushed) {\n      this.#deleted = Operation.Complete;\n    }\n    this.unmarkMaybePending();\n  }\n\n  /** Our public-facing `isNewEntity`. */\n  get isNewEntity(): boolean {\n    return this.#new !== undefined && this.#new !== Operation.Complete;\n  }\n\n  /** Our public-facing `isDeletedEntity`. */\n  get isDeletedEntity(): boolean {\n    return this.#deleted !== undefined;\n  }\n\n  /** The original values of mutated fields; a shared empty object until the entity is actually mutated. */\n  get originalData(): Record<any, any> {\n    return this.#originalData ?? emptyObject;\n  }\n\n  /** Our public-facing `isDirtyEntity`. */\n  get isDirtyEntity(): boolean {\n    return hasAnyKey(this.#originalData);\n  }\n\n  /** This is our internal \"is pending flush\", which is aware of RQF micro-flush loops. */\n  get pendingOperation(): \"insert\" | \"update\" | \"delete\" | \"none\" | \"created-then-deleted\" {\n    if (this.#deleted !== undefined) {\n      // Mark entities that were created and them immediately `em.delete`-d; granted this is\n      // probably rare, but we shouldn't run hooks or have the driver try and delete these.\n      // Note that we return them, instead of skipping entirely, so that fixupCreatedThenDeleted\n      // can later be called.\n      return this.#deleted === Operation.Pending && this.#new === Operation.Pending\n        ? \"created-then-deleted\"\n        : this.#deleted === Operation.Pending\n          ? \"delete\"\n          : \"none\";\n    } else if (this.#new === Operation.Pending) {\n      // Per ^, if `#new === flushed`, we fall through to check if micro-flush UPDATEs are required\n      return \"insert\";\n    } else if (this.flushedData) {\n      return hasAnyKey(this.flushedData) ? \"update\" : \"none\";\n    } else {\n      return this.isTouched || hasAnyKey(this.#originalData) ? \"update\" : \"none\";\n    }\n  }\n\n  get changedFields(): string[] {\n    return Object.keys(this.changedData);\n  }\n\n  /** The changed-fields bag (flushedData during RQF loops, else originalData) without allocating a keys array. */\n  get changedData(): Record<any, any> {\n    return this.flushedData ?? this.#originalData ?? emptyObject;\n  }\n\n  /** Called when an `em.load` tries to find the entity and it's just gone from the db. */\n  markDeletedBecauseNotFound(): void {\n    this.#deleted = Operation.Complete;\n  }\n\n  /** Called by `em.delete`, returns true if this is new information. */\n  markDeleted(): boolean {\n    if (this.#deleted === undefined) {\n      // Let any OneToManyCollection/ReactiveField/ReactiveReference.get caches know that they should recalc\n      // (i.e. their filterDeleted logic) by asserting the `deleteBook.author` field is changing.\n      for (const field of Object.values(this.metadata.allFields)) {\n        // We only do reference/collection fields and skip the primitives, b/c we assume something like\n        // `{ books: \"title\" }` doesn't need `resetIsLoaded(..., \"title\")` b/c the same hint will also\n        // be watching \"did books change\", and so get reset that way.\n        if (field.kind === \"m2o\" || field.kind === \"poly\" || field.kind === \"m2m\" || field.kind === \"m2mEnum\") {\n          getEmInternalApi(this.em).isLoadedCache.resetIsLoaded(this.entity, field.fieldName);\n        } else if (field.kind === \"primitive\" || field.kind === \"enum\" || field.kind === \"primaryKey\") {\n          // Any reactable watching these fields will also be watching reference/collection\n        } else if (field.kind === \"o2m\" || field.kind === \"o2o\") {\n          // Any reactable watching these actually gets triggered by the primary m2o/poly side changing\n        } else if (field.kind === \"lo2m\") {\n          // Doesn't support reactivity\n        } else {\n          throw new Error(`Unhandled field kind ${field}`);\n        }\n      }\n      this.#deleted = Operation.Pending;\n      this.markMaybePending();\n      return true;\n    }\n    return false;\n  }\n\n  fixupCreatedThenDeleted(): void {\n    // Ideally we could do this via `resetAfterFlushed`?\n    this.#deleted = Operation.Complete;\n    this.unmarkMaybePending();\n  }\n\n  /** Marks this entity as needing a flush even if no fields changed. */\n  markTouched(): void {\n    this.isTouched = true;\n    this.markMaybePending();\n  }\n\n  /** Marks a field as dirty with its pre-mutation value. */\n  markFieldDirty(fieldName: string, value: any): void {\n    (this.#originalData ??= {})[fieldName] = value;\n    this.markMaybePending();\n  }\n\n  /** Marks a reverted field as clean again. */\n  markFieldClean(fieldName: string): void {\n    if (this.#originalData) delete this.#originalData[fieldName];\n    this.markMaybePending();\n  }\n\n  /** Marks this entity as a possible flush candidate. */\n  markMaybePending(): void {\n    getEmInternalApi(this.em).markMaybePending(this.entity);\n  }\n\n  /** Removes this entity from the possible flush candidate set. */\n  private unmarkMaybePending(): void {\n    getEmInternalApi(this.em).unmarkMaybePending(this.entity);\n  }\n\n  /** Remembers a reference value that may need to be reverse-walked later. */\n  rememberReferenceValue(fieldName: string, value: any): void {\n    if (value === undefined) return;\n    const values = ((this.#referenceHistory ??= {})[fieldName] ??= []);\n    if (!values.includes(value)) values.push(value);\n  }\n\n  /** Returns reference values that may need to be reverse-walked later. */\n  getReferenceHistory(fieldName: string): readonly any[] {\n    return this.#referenceHistory?.[fieldName] ?? emptyArray;\n  }\n\n  get isDeletedAndFlushed(): boolean {\n    return this.#deleted === Operation.Complete;\n  }\n\n  /**\n   * Returns true if the entity is new or was new in this EM.\n   *\n   * This is primarily used for lazy-initializing relations, i.e. if:\n   *\n   * - A new `Author` is created\n   * - We `em.flush` the author to the database\n   * - Then `a1.books` is accessed for the first time\n   *\n   * We can have a high-confidence that `a1` has no books, because we just\n   * created it, so we can set the OneToManyCollection to loaded.\n   */\n  get isOrWasNew(): boolean {\n    // #new will be left as `complete`\n    return this.#new !== undefined;\n  }\n}\n\n/** An enum to track our insert/delete state progression. */\nenum Operation {\n  Pending = 1,\n  Flushed = 2,\n  Complete = 3,\n}\n\n/** A shared frozen bag for un-mutated entities; strict mode makes accidental writes throw. */\nconst emptyObject: Record<any, any> = Object.freeze({});\n\n/** A shared frozen array for fields with no remembered reference values. */\nconst emptyArray: readonly any[] = Object.freeze([]);\n"],"mappings":"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"}

package/build/PluginManager.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"PluginManager.cjs","names":["isDefined","#pluginsByCallback","#plugins"],"sources":["../src/PluginManager.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type EntityManager, type FindOperation, isDefined } from \"./EntityManager.ts\";\nimport { type EntityMetadata } from \"./EntityMetadata.ts\";\nimport type { JoinRowTodo, Todo } from \"./flush/Todo.ts\";\nimport type { ParsedFindQuery } from \"./queries/find/QueryParser.ts\";\nimport { type RowData } from \"./RowData.ts\";\n\ninterface PluginMethods {\n  /**\n   * Called before a field value is retrieved from an entity via getField.\n   *\n   * @param entity The entity instance being accessed\n   * @param field The field name being retrieved\n   */\n  beforeGetField?(entity: Entity, field: string): void;\n  /**\n   * Called before a field value is set on an entity via setField.\n   *\n   * @param entity The entity instance being modified\n   * @param field The field name being set\n   * @param newValue The new value being assigned to the field\n   */\n  beforeSetField?(entity: Entity, field: string, newValue: any): void;\n  /**\n   * Called before a find operation is executed.\n   *\n   * @param meta Metadata for the entity type being queried\n   * @param operation The type of find operation being performed\n   * @param query The parsed query conditions\n   * @param settings Query settings including limit and offset\n   */\n  beforeFind?(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void;\n  /**\n   * Called after a find operation has been executed to observe the raw database rows.\n   *\n   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,\n   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.\n   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;\n   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is\n   * unsupported and is not guaranteed to affect entity hydration.\n   *\n   * @param meta Metadata for the entity type that was queried\n   * @param operation The type of find operation that was performed\n   * @param rows A read-only view of the raw database rows returned from the query\n   */\n  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;\n\n  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;\n}\n\nconst syncPluginMethods = [\n  \"beforeGetField\",\n  \"beforeSetField\",\n  \"beforeFind\",\n  \"afterFind\",\n  \"afterWrite\",\n] as const satisfies readonly (keyof PluginMethods)[];\nconst asyncPluginMethods = [\"beforeValidate\", \"afterValidate\"] as const satisfies readonly (keyof PluginMethods)[];\nconst emsSymbol = Symbol(\"ems\");\n/**\n * Base class for plugins that hook into entity lifecycle events.\n *\n * Plugins can implement any of the PluginMethods to intercept entity operations\n * and are automatically registered with the EntityManager when added via PluginManager.\n */\nexport abstract class Plugin {\n  // We need to store the EntityManager references in a WeakRef array so that they can be garbage collected.  If we\n  // didn't do this, then multiple EMs with the same plugin instance could keep each other from being garbage collected.\n  [emsSymbol]: WeakRef<EntityManager>[] = [];\n\n  maybeCloneForNewEm(): this | undefined {\n    return undefined;\n  }\n\n  get ems(): readonly EntityManager[] {\n    return this[emsSymbol]\n      .values()\n      .map((wr) => wr.deref())\n      .filter(isDefined)\n      .toArray();\n  }\n}\n\nexport interface Plugin extends PluginMethods {}\n\n/**\n * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.\n *\n * The PluginManager optimizes callback dispatch by only creating dispatcher methods\n * for callbacks that have at least one registered plugin, making unused plugin hooks\n * zero-cost at runtime.\n */\nexport class PluginManager implements Required<PluginMethods> {\n  #plugins = new Set<Plugin>();\n  readonly #pluginsByCallback: Partial<Record<keyof Plugin, Plugin[]>> = {};\n  constructor(public readonly em: EntityManager) {}\n\n  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */\n  hasHook(method: keyof PluginMethods): boolean {\n    return this.#pluginsByCallback[method] !== undefined;\n  }\n\n  /**\n   * Registers a plugin with this EntityManager.\n   *\n   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,\n   * enabling lazy initialization of only the hooks that are actually used.\n   *\n   * @throws Error if the plugin is already registered with another EntityManager\n   */\n  addPlugin(plugin: Plugin) {\n    if (this.#plugins.has(plugin)) return; // if we're already added, then we can just early exit\n    this.#plugins.add(plugin);\n    plugin[emsSymbol].push(new WeakRef(this.em));\n    for (const method of syncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // As a performance optimization, we only create the actual implementation for each method on the plugin manager\n        // once we have at least one plugin using that method. This is to make it so any unused plugin methods are\n        // effectively no-ops when called from within the em.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              (plugin[method] as (...args: any[]) => unknown)(...args);\n            }\n          };\n        }\n      }\n    }\n    for (const method of asyncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // Validate-phase plugin hooks are intentionally awaited without making hot-path hooks async.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = async function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              await (plugin[method] as (...args: any[]) => Promise<void> | void)(...args);\n            }\n          };\n        }\n      }\n    }\n  }\n\n  get plugins(): readonly Plugin[] {\n    return [...this.#plugins];\n  }\n\n  cloneTo(other: PluginManager) {\n    this.#plugins\n      .values()\n      .map((plugin) => plugin.maybeCloneForNewEm())\n      .filter(isDefined)\n      .forEach((plugin) => other.addPlugin(plugin));\n  }\n\n  // Defined as no-op functions initially instead of using optional chaining for performance reasons, see:\n  // https://adventures.nodeland.dev/archive/noop-functions-vs-optional-chaining-a-performance/\n\n  beforeGetField(entity: Entity, field: string): void {}\n  beforeSetField(entity: Entity, field: string, newValue: any): void {}\n  beforeFind(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void {}\n  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData) {}\n  beforeValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void {}\n}\n"],"mappings":";;;;;AAkEA,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;AACF;AACA,MAAM,qBAAqB,CAAC,kBAAkB,eAAe;AAC7D,MAAM,YAAY,OAAO,KAAK;;;;;;;AAO9B,IAAsB,SAAtB,MAA6B;CAG3B,CAAC,aAAuC,CAAC;CAEzC,qBAAuC,CAEvC;CAEA,IAAI,MAAgC;EAClC,OAAO,KAAK,UAAU,CACnB,OAAO,CAAC,CACR,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CACvB,OAAOA,sBAAAA,SAAS,CAAC,CACjB,QAAQ;CACb;AACF;;;;;;;;AAWA,IAAa,gBAAb,MAA8D;CAGhC;CAF5B,2BAAW,IAAI,IAAY;CAC3B,qBAAuE,CAAC;CACxE,YAAY,IAAmC;EAAnB,KAAA,KAAA;CAAoB;;CAGhD,QAAQ,QAAsC;EAC5C,OAAO,KAAKC,mBAAmB,YAAY,KAAA;CAC7C;;;;;;;;;CAUA,UAAU,QAAgB;EACxB,IAAI,KAAKC,SAAS,IAAI,MAAM,GAAG;EAC/B,KAAKA,SAAS,IAAI,MAAM;EACxB,OAAO,UAAU,CAAC,KAAK,IAAI,QAAQ,KAAK,EAAE,CAAC;EAC3C,KAAK,MAAM,UAAU,mBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKD,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAIpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,SAA+B,GAAG,MAAa;IAC5D,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,OAAQ,OAAO,CAAiC,GAAG,IAAI;GAE3D;EAEJ;EAEF,KAAK,MAAM,UAAU,oBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKA,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAEpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,eAAqC,GAAG,MAAa;IAClE,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,MAAO,OAAO,OAAO,CAA8C,GAAG,IAAI;GAE9E;EAEJ;CAEJ;CAEA,IAAI,UAA6B;EAC/B,OAAO,CAAC,GAAG,KAAKC,QAAQ;CAC1B;CAEA,QAAQ,OAAsB;EAC5B,KAAKA,SACF,OAAO,CAAC,CACR,KAAK,WAAW,OAAO,mBAAmB,CAAC,CAAC,CAC5C,OAAOF,sBAAAA,SAAS,CAAC,CACjB,SAAS,WAAW,MAAM,UAAU,MAAM,CAAC;CAChD;CAKA,eAAe,QAAgB,OAAqB,CAAC;CACrD,eAAe,QAAgB,OAAe,UAAqB,CAAC;CACpE,WACE,MACA,WACA,OACA,UAQM,CAAC;CACT,UAAU,MAAsB,WAA0B,MAAe,CAAC;CAC1E,eAAe,UAAmD,CAAC;CACnE,cAAc,UAAmD,CAAC;CAClE,WAAW,aAAmC,cAAiD,CAAC;AAClG"}
+{"version":3,"file":"PluginManager.cjs","names":["isDefined","#pluginsByCallback","#plugins"],"sources":["../src/PluginManager.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, type FindOperation, isDefined } from \"src/EntityManager.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport type { JoinRowTodo, Todo } from \"src/flush/Todo.ts\";\nimport type { ParsedFindQuery } from \"src/queries/find/QueryParser.ts\";\nimport { type RowData } from \"src/RowData.ts\";\n\ninterface PluginMethods {\n  /**\n   * Called before a field value is retrieved from an entity via getField.\n   *\n   * @param entity The entity instance being accessed\n   * @param field The field name being retrieved\n   */\n  beforeGetField?(entity: Entity, field: string): void;\n  /**\n   * Called before a field value is set on an entity via setField.\n   *\n   * @param entity The entity instance being modified\n   * @param field The field name being set\n   * @param newValue The new value being assigned to the field\n   */\n  beforeSetField?(entity: Entity, field: string, newValue: any): void;\n  /**\n   * Called before a find operation is executed.\n   *\n   * @param meta Metadata for the entity type being queried\n   * @param operation The type of find operation being performed\n   * @param query The parsed query conditions\n   * @param settings Query settings including limit and offset\n   */\n  beforeFind?(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void;\n  /**\n   * Called after a find operation has been executed to observe the raw database rows.\n   *\n   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,\n   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.\n   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;\n   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is\n   * unsupported and is not guaranteed to affect entity hydration.\n   *\n   * @param meta Metadata for the entity type that was queried\n   * @param operation The type of find operation that was performed\n   * @param rows A read-only view of the raw database rows returned from the query\n   */\n  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;\n\n  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;\n}\n\nconst syncPluginMethods = [\n  \"beforeGetField\",\n  \"beforeSetField\",\n  \"beforeFind\",\n  \"afterFind\",\n  \"afterWrite\",\n] as const satisfies readonly (keyof PluginMethods)[];\nconst asyncPluginMethods = [\"beforeValidate\", \"afterValidate\"] as const satisfies readonly (keyof PluginMethods)[];\nconst emsSymbol = Symbol(\"ems\");\n/**\n * Base class for plugins that hook into entity lifecycle events.\n *\n * Plugins can implement any of the PluginMethods to intercept entity operations\n * and are automatically registered with the EntityManager when added via PluginManager.\n */\nexport abstract class Plugin {\n  // We need to store the EntityManager references in a WeakRef array so that they can be garbage collected.  If we\n  // didn't do this, then multiple EMs with the same plugin instance could keep each other from being garbage collected.\n  [emsSymbol]: WeakRef<EntityManager>[] = [];\n\n  maybeCloneForNewEm(): this | undefined {\n    return undefined;\n  }\n\n  get ems(): readonly EntityManager[] {\n    return this[emsSymbol]\n      .values()\n      .map((wr) => wr.deref())\n      .filter(isDefined)\n      .toArray();\n  }\n}\n\nexport interface Plugin extends PluginMethods {}\n\n/**\n * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.\n *\n * The PluginManager optimizes callback dispatch by only creating dispatcher methods\n * for callbacks that have at least one registered plugin, making unused plugin hooks\n * zero-cost at runtime.\n */\nexport class PluginManager implements Required<PluginMethods> {\n  #plugins = new Set<Plugin>();\n  readonly #pluginsByCallback: Partial<Record<keyof Plugin, Plugin[]>> = {};\n  constructor(public readonly em: EntityManager) {}\n\n  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */\n  hasHook(method: keyof PluginMethods): boolean {\n    return this.#pluginsByCallback[method] !== undefined;\n  }\n\n  /**\n   * Registers a plugin with this EntityManager.\n   *\n   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,\n   * enabling lazy initialization of only the hooks that are actually used.\n   *\n   * @throws Error if the plugin is already registered with another EntityManager\n   */\n  addPlugin(plugin: Plugin) {\n    if (this.#plugins.has(plugin)) return; // if we're already added, then we can just early exit\n    this.#plugins.add(plugin);\n    plugin[emsSymbol].push(new WeakRef(this.em));\n    for (const method of syncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // As a performance optimization, we only create the actual implementation for each method on the plugin manager\n        // once we have at least one plugin using that method. This is to make it so any unused plugin methods are\n        // effectively no-ops when called from within the em.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              (plugin[method] as (...args: any[]) => unknown)(...args);\n            }\n          };\n        }\n      }\n    }\n    for (const method of asyncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // Validate-phase plugin hooks are intentionally awaited without making hot-path hooks async.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = async function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              await (plugin[method] as (...args: any[]) => Promise<void> | void)(...args);\n            }\n          };\n        }\n      }\n    }\n  }\n\n  get plugins(): readonly Plugin[] {\n    return [...this.#plugins];\n  }\n\n  cloneTo(other: PluginManager) {\n    this.#plugins\n      .values()\n      .map((plugin) => plugin.maybeCloneForNewEm())\n      .filter(isDefined)\n      .forEach((plugin) => other.addPlugin(plugin));\n  }\n\n  // Defined as no-op functions initially instead of using optional chaining for performance reasons, see:\n  // https://adventures.nodeland.dev/archive/noop-functions-vs-optional-chaining-a-performance/\n\n  beforeGetField(entity: Entity, field: string): void {}\n  beforeSetField(entity: Entity, field: string, newValue: any): void {}\n  beforeFind(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void {}\n  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData) {}\n  beforeValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void {}\n}\n"],"mappings":";;;;;AAkEA,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;AACF;AACA,MAAM,qBAAqB,CAAC,kBAAkB,eAAe;AAC7D,MAAM,YAAY,OAAO,KAAK;;;;;;;AAO9B,IAAsB,SAAtB,MAA6B;CAG3B,CAAC,aAAuC,CAAC;CAEzC,qBAAuC,CAEvC;CAEA,IAAI,MAAgC;EAClC,OAAO,KAAK,UAAU,CACnB,OAAO,CAAC,CACR,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CACvB,OAAOA,sBAAAA,SAAS,CAAC,CACjB,QAAQ;CACb;AACF;;;;;;;;AAWA,IAAa,gBAAb,MAA8D;CAGhC;CAF5B,2BAAW,IAAI,IAAY;CAC3B,qBAAuE,CAAC;CACxE,YAAY,IAAmC;EAAnB,KAAA,KAAA;CAAoB;;CAGhD,QAAQ,QAAsC;EAC5C,OAAO,KAAKC,mBAAmB,YAAY,KAAA;CAC7C;;;;;;;;;CAUA,UAAU,QAAgB;EACxB,IAAI,KAAKC,SAAS,IAAI,MAAM,GAAG;EAC/B,KAAKA,SAAS,IAAI,MAAM;EACxB,OAAO,UAAU,CAAC,KAAK,IAAI,QAAQ,KAAK,EAAE,CAAC;EAC3C,KAAK,MAAM,UAAU,mBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKD,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAIpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,SAA+B,GAAG,MAAa;IAC5D,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,OAAQ,OAAO,CAAiC,GAAG,IAAI;GAE3D;EAEJ;EAEF,KAAK,MAAM,UAAU,oBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKA,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAEpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,eAAqC,GAAG,MAAa;IAClE,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,MAAO,OAAO,OAAO,CAA8C,GAAG,IAAI;GAE9E;EAEJ;CAEJ;CAEA,IAAI,UAA6B;EAC/B,OAAO,CAAC,GAAG,KAAKC,QAAQ;CAC1B;CAEA,QAAQ,OAAsB;EAC5B,KAAKA,SACF,OAAO,CAAC,CACR,KAAK,WAAW,OAAO,mBAAmB,CAAC,CAAC,CAC5C,OAAOF,sBAAAA,SAAS,CAAC,CACjB,SAAS,WAAW,MAAM,UAAU,MAAM,CAAC;CAChD;CAKA,eAAe,QAAgB,OAAqB,CAAC;CACrD,eAAe,QAAgB,OAAe,UAAqB,CAAC;CACpE,WACE,MACA,WACA,OACA,UAQM,CAAC;CACT,UAAU,MAAsB,WAA0B,MAAe,CAAC;CAC1E,eAAe,UAAmD,CAAC;CACnE,cAAc,UAAmD,CAAC;CAClE,WAAW,aAAmC,cAAiD,CAAC;AAClG"}

package/build/PluginManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"PluginManager.js","names":["#pluginsByCallback","#plugins"],"sources":["../src/PluginManager.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type EntityManager, type FindOperation, isDefined } from \"./EntityManager.ts\";\nimport { type EntityMetadata } from \"./EntityMetadata.ts\";\nimport type { JoinRowTodo, Todo } from \"./flush/Todo.ts\";\nimport type { ParsedFindQuery } from \"./queries/find/QueryParser.ts\";\nimport { type RowData } from \"./RowData.ts\";\n\ninterface PluginMethods {\n  /**\n   * Called before a field value is retrieved from an entity via getField.\n   *\n   * @param entity The entity instance being accessed\n   * @param field The field name being retrieved\n   */\n  beforeGetField?(entity: Entity, field: string): void;\n  /**\n   * Called before a field value is set on an entity via setField.\n   *\n   * @param entity The entity instance being modified\n   * @param field The field name being set\n   * @param newValue The new value being assigned to the field\n   */\n  beforeSetField?(entity: Entity, field: string, newValue: any): void;\n  /**\n   * Called before a find operation is executed.\n   *\n   * @param meta Metadata for the entity type being queried\n   * @param operation The type of find operation being performed\n   * @param query The parsed query conditions\n   * @param settings Query settings including limit and offset\n   */\n  beforeFind?(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void;\n  /**\n   * Called after a find operation has been executed to observe the raw database rows.\n   *\n   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,\n   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.\n   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;\n   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is\n   * unsupported and is not guaranteed to affect entity hydration.\n   *\n   * @param meta Metadata for the entity type that was queried\n   * @param operation The type of find operation that was performed\n   * @param rows A read-only view of the raw database rows returned from the query\n   */\n  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;\n\n  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;\n}\n\nconst syncPluginMethods = [\n  \"beforeGetField\",\n  \"beforeSetField\",\n  \"beforeFind\",\n  \"afterFind\",\n  \"afterWrite\",\n] as const satisfies readonly (keyof PluginMethods)[];\nconst asyncPluginMethods = [\"beforeValidate\", \"afterValidate\"] as const satisfies readonly (keyof PluginMethods)[];\nconst emsSymbol = Symbol(\"ems\");\n/**\n * Base class for plugins that hook into entity lifecycle events.\n *\n * Plugins can implement any of the PluginMethods to intercept entity operations\n * and are automatically registered with the EntityManager when added via PluginManager.\n */\nexport abstract class Plugin {\n  // We need to store the EntityManager references in a WeakRef array so that they can be garbage collected.  If we\n  // didn't do this, then multiple EMs with the same plugin instance could keep each other from being garbage collected.\n  [emsSymbol]: WeakRef<EntityManager>[] = [];\n\n  maybeCloneForNewEm(): this | undefined {\n    return undefined;\n  }\n\n  get ems(): readonly EntityManager[] {\n    return this[emsSymbol]\n      .values()\n      .map((wr) => wr.deref())\n      .filter(isDefined)\n      .toArray();\n  }\n}\n\nexport interface Plugin extends PluginMethods {}\n\n/**\n * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.\n *\n * The PluginManager optimizes callback dispatch by only creating dispatcher methods\n * for callbacks that have at least one registered plugin, making unused plugin hooks\n * zero-cost at runtime.\n */\nexport class PluginManager implements Required<PluginMethods> {\n  #plugins = new Set<Plugin>();\n  readonly #pluginsByCallback: Partial<Record<keyof Plugin, Plugin[]>> = {};\n  constructor(public readonly em: EntityManager) {}\n\n  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */\n  hasHook(method: keyof PluginMethods): boolean {\n    return this.#pluginsByCallback[method] !== undefined;\n  }\n\n  /**\n   * Registers a plugin with this EntityManager.\n   *\n   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,\n   * enabling lazy initialization of only the hooks that are actually used.\n   *\n   * @throws Error if the plugin is already registered with another EntityManager\n   */\n  addPlugin(plugin: Plugin) {\n    if (this.#plugins.has(plugin)) return; // if we're already added, then we can just early exit\n    this.#plugins.add(plugin);\n    plugin[emsSymbol].push(new WeakRef(this.em));\n    for (const method of syncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // As a performance optimization, we only create the actual implementation for each method on the plugin manager\n        // once we have at least one plugin using that method. This is to make it so any unused plugin methods are\n        // effectively no-ops when called from within the em.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              (plugin[method] as (...args: any[]) => unknown)(...args);\n            }\n          };\n        }\n      }\n    }\n    for (const method of asyncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // Validate-phase plugin hooks are intentionally awaited without making hot-path hooks async.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = async function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              await (plugin[method] as (...args: any[]) => Promise<void> | void)(...args);\n            }\n          };\n        }\n      }\n    }\n  }\n\n  get plugins(): readonly Plugin[] {\n    return [...this.#plugins];\n  }\n\n  cloneTo(other: PluginManager) {\n    this.#plugins\n      .values()\n      .map((plugin) => plugin.maybeCloneForNewEm())\n      .filter(isDefined)\n      .forEach((plugin) => other.addPlugin(plugin));\n  }\n\n  // Defined as no-op functions initially instead of using optional chaining for performance reasons, see:\n  // https://adventures.nodeland.dev/archive/noop-functions-vs-optional-chaining-a-performance/\n\n  beforeGetField(entity: Entity, field: string): void {}\n  beforeSetField(entity: Entity, field: string, newValue: any): void {}\n  beforeFind(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void {}\n  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData) {}\n  beforeValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void {}\n}\n"],"mappings":";;;;AAkEA,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;AACF;AACA,MAAM,qBAAqB,CAAC,kBAAkB,eAAe;AAC7D,MAAM,YAAY,OAAO,KAAK;;;;;;;AAO9B,IAAsB,SAAtB,MAA6B;CAG3B,CAAC,aAAuC,CAAC;CAEzC,qBAAuC,CAEvC;CAEA,IAAI,MAAgC;EAClC,OAAO,KAAK,UAAU,CACnB,OAAO,CAAC,CACR,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CACvB,OAAO,SAAS,CAAC,CACjB,QAAQ;CACb;AACF;;;;;;;;AAWA,IAAa,gBAAb,MAA8D;CAGhC;CAF5B,2BAAW,IAAI,IAAY;CAC3B,qBAAuE,CAAC;CACxE,YAAY,IAAmC;EAAnB,KAAA,KAAA;CAAoB;;CAGhD,QAAQ,QAAsC;EAC5C,OAAO,KAAKA,mBAAmB,YAAY,KAAA;CAC7C;;;;;;;;;CAUA,UAAU,QAAgB;EACxB,IAAI,KAAKC,SAAS,IAAI,MAAM,GAAG;EAC/B,KAAKA,SAAS,IAAI,MAAM;EACxB,OAAO,UAAU,CAAC,KAAK,IAAI,QAAQ,KAAK,EAAE,CAAC;EAC3C,KAAK,MAAM,UAAU,mBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKD,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAIpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,SAA+B,GAAG,MAAa;IAC5D,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,OAAQ,OAAO,CAAiC,GAAG,IAAI;GAE3D;EAEJ;EAEF,KAAK,MAAM,UAAU,oBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKA,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAEpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,eAAqC,GAAG,MAAa;IAClE,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,MAAO,OAAO,OAAO,CAA8C,GAAG,IAAI;GAE9E;EAEJ;CAEJ;CAEA,IAAI,UAA6B;EAC/B,OAAO,CAAC,GAAG,KAAKC,QAAQ;CAC1B;CAEA,QAAQ,OAAsB;EAC5B,KAAKA,SACF,OAAO,CAAC,CACR,KAAK,WAAW,OAAO,mBAAmB,CAAC,CAAC,CAC5C,OAAO,SAAS,CAAC,CACjB,SAAS,WAAW,MAAM,UAAU,MAAM,CAAC;CAChD;CAKA,eAAe,QAAgB,OAAqB,CAAC;CACrD,eAAe,QAAgB,OAAe,UAAqB,CAAC;CACpE,WACE,MACA,WACA,OACA,UAQM,CAAC;CACT,UAAU,MAAsB,WAA0B,MAAe,CAAC;CAC1E,eAAe,UAAmD,CAAC;CACnE,cAAc,UAAmD,CAAC;CAClE,WAAW,aAAmC,cAAiD,CAAC;AAClG"}
+{"version":3,"file":"PluginManager.js","names":["#pluginsByCallback","#plugins"],"sources":["../src/PluginManager.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, type FindOperation, isDefined } from \"src/EntityManager.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport type { JoinRowTodo, Todo } from \"src/flush/Todo.ts\";\nimport type { ParsedFindQuery } from \"src/queries/find/QueryParser.ts\";\nimport { type RowData } from \"src/RowData.ts\";\n\ninterface PluginMethods {\n  /**\n   * Called before a field value is retrieved from an entity via getField.\n   *\n   * @param entity The entity instance being accessed\n   * @param field The field name being retrieved\n   */\n  beforeGetField?(entity: Entity, field: string): void;\n  /**\n   * Called before a field value is set on an entity via setField.\n   *\n   * @param entity The entity instance being modified\n   * @param field The field name being set\n   * @param newValue The new value being assigned to the field\n   */\n  beforeSetField?(entity: Entity, field: string, newValue: any): void;\n  /**\n   * Called before a find operation is executed.\n   *\n   * @param meta Metadata for the entity type being queried\n   * @param operation The type of find operation being performed\n   * @param query The parsed query conditions\n   * @param settings Query settings including limit and offset\n   */\n  beforeFind?(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void;\n  /**\n   * Called after a find operation has been executed to observe the raw database rows.\n   *\n   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,\n   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.\n   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;\n   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is\n   * unsupported and is not guaranteed to affect entity hydration.\n   *\n   * @param meta Metadata for the entity type that was queried\n   * @param operation The type of find operation that was performed\n   * @param rows A read-only view of the raw database rows returned from the query\n   */\n  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;\n\n  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;\n}\n\nconst syncPluginMethods = [\n  \"beforeGetField\",\n  \"beforeSetField\",\n  \"beforeFind\",\n  \"afterFind\",\n  \"afterWrite\",\n] as const satisfies readonly (keyof PluginMethods)[];\nconst asyncPluginMethods = [\"beforeValidate\", \"afterValidate\"] as const satisfies readonly (keyof PluginMethods)[];\nconst emsSymbol = Symbol(\"ems\");\n/**\n * Base class for plugins that hook into entity lifecycle events.\n *\n * Plugins can implement any of the PluginMethods to intercept entity operations\n * and are automatically registered with the EntityManager when added via PluginManager.\n */\nexport abstract class Plugin {\n  // We need to store the EntityManager references in a WeakRef array so that they can be garbage collected.  If we\n  // didn't do this, then multiple EMs with the same plugin instance could keep each other from being garbage collected.\n  [emsSymbol]: WeakRef<EntityManager>[] = [];\n\n  maybeCloneForNewEm(): this | undefined {\n    return undefined;\n  }\n\n  get ems(): readonly EntityManager[] {\n    return this[emsSymbol]\n      .values()\n      .map((wr) => wr.deref())\n      .filter(isDefined)\n      .toArray();\n  }\n}\n\nexport interface Plugin extends PluginMethods {}\n\n/**\n * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.\n *\n * The PluginManager optimizes callback dispatch by only creating dispatcher methods\n * for callbacks that have at least one registered plugin, making unused plugin hooks\n * zero-cost at runtime.\n */\nexport class PluginManager implements Required<PluginMethods> {\n  #plugins = new Set<Plugin>();\n  readonly #pluginsByCallback: Partial<Record<keyof Plugin, Plugin[]>> = {};\n  constructor(public readonly em: EntityManager) {}\n\n  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */\n  hasHook(method: keyof PluginMethods): boolean {\n    return this.#pluginsByCallback[method] !== undefined;\n  }\n\n  /**\n   * Registers a plugin with this EntityManager.\n   *\n   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,\n   * enabling lazy initialization of only the hooks that are actually used.\n   *\n   * @throws Error if the plugin is already registered with another EntityManager\n   */\n  addPlugin(plugin: Plugin) {\n    if (this.#plugins.has(plugin)) return; // if we're already added, then we can just early exit\n    this.#plugins.add(plugin);\n    plugin[emsSymbol].push(new WeakRef(this.em));\n    for (const method of syncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // As a performance optimization, we only create the actual implementation for each method on the plugin manager\n        // once we have at least one plugin using that method. This is to make it so any unused plugin methods are\n        // effectively no-ops when called from within the em.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              (plugin[method] as (...args: any[]) => unknown)(...args);\n            }\n          };\n        }\n      }\n    }\n    for (const method of asyncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // Validate-phase plugin hooks are intentionally awaited without making hot-path hooks async.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = async function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              await (plugin[method] as (...args: any[]) => Promise<void> | void)(...args);\n            }\n          };\n        }\n      }\n    }\n  }\n\n  get plugins(): readonly Plugin[] {\n    return [...this.#plugins];\n  }\n\n  cloneTo(other: PluginManager) {\n    this.#plugins\n      .values()\n      .map((plugin) => plugin.maybeCloneForNewEm())\n      .filter(isDefined)\n      .forEach((plugin) => other.addPlugin(plugin));\n  }\n\n  // Defined as no-op functions initially instead of using optional chaining for performance reasons, see:\n  // https://adventures.nodeland.dev/archive/noop-functions-vs-optional-chaining-a-performance/\n\n  beforeGetField(entity: Entity, field: string): void {}\n  beforeSetField(entity: Entity, field: string, newValue: any): void {}\n  beforeFind(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void {}\n  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData) {}\n  beforeValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void {}\n}\n"],"mappings":";;;;AAkEA,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;AACF;AACA,MAAM,qBAAqB,CAAC,kBAAkB,eAAe;AAC7D,MAAM,YAAY,OAAO,KAAK;;;;;;;AAO9B,IAAsB,SAAtB,MAA6B;CAG3B,CAAC,aAAuC,CAAC;CAEzC,qBAAuC,CAEvC;CAEA,IAAI,MAAgC;EAClC,OAAO,KAAK,UAAU,CACnB,OAAO,CAAC,CACR,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CACvB,OAAO,SAAS,CAAC,CACjB,QAAQ;CACb;AACF;;;;;;;;AAWA,IAAa,gBAAb,MAA8D;CAGhC;CAF5B,2BAAW,IAAI,IAAY;CAC3B,qBAAuE,CAAC;CACxE,YAAY,IAAmC;EAAnB,KAAA,KAAA;CAAoB;;CAGhD,QAAQ,QAAsC;EAC5C,OAAO,KAAKA,mBAAmB,YAAY,KAAA;CAC7C;;;;;;;;;CAUA,UAAU,QAAgB;EACxB,IAAI,KAAKC,SAAS,IAAI,MAAM,GAAG;EAC/B,KAAKA,SAAS,IAAI,MAAM;EACxB,OAAO,UAAU,CAAC,KAAK,IAAI,QAAQ,KAAK,EAAE,CAAC;EAC3C,KAAK,MAAM,UAAU,mBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKD,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAIpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,SAA+B,GAAG,MAAa;IAC5D,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,OAAQ,OAAO,CAAiC,GAAG,IAAI;GAE3D;EAEJ;EAEF,KAAK,MAAM,UAAU,oBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKA,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAEpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,eAAqC,GAAG,MAAa;IAClE,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,MAAO,OAAO,OAAO,CAA8C,GAAG,IAAI;GAE9E;EAEJ;CAEJ;CAEA,IAAI,UAA6B;EAC/B,OAAO,CAAC,GAAG,KAAKC,QAAQ;CAC1B;CAEA,QAAQ,OAAsB;EAC5B,KAAKA,SACF,OAAO,CAAC,CACR,KAAK,WAAW,OAAO,mBAAmB,CAAC,CAAC,CAC5C,OAAO,SAAS,CAAC,CACjB,SAAS,WAAW,MAAM,UAAU,MAAM,CAAC;CAChD;CAKA,eAAe,QAAgB,OAAqB,CAAC;CACrD,eAAe,QAAgB,OAAe,UAAqB,CAAC;CACpE,WACE,MACA,WACA,OACA,UAQM,CAAC;CACT,UAAU,MAAsB,WAA0B,MAAe,CAAC;CAC1E,eAAe,UAAmD,CAAC;CACnE,cAAc,UAAmD,CAAC;CAClE,WAAW,aAAmC,cAAiD,CAAC;AAClG"}

package/build/batchloaders/enumCollectionBatchLoader.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"enumCollectionBatchLoader.cjs","names":["getEmInternalApi","abbreviation","keyToNumber"],"sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"sourcesContent":["import { type EntityManager, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type ManyToManyLike, type ParsedFindQuery, keyToNumber } from \"../index.ts\";\nimport { abbreviation } from \"../utils.ts\";\nimport { type BatchLoader } from \"./BatchLoader.ts\";\n\nexport const enumCollectionLoadOperation = \"enum-collection-load\";\n\n/** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */\nexport function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string> {\n  return em.getBatchLoader(enumCollectionLoadOperation, collection.joinTableName, (keys) =>\n    loadBatch(em, collection, keys),\n  );\n}\n\nasync function loadBatch(em: EntityManager, collection: ManyToManyLike, keys: string[]): Promise<void> {\n  const { meta, columnName, otherColumnName, joinTableName, hasJoinTableId, otherEnum, fieldName } = collection;\n  const joinRows = getEmInternalApi(em).joinRows(collection);\n\n  const alias = abbreviation(joinTableName);\n  const query: ParsedFindQuery = {\n    selects: [`\"${alias}\".*`],\n    tables: [{ alias, join: \"primary\", table: joinTableName }],\n    condition: {\n      kind: \"exp\",\n      op: \"and\",\n      conditions: [\n        {\n          kind: \"column\",\n          alias,\n          column: columnName,\n          dbType: meta.idDbType,\n          cond: { kind: \"in\", value: keys.map((id) => keyToNumber(meta, id)!) },\n        },\n      ],\n    },\n    // Id-less join tables have no surrogate id to order by, so order by the FK columns instead.\n    orderBys: hasJoinTableId\n      ? [{ alias, column: \"id\", order: \"ASC\" }]\n      : [\n          { alias, column: columnName, order: \"ASC\" },\n          { alias, column: otherColumnName, order: \"ASC\" },\n        ],\n  };\n\n  const rows = await em[\"executeFind\"](meta, enumCollectionLoadOperation, query, { limit: undefined });\n  await joinRows.loadRows(\n    keys.map((id) => [columnName, id]),\n    rows,\n  );\n\n  const api = getEmInternalApi(em);\n  for (const id of keys) {\n    const entity = em.getEntity(id);\n    if (!entity) continue;\n    const codes = (joinRows.getOthers(columnName, entity) as number[])\n      .sort((a, b) => a - b)\n      .map((enumId) => otherEnum!.findById(enumId)!.code);\n    api.setPreloadedRelation(entity.idTagged!, fieldName, codes);\n  }\n}\n"],"mappings":";;;;;;;AAKA,MAAa,8BAA8B;;AAG3C,SAAgB,0BAA0B,IAAmB,YAAiD;CAC5G,OAAO,GAAG,eAAe,6BAA6B,WAAW,gBAAgB,SAC/E,UAAU,IAAI,YAAY,IAAI,CAChC;AACF;AAEA,eAAe,UAAU,IAAmB,YAA4B,MAA+B;CACrG,MAAM,EAAE,MAAM,YAAY,iBAAiB,eAAe,gBAAgB,WAAW,cAAc;CACnG,MAAM,WAAWA,sBAAAA,iBAAiB,EAAE,CAAC,CAAC,SAAS,UAAU;CAEzD,MAAM,QAAQC,cAAAA,aAAa,aAAa;CACxC,MAAM,QAAyB;EAC7B,SAAS,CAAC,IAAI,MAAM,IAAI;EACxB,QAAQ,CAAC;GAAE;GAAO,MAAM;GAAW,OAAO;EAAc,CAAC;EACzD,WAAW;GACT,MAAM;GACN,IAAI;GACJ,YAAY,CACV;IACE,MAAM;IACN;IACA,QAAQ;IACR,QAAQ,KAAK;IACb,MAAM;KAAE,MAAM;KAAM,OAAO,KAAK,KAAK,OAAOC,aAAAA,YAAY,MAAM,EAAE,CAAE;IAAE;GACtE,CACF;EACF;EAEA,UAAU,iBACN,CAAC;GAAE;GAAO,QAAQ;GAAM,OAAO;EAAM,CAAC,IACtC,CACE;GAAE;GAAO,QAAQ;GAAY,OAAO;EAAM,GAC1C;GAAE;GAAO,QAAQ;GAAiB,OAAO;EAAM,CACjD;CACN;CAEA,MAAM,OAAO,MAAM,GAAG,cAAc,CAAC,MAAM,6BAA6B,OAAO,EAAE,OAAO,KAAA,EAAU,CAAC;CACnG,MAAM,SAAS,SACb,KAAK,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,GACjC,IACF;CAEA,MAAM,MAAMF,sBAAAA,iBAAiB,EAAE;CAC/B,KAAK,MAAM,MAAM,MAAM;EACrB,MAAM,SAAS,GAAG,UAAU,EAAE;EAC9B,IAAI,CAAC,QAAQ;EACb,MAAM,QAAS,SAAS,UAAU,YAAY,MAAM,CAAC,CAClD,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,CACrB,KAAK,WAAW,UAAW,SAAS,MAAM,CAAC,CAAE,IAAI;EACpD,IAAI,qBAAqB,OAAO,UAAW,WAAW,KAAK;CAC7D;AACF"}
+{"version":3,"file":"enumCollectionBatchLoader.cjs","names":["getEmInternalApi","abbreviation","keyToNumber"],"sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"sourcesContent":["import { type BatchLoader } from \"src/batchloaders/BatchLoader.ts\";\nimport { type EntityManager, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type ManyToManyLike, type ParsedFindQuery, keyToNumber } from \"src/index.ts\";\nimport { abbreviation } from \"src/utils.ts\";\n\nexport const enumCollectionLoadOperation = \"enum-collection-load\";\n\n/** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */\nexport function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string> {\n  return em.getBatchLoader(enumCollectionLoadOperation, collection.joinTableName, (keys) =>\n    loadBatch(em, collection, keys),\n  );\n}\n\nasync function loadBatch(em: EntityManager, collection: ManyToManyLike, keys: string[]): Promise<void> {\n  const { meta, columnName, otherColumnName, joinTableName, hasJoinTableId, otherEnum, fieldName } = collection;\n  const joinRows = getEmInternalApi(em).joinRows(collection);\n\n  const alias = abbreviation(joinTableName);\n  const query: ParsedFindQuery = {\n    selects: [`\"${alias}\".*`],\n    tables: [{ alias, join: \"primary\", table: joinTableName }],\n    condition: {\n      kind: \"exp\",\n      op: \"and\",\n      conditions: [\n        {\n          kind: \"column\",\n          alias,\n          column: columnName,\n          dbType: meta.idDbType,\n          cond: { kind: \"in\", value: keys.map((id) => keyToNumber(meta, id)!) },\n        },\n      ],\n    },\n    // Id-less join tables have no surrogate id to order by, so order by the FK columns instead.\n    orderBys: hasJoinTableId\n      ? [{ alias, column: \"id\", order: \"ASC\" }]\n      : [\n          { alias, column: columnName, order: \"ASC\" },\n          { alias, column: otherColumnName, order: \"ASC\" },\n        ],\n  };\n\n  const rows = await em[\"executeFind\"](meta, enumCollectionLoadOperation, query, { limit: undefined });\n  await joinRows.loadRows(\n    keys.map((id) => [columnName, id]),\n    rows,\n  );\n\n  const api = getEmInternalApi(em);\n  for (const id of keys) {\n    const entity = em.getEntity(id);\n    if (!entity) continue;\n    const codes = (joinRows.getOthers(columnName, entity) as number[])\n      .sort((a, b) => a - b)\n      .map((enumId) => otherEnum!.findById(enumId)!.code);\n    api.setPreloadedRelation(entity.idTagged!, fieldName, codes);\n  }\n}\n"],"mappings":";;;;;;;AAKA,MAAa,8BAA8B;;AAG3C,SAAgB,0BAA0B,IAAmB,YAAiD;CAC5G,OAAO,GAAG,eAAe,6BAA6B,WAAW,gBAAgB,SAC/E,UAAU,IAAI,YAAY,IAAI,CAChC;AACF;AAEA,eAAe,UAAU,IAAmB,YAA4B,MAA+B;CACrG,MAAM,EAAE,MAAM,YAAY,iBAAiB,eAAe,gBAAgB,WAAW,cAAc;CACnG,MAAM,WAAWA,sBAAAA,iBAAiB,EAAE,CAAC,CAAC,SAAS,UAAU;CAEzD,MAAM,QAAQC,cAAAA,aAAa,aAAa;CACxC,MAAM,QAAyB;EAC7B,SAAS,CAAC,IAAI,MAAM,IAAI;EACxB,QAAQ,CAAC;GAAE;GAAO,MAAM;GAAW,OAAO;EAAc,CAAC;EACzD,WAAW;GACT,MAAM;GACN,IAAI;GACJ,YAAY,CACV;IACE,MAAM;IACN;IACA,QAAQ;IACR,QAAQ,KAAK;IACb,MAAM;KAAE,MAAM;KAAM,OAAO,KAAK,KAAK,OAAOC,aAAAA,YAAY,MAAM,EAAE,CAAE;IAAE;GACtE,CACF;EACF;EAEA,UAAU,iBACN,CAAC;GAAE;GAAO,QAAQ;GAAM,OAAO;EAAM,CAAC,IACtC,CACE;GAAE;GAAO,QAAQ;GAAY,OAAO;EAAM,GAC1C;GAAE;GAAO,QAAQ;GAAiB,OAAO;EAAM,CACjD;CACN;CAEA,MAAM,OAAO,MAAM,GAAG,cAAc,CAAC,MAAM,6BAA6B,OAAO,EAAE,OAAO,KAAA,EAAU,CAAC;CACnG,MAAM,SAAS,SACb,KAAK,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,GACjC,IACF;CAEA,MAAM,MAAMF,sBAAAA,iBAAiB,EAAE;CAC/B,KAAK,MAAM,MAAM,MAAM;EACrB,MAAM,SAAS,GAAG,UAAU,EAAE;EAC9B,IAAI,CAAC,QAAQ;EACb,MAAM,QAAS,SAAS,UAAU,YAAY,MAAM,CAAC,CAClD,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,CACrB,KAAK,WAAW,UAAW,SAAS,MAAM,CAAC,CAAE,IAAI;EACpD,IAAI,qBAAqB,OAAO,UAAW,WAAW,KAAK;CAC7D;AACF"}