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

package/build/BaseEntity.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"BaseEntity.cjs","names":["deTagId","getMetadata","keyToNumber","InstanceData"],"sources":["../src/BaseEntity.ts"],"sourcesContent":["import { type IdType } from \"./Entity.ts\";\nimport {\n  type Entity,\n  type EntityManager,\n  type EntityMetadata,\n  InstanceData,\n  type TaggedId,\n  deTagId,\n  getMetadata,\n  keyToNumber,\n} from \"./index.ts\";\n\n/**\n * Returns the internal `__data` tracking field for `entity`.\n *\n * This should be treated as an internal API and may change without notice.\n */\nexport function getInstanceData(entity: Entity): InstanceData {\n  return BaseEntity.getInstanceData(entity);\n}\n\n/**\n * The base class for all entities.\n *\n * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.\n */\nexport abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {\n  public static getInstanceData(entity: Entity): InstanceData {\n    return (entity as BaseEntity<any>).__data;\n  }\n  // We use a protected field so that subclass getters can easily access `this.__data.relations`.\n  protected readonly __data!: InstanceData;\n\n  /** The single-arg constructor is our psuedo-public API that can only be called by the EntityManager. */\n  constructor(em: EntityManager);\n  constructor(em: EntityManager, isNew?: boolean) {\n    if (isNew === undefined) {\n      throw new Error(\"Entities must be constructed by calling em.create or em.load\");\n    }\n    // This code path won't be reused for real entities, as they go through the `newEntity`\n    // construction process that lazifies the relations.\n    baseEntityCstr(em, this, isNew);\n  }\n\n  // This gives rules a way to access the fully typed object instead of their Reacted view.\n  // And we make it public so that a function that takes Reacted<...> can accept a Loaded<...>\n  // that sufficiently overlaps.\n  get fullNonReactiveAccess(): this {\n    return this;\n  }\n\n  /** @returns the entity's id, tagged/untagged based on your config, or a runtime error if it's new/unassigned. */\n  abstract id: I;\n\n  /** @returns the entity's, tagged/untagged based on your config, or undefined if it's new/unassigned. */\n  abstract get idMaybe(): I | undefined;\n\n  /** @returns the entity's id, always tagged, or a runtime error if it's new/unassigned. */\n  abstract idTagged: TaggedId;\n\n  /** @returns the entity's id, always tagged, or undefined if it's new/unassigned. */\n  abstract get idTaggedMaybe(): TaggedId | undefined;\n\n  /** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */\n  get idUntagged(): string {\n    return deTagId(getMetadata(this), this.id);\n  }\n\n  abstract set(opts: unknown): void;\n\n  /**\n   * Similar to `set` but applies \"Partial API\" semantics, i.e. `null` means unset and `undefined` means don't change.\n   */\n  abstract setPartial(opts: unknown): void;\n\n  /**\n   * Similar to `set` but applies \"Partial API\" semantics, i.e. `null` means unset and `undefined` means don't change.\n   */\n  abstract setDeepPartial(opts: unknown): Promise<void>;\n\n  /**\n   * Returns whether the entity is new.\n   *\n   * This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity\n   * is no longer new; this only flips to `false` after the `flush` transaction has been committed.\n   */\n  get isNewEntity(): boolean {\n    return this.__data.isNewEntity;\n  }\n\n  get isDeletedEntity(): boolean {\n    return this.__data.isDeletedEntity;\n  }\n\n  get isDirtyEntity(): boolean {\n    return this.__data.isDirtyEntity;\n  }\n\n  toString(): string {\n    const meta = getMetadata(this);\n    return toStringWithPrefix(meta, this, meta.type);\n  }\n\n  toTaggedString(): string {\n    const meta = getMetadata(this);\n    return toStringWithPrefix(meta, this, meta.tagName);\n  }\n\n  public get em(): EM {\n    return this.__data.em as EM;\n  }\n\n  /**\n   * A very simple toJSON that just returns the id.\n   *\n   * This is for security reasons, to avoid accidentally logging sensitive data; you\n   * can specify more fields, and potentially nested return data, by using passing\n   * a {@link JsonHint} to `toJSON`.\n   */\n  public toJSON(): object {\n    return { id: this.idMaybe || null };\n  }\n\n  [Symbol.toStringTag](): string {\n    return this.toString();\n  }\n\n  /**\n   * Hooks into node's `console.log` to avoid sprawling output of our relations/internal state.\n   *\n   * See https://nodejs.org/api/util.html#custom-inspection-functions-on-objects.\n   */\n  [Symbol.for(\"nodejs.util.inspect.custom\")](): string {\n    return this.toString();\n  }\n\n  /** A bag of non-persisted state, typically for flags that control business logic behavior. */\n  declare readonly transientFields: Record<string, unknown>;\n}\n\nfunction toStringWithPrefix(meta: EntityMetadata, entity: Entity, prefix: string): string {\n  // Start with `Author` or `a`, depending on the caller\n  let result = prefix;\n  // Add `#1` if this is an em.create-d entity\n  const data = getInstanceData(entity);\n  const createId = data.createId;\n  if (createId) {\n    result += `#${createId}`;\n  }\n  // Add the `:1` but only after our flush is complete, otherwise the id is\n  // internally assigned but not really flushed/committed to the db yet\n  const dbId = entity.idTaggedMaybe;\n  if (data.pendingOperation !== \"insert\" && dbId) {\n    // Strip the tag because we add back the entity prefix\n    result += `:${keyToNumber(meta, dbId)}`;\n  }\n  return result;\n}\n\n/**\n * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too\n * on its `Object.create`-d instances.\n */\nexport function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void {\n  const data = new InstanceData(em, entity, (entity.constructor as any).metadata, isNew);\n  // This makes it non-enumerable to avoid Jest/recursive things tripping over it\n  Object.defineProperty(entity, \"__data\", { value: data, enumerable: false, writable: false, configurable: false });\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,SAAgB,gBAAgB,QAA8B;CAC5D,OAAO,WAAW,gBAAgB,MAAM;AAC1C;;;;;;AAOA,IAAsB,aAAtB,MAAwG;CACtG,OAAc,gBAAgB,QAA8B;EAC1D,OAAQ,OAA2B;CACrC;CAEA;CAIA,YAAY,IAAmB,OAAiB;EAC9C,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,8DAA8D;EAIhF,eAAe,IAAI,MAAM,KAAK;CAChC;CAKA,IAAI,wBAA8B;EAChC,OAAO;CACT;;CAeA,IAAI,aAAqB;EACvB,OAAOA,aAAAA,QAAQC,uBAAAA,YAAY,IAAI,GAAG,KAAK,EAAE;CAC3C;;;;;;;CAoBA,IAAI,cAAuB;EACzB,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,kBAA2B;EAC7B,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,gBAAyB;EAC3B,OAAO,KAAK,OAAO;CACrB;CAEA,WAAmB;EACjB,MAAM,OAAOA,uBAAAA,YAAY,IAAI;EAC7B,OAAO,mBAAmB,MAAM,MAAM,KAAK,IAAI;CACjD;CAEA,iBAAyB;EACvB,MAAM,OAAOA,uBAAAA,YAAY,IAAI;EAC7B,OAAO,mBAAmB,MAAM,MAAM,KAAK,OAAO;CACpD;CAEA,IAAW,KAAS;EAClB,OAAO,KAAK,OAAO;CACrB;;;;;;;;CASA,SAAwB;EACtB,OAAO,EAAE,IAAI,KAAK,WAAW,KAAK;CACpC;CAEA,CAAC,OAAO,eAAuB;EAC7B,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,CAAC,OAAO,IAAI,4BAA4B,KAAa;EACnD,OAAO,KAAK,SAAS;CACvB;AAIF;AAEA,SAAS,mBAAmB,MAAsB,QAAgB,QAAwB;CAExF,IAAI,SAAS;CAEb,MAAM,OAAO,gBAAgB,MAAM;CACnC,MAAM,WAAW,KAAK;CACtB,IAAI,UACF,UAAU,IAAI;CAIhB,MAAM,OAAO,OAAO;CACpB,IAAI,KAAK,qBAAqB,YAAY,MAExC,UAAU,IAAIC,aAAAA,YAAY,MAAM,IAAI;CAEtC,OAAO;AACT;;;;;AAMA,SAAgB,eAAe,IAAmB,QAA8B,OAAsB;CACpG,MAAM,OAAO,IAAIC,qBAAAA,aAAa,IAAI,QAAS,OAAO,YAAoB,UAAU,KAAK;CAErF,OAAO,eAAe,QAAQ,UAAU;EAAE,OAAO;EAAM,YAAY;EAAO,UAAU;EAAO,cAAc;CAAM,CAAC;AAClH"}
+{"version":3,"file":"BaseEntity.cjs","names":["deTagId","getMetadata","keyToNumber","InstanceData"],"sources":["../src/BaseEntity.ts"],"sourcesContent":["import { type IdType } from \"src/Entity.ts\";\nimport {\n  type Entity,\n  type EntityManager,\n  type EntityMetadata,\n  InstanceData,\n  type TaggedId,\n  deTagId,\n  getMetadata,\n  keyToNumber,\n} from \"src/index.ts\";\n\n/**\n * Returns the internal `__data` tracking field for `entity`.\n *\n * This should be treated as an internal API and may change without notice.\n */\nexport function getInstanceData(entity: Entity): InstanceData {\n  return BaseEntity.getInstanceData(entity);\n}\n\n/**\n * The base class for all entities.\n *\n * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.\n */\nexport abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {\n  public static getInstanceData(entity: Entity): InstanceData {\n    return (entity as BaseEntity<any>).__data;\n  }\n  // We use a protected field so that subclass getters can easily access `this.__data.relations`.\n  protected readonly __data!: InstanceData;\n\n  /** The single-arg constructor is our psuedo-public API that can only be called by the EntityManager. */\n  constructor(em: EntityManager);\n  constructor(em: EntityManager, isNew?: boolean) {\n    if (isNew === undefined) {\n      throw new Error(\"Entities must be constructed by calling em.create or em.load\");\n    }\n    // This code path won't be reused for real entities, as they go through the `newEntity`\n    // construction process that lazifies the relations.\n    baseEntityCstr(em, this, isNew);\n  }\n\n  // This gives rules a way to access the fully typed object instead of their Reacted view.\n  // And we make it public so that a function that takes Reacted<...> can accept a Loaded<...>\n  // that sufficiently overlaps.\n  get fullNonReactiveAccess(): this {\n    return this;\n  }\n\n  /** @returns the entity's id, tagged/untagged based on your config, or a runtime error if it's new/unassigned. */\n  abstract id: I;\n\n  /** @returns the entity's, tagged/untagged based on your config, or undefined if it's new/unassigned. */\n  abstract get idMaybe(): I | undefined;\n\n  /** @returns the entity's id, always tagged, or a runtime error if it's new/unassigned. */\n  abstract idTagged: TaggedId;\n\n  /** @returns the entity's id, always tagged, or undefined if it's new/unassigned. */\n  abstract get idTaggedMaybe(): TaggedId | undefined;\n\n  /** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */\n  get idUntagged(): string {\n    return deTagId(getMetadata(this), this.id);\n  }\n\n  abstract set(opts: unknown): void;\n\n  /**\n   * Similar to `set` but applies \"Partial API\" semantics, i.e. `null` means unset and `undefined` means don't change.\n   */\n  abstract setPartial(opts: unknown): void;\n\n  /**\n   * Similar to `set` but applies \"Partial API\" semantics, i.e. `null` means unset and `undefined` means don't change.\n   */\n  abstract setDeepPartial(opts: unknown): Promise<void>;\n\n  /**\n   * Returns whether the entity is new.\n   *\n   * This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity\n   * is no longer new; this only flips to `false` after the `flush` transaction has been committed.\n   */\n  get isNewEntity(): boolean {\n    return this.__data.isNewEntity;\n  }\n\n  get isDeletedEntity(): boolean {\n    return this.__data.isDeletedEntity;\n  }\n\n  get isDirtyEntity(): boolean {\n    return this.__data.isDirtyEntity;\n  }\n\n  toString(): string {\n    const meta = getMetadata(this);\n    return toStringWithPrefix(meta, this, meta.type);\n  }\n\n  toTaggedString(): string {\n    const meta = getMetadata(this);\n    return toStringWithPrefix(meta, this, meta.tagName);\n  }\n\n  public get em(): EM {\n    return this.__data.em as EM;\n  }\n\n  /**\n   * A very simple toJSON that just returns the id.\n   *\n   * This is for security reasons, to avoid accidentally logging sensitive data; you\n   * can specify more fields, and potentially nested return data, by using passing\n   * a {@link JsonHint} to `toJSON`.\n   */\n  public toJSON(): object {\n    return { id: this.idMaybe || null };\n  }\n\n  [Symbol.toStringTag](): string {\n    return this.toString();\n  }\n\n  /**\n   * Hooks into node's `console.log` to avoid sprawling output of our relations/internal state.\n   *\n   * See https://nodejs.org/api/util.html#custom-inspection-functions-on-objects.\n   */\n  [Symbol.for(\"nodejs.util.inspect.custom\")](): string {\n    return this.toString();\n  }\n\n  /** A bag of non-persisted state, typically for flags that control business logic behavior. */\n  declare readonly transientFields: Record<string, unknown>;\n}\n\nfunction toStringWithPrefix(meta: EntityMetadata, entity: Entity, prefix: string): string {\n  // Start with `Author` or `a`, depending on the caller\n  let result = prefix;\n  // Add `#1` if this is an em.create-d entity\n  const data = getInstanceData(entity);\n  const createId = data.createId;\n  if (createId) {\n    result += `#${createId}`;\n  }\n  // Add the `:1` but only after our flush is complete, otherwise the id is\n  // internally assigned but not really flushed/committed to the db yet\n  const dbId = entity.idTaggedMaybe;\n  if (data.pendingOperation !== \"insert\" && dbId) {\n    // Strip the tag because we add back the entity prefix\n    result += `:${keyToNumber(meta, dbId)}`;\n  }\n  return result;\n}\n\n/**\n * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too\n * on its `Object.create`-d instances.\n */\nexport function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void {\n  const data = new InstanceData(em, entity, (entity.constructor as any).metadata, isNew);\n  // This makes it non-enumerable to avoid Jest/recursive things tripping over it\n  Object.defineProperty(entity, \"__data\", { value: data, enumerable: false, writable: false, configurable: false });\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,SAAgB,gBAAgB,QAA8B;CAC5D,OAAO,WAAW,gBAAgB,MAAM;AAC1C;;;;;;AAOA,IAAsB,aAAtB,MAAwG;CACtG,OAAc,gBAAgB,QAA8B;EAC1D,OAAQ,OAA2B;CACrC;CAEA;CAIA,YAAY,IAAmB,OAAiB;EAC9C,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,8DAA8D;EAIhF,eAAe,IAAI,MAAM,KAAK;CAChC;CAKA,IAAI,wBAA8B;EAChC,OAAO;CACT;;CAeA,IAAI,aAAqB;EACvB,OAAOA,aAAAA,QAAQC,uBAAAA,YAAY,IAAI,GAAG,KAAK,EAAE;CAC3C;;;;;;;CAoBA,IAAI,cAAuB;EACzB,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,kBAA2B;EAC7B,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,gBAAyB;EAC3B,OAAO,KAAK,OAAO;CACrB;CAEA,WAAmB;EACjB,MAAM,OAAOA,uBAAAA,YAAY,IAAI;EAC7B,OAAO,mBAAmB,MAAM,MAAM,KAAK,IAAI;CACjD;CAEA,iBAAyB;EACvB,MAAM,OAAOA,uBAAAA,YAAY,IAAI;EAC7B,OAAO,mBAAmB,MAAM,MAAM,KAAK,OAAO;CACpD;CAEA,IAAW,KAAS;EAClB,OAAO,KAAK,OAAO;CACrB;;;;;;;;CASA,SAAwB;EACtB,OAAO,EAAE,IAAI,KAAK,WAAW,KAAK;CACpC;CAEA,CAAC,OAAO,eAAuB;EAC7B,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,CAAC,OAAO,IAAI,4BAA4B,KAAa;EACnD,OAAO,KAAK,SAAS;CACvB;AAIF;AAEA,SAAS,mBAAmB,MAAsB,QAAgB,QAAwB;CAExF,IAAI,SAAS;CAEb,MAAM,OAAO,gBAAgB,MAAM;CACnC,MAAM,WAAW,KAAK;CACtB,IAAI,UACF,UAAU,IAAI;CAIhB,MAAM,OAAO,OAAO;CACpB,IAAI,KAAK,qBAAqB,YAAY,MAExC,UAAU,IAAIC,aAAAA,YAAY,MAAM,IAAI;CAEtC,OAAO;AACT;;;;;AAMA,SAAgB,eAAe,IAAmB,QAA8B,OAAsB;CACpG,MAAM,OAAO,IAAIC,qBAAAA,aAAa,IAAI,QAAS,OAAO,YAAoB,UAAU,KAAK;CAErF,OAAO,eAAe,QAAQ,UAAU;EAAE,OAAO;EAAM,YAAY;EAAO,UAAU;EAAO,cAAc;CAAM,CAAC;AAClH"}

package/build/BaseEntity.js.map

@@ -1 +1 @@
-{"version":3,"file":"BaseEntity.js","names":[],"sources":["../src/BaseEntity.ts"],"sourcesContent":["import { type IdType } from \"./Entity.ts\";\nimport {\n  type Entity,\n  type EntityManager,\n  type EntityMetadata,\n  InstanceData,\n  type TaggedId,\n  deTagId,\n  getMetadata,\n  keyToNumber,\n} from \"./index.ts\";\n\n/**\n * Returns the internal `__data` tracking field for `entity`.\n *\n * This should be treated as an internal API and may change without notice.\n */\nexport function getInstanceData(entity: Entity): InstanceData {\n  return BaseEntity.getInstanceData(entity);\n}\n\n/**\n * The base class for all entities.\n *\n * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.\n */\nexport abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {\n  public static getInstanceData(entity: Entity): InstanceData {\n    return (entity as BaseEntity<any>).__data;\n  }\n  // We use a protected field so that subclass getters can easily access `this.__data.relations`.\n  protected readonly __data!: InstanceData;\n\n  /** The single-arg constructor is our psuedo-public API that can only be called by the EntityManager. */\n  constructor(em: EntityManager);\n  constructor(em: EntityManager, isNew?: boolean) {\n    if (isNew === undefined) {\n      throw new Error(\"Entities must be constructed by calling em.create or em.load\");\n    }\n    // This code path won't be reused for real entities, as they go through the `newEntity`\n    // construction process that lazifies the relations.\n    baseEntityCstr(em, this, isNew);\n  }\n\n  // This gives rules a way to access the fully typed object instead of their Reacted view.\n  // And we make it public so that a function that takes Reacted<...> can accept a Loaded<...>\n  // that sufficiently overlaps.\n  get fullNonReactiveAccess(): this {\n    return this;\n  }\n\n  /** @returns the entity's id, tagged/untagged based on your config, or a runtime error if it's new/unassigned. */\n  abstract id: I;\n\n  /** @returns the entity's, tagged/untagged based on your config, or undefined if it's new/unassigned. */\n  abstract get idMaybe(): I | undefined;\n\n  /** @returns the entity's id, always tagged, or a runtime error if it's new/unassigned. */\n  abstract idTagged: TaggedId;\n\n  /** @returns the entity's id, always tagged, or undefined if it's new/unassigned. */\n  abstract get idTaggedMaybe(): TaggedId | undefined;\n\n  /** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */\n  get idUntagged(): string {\n    return deTagId(getMetadata(this), this.id);\n  }\n\n  abstract set(opts: unknown): void;\n\n  /**\n   * Similar to `set` but applies \"Partial API\" semantics, i.e. `null` means unset and `undefined` means don't change.\n   */\n  abstract setPartial(opts: unknown): void;\n\n  /**\n   * Similar to `set` but applies \"Partial API\" semantics, i.e. `null` means unset and `undefined` means don't change.\n   */\n  abstract setDeepPartial(opts: unknown): Promise<void>;\n\n  /**\n   * Returns whether the entity is new.\n   *\n   * This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity\n   * is no longer new; this only flips to `false` after the `flush` transaction has been committed.\n   */\n  get isNewEntity(): boolean {\n    return this.__data.isNewEntity;\n  }\n\n  get isDeletedEntity(): boolean {\n    return this.__data.isDeletedEntity;\n  }\n\n  get isDirtyEntity(): boolean {\n    return this.__data.isDirtyEntity;\n  }\n\n  toString(): string {\n    const meta = getMetadata(this);\n    return toStringWithPrefix(meta, this, meta.type);\n  }\n\n  toTaggedString(): string {\n    const meta = getMetadata(this);\n    return toStringWithPrefix(meta, this, meta.tagName);\n  }\n\n  public get em(): EM {\n    return this.__data.em as EM;\n  }\n\n  /**\n   * A very simple toJSON that just returns the id.\n   *\n   * This is for security reasons, to avoid accidentally logging sensitive data; you\n   * can specify more fields, and potentially nested return data, by using passing\n   * a {@link JsonHint} to `toJSON`.\n   */\n  public toJSON(): object {\n    return { id: this.idMaybe || null };\n  }\n\n  [Symbol.toStringTag](): string {\n    return this.toString();\n  }\n\n  /**\n   * Hooks into node's `console.log` to avoid sprawling output of our relations/internal state.\n   *\n   * See https://nodejs.org/api/util.html#custom-inspection-functions-on-objects.\n   */\n  [Symbol.for(\"nodejs.util.inspect.custom\")](): string {\n    return this.toString();\n  }\n\n  /** A bag of non-persisted state, typically for flags that control business logic behavior. */\n  declare readonly transientFields: Record<string, unknown>;\n}\n\nfunction toStringWithPrefix(meta: EntityMetadata, entity: Entity, prefix: string): string {\n  // Start with `Author` or `a`, depending on the caller\n  let result = prefix;\n  // Add `#1` if this is an em.create-d entity\n  const data = getInstanceData(entity);\n  const createId = data.createId;\n  if (createId) {\n    result += `#${createId}`;\n  }\n  // Add the `:1` but only after our flush is complete, otherwise the id is\n  // internally assigned but not really flushed/committed to the db yet\n  const dbId = entity.idTaggedMaybe;\n  if (data.pendingOperation !== \"insert\" && dbId) {\n    // Strip the tag because we add back the entity prefix\n    result += `:${keyToNumber(meta, dbId)}`;\n  }\n  return result;\n}\n\n/**\n * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too\n * on its `Object.create`-d instances.\n */\nexport function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void {\n  const data = new InstanceData(em, entity, (entity.constructor as any).metadata, isNew);\n  // This makes it non-enumerable to avoid Jest/recursive things tripping over it\n  Object.defineProperty(entity, \"__data\", { value: data, enumerable: false, writable: false, configurable: false });\n}\n"],"mappings":";;;;;;;;;;;AAiBA,SAAgB,gBAAgB,QAA8B;CAC5D,OAAO,WAAW,gBAAgB,MAAM;AAC1C;;;;;;AAOA,IAAsB,aAAtB,MAAwG;CACtG,OAAc,gBAAgB,QAA8B;EAC1D,OAAQ,OAA2B;CACrC;CAEA;CAIA,YAAY,IAAmB,OAAiB;EAC9C,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,8DAA8D;EAIhF,eAAe,IAAI,MAAM,KAAK;CAChC;CAKA,IAAI,wBAA8B;EAChC,OAAO;CACT;;CAeA,IAAI,aAAqB;EACvB,OAAO,QAAQ,YAAY,IAAI,GAAG,KAAK,EAAE;CAC3C;;;;;;;CAoBA,IAAI,cAAuB;EACzB,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,kBAA2B;EAC7B,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,gBAAyB;EAC3B,OAAO,KAAK,OAAO;CACrB;CAEA,WAAmB;EACjB,MAAM,OAAO,YAAY,IAAI;EAC7B,OAAO,mBAAmB,MAAM,MAAM,KAAK,IAAI;CACjD;CAEA,iBAAyB;EACvB,MAAM,OAAO,YAAY,IAAI;EAC7B,OAAO,mBAAmB,MAAM,MAAM,KAAK,OAAO;CACpD;CAEA,IAAW,KAAS;EAClB,OAAO,KAAK,OAAO;CACrB;;;;;;;;CASA,SAAwB;EACtB,OAAO,EAAE,IAAI,KAAK,WAAW,KAAK;CACpC;CAEA,CAAC,OAAO,eAAuB;EAC7B,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,CAAC,OAAO,IAAI,4BAA4B,KAAa;EACnD,OAAO,KAAK,SAAS;CACvB;AAIF;AAEA,SAAS,mBAAmB,MAAsB,QAAgB,QAAwB;CAExF,IAAI,SAAS;CAEb,MAAM,OAAO,gBAAgB,MAAM;CACnC,MAAM,WAAW,KAAK;CACtB,IAAI,UACF,UAAU,IAAI;CAIhB,MAAM,OAAO,OAAO;CACpB,IAAI,KAAK,qBAAqB,YAAY,MAExC,UAAU,IAAI,YAAY,MAAM,IAAI;CAEtC,OAAO;AACT;;;;;AAMA,SAAgB,eAAe,IAAmB,QAA8B,OAAsB;CACpG,MAAM,OAAO,IAAI,aAAa,IAAI,QAAS,OAAO,YAAoB,UAAU,KAAK;CAErF,OAAO,eAAe,QAAQ,UAAU;EAAE,OAAO;EAAM,YAAY;EAAO,UAAU;EAAO,cAAc;CAAM,CAAC;AAClH"}
+{"version":3,"file":"BaseEntity.js","names":[],"sources":["../src/BaseEntity.ts"],"sourcesContent":["import { type IdType } from \"src/Entity.ts\";\nimport {\n  type Entity,\n  type EntityManager,\n  type EntityMetadata,\n  InstanceData,\n  type TaggedId,\n  deTagId,\n  getMetadata,\n  keyToNumber,\n} from \"src/index.ts\";\n\n/**\n * Returns the internal `__data` tracking field for `entity`.\n *\n * This should be treated as an internal API and may change without notice.\n */\nexport function getInstanceData(entity: Entity): InstanceData {\n  return BaseEntity.getInstanceData(entity);\n}\n\n/**\n * The base class for all entities.\n *\n * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.\n */\nexport abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {\n  public static getInstanceData(entity: Entity): InstanceData {\n    return (entity as BaseEntity<any>).__data;\n  }\n  // We use a protected field so that subclass getters can easily access `this.__data.relations`.\n  protected readonly __data!: InstanceData;\n\n  /** The single-arg constructor is our psuedo-public API that can only be called by the EntityManager. */\n  constructor(em: EntityManager);\n  constructor(em: EntityManager, isNew?: boolean) {\n    if (isNew === undefined) {\n      throw new Error(\"Entities must be constructed by calling em.create or em.load\");\n    }\n    // This code path won't be reused for real entities, as they go through the `newEntity`\n    // construction process that lazifies the relations.\n    baseEntityCstr(em, this, isNew);\n  }\n\n  // This gives rules a way to access the fully typed object instead of their Reacted view.\n  // And we make it public so that a function that takes Reacted<...> can accept a Loaded<...>\n  // that sufficiently overlaps.\n  get fullNonReactiveAccess(): this {\n    return this;\n  }\n\n  /** @returns the entity's id, tagged/untagged based on your config, or a runtime error if it's new/unassigned. */\n  abstract id: I;\n\n  /** @returns the entity's, tagged/untagged based on your config, or undefined if it's new/unassigned. */\n  abstract get idMaybe(): I | undefined;\n\n  /** @returns the entity's id, always tagged, or a runtime error if it's new/unassigned. */\n  abstract idTagged: TaggedId;\n\n  /** @returns the entity's id, always tagged, or undefined if it's new/unassigned. */\n  abstract get idTaggedMaybe(): TaggedId | undefined;\n\n  /** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */\n  get idUntagged(): string {\n    return deTagId(getMetadata(this), this.id);\n  }\n\n  abstract set(opts: unknown): void;\n\n  /**\n   * Similar to `set` but applies \"Partial API\" semantics, i.e. `null` means unset and `undefined` means don't change.\n   */\n  abstract setPartial(opts: unknown): void;\n\n  /**\n   * Similar to `set` but applies \"Partial API\" semantics, i.e. `null` means unset and `undefined` means don't change.\n   */\n  abstract setDeepPartial(opts: unknown): Promise<void>;\n\n  /**\n   * Returns whether the entity is new.\n   *\n   * This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity\n   * is no longer new; this only flips to `false` after the `flush` transaction has been committed.\n   */\n  get isNewEntity(): boolean {\n    return this.__data.isNewEntity;\n  }\n\n  get isDeletedEntity(): boolean {\n    return this.__data.isDeletedEntity;\n  }\n\n  get isDirtyEntity(): boolean {\n    return this.__data.isDirtyEntity;\n  }\n\n  toString(): string {\n    const meta = getMetadata(this);\n    return toStringWithPrefix(meta, this, meta.type);\n  }\n\n  toTaggedString(): string {\n    const meta = getMetadata(this);\n    return toStringWithPrefix(meta, this, meta.tagName);\n  }\n\n  public get em(): EM {\n    return this.__data.em as EM;\n  }\n\n  /**\n   * A very simple toJSON that just returns the id.\n   *\n   * This is for security reasons, to avoid accidentally logging sensitive data; you\n   * can specify more fields, and potentially nested return data, by using passing\n   * a {@link JsonHint} to `toJSON`.\n   */\n  public toJSON(): object {\n    return { id: this.idMaybe || null };\n  }\n\n  [Symbol.toStringTag](): string {\n    return this.toString();\n  }\n\n  /**\n   * Hooks into node's `console.log` to avoid sprawling output of our relations/internal state.\n   *\n   * See https://nodejs.org/api/util.html#custom-inspection-functions-on-objects.\n   */\n  [Symbol.for(\"nodejs.util.inspect.custom\")](): string {\n    return this.toString();\n  }\n\n  /** A bag of non-persisted state, typically for flags that control business logic behavior. */\n  declare readonly transientFields: Record<string, unknown>;\n}\n\nfunction toStringWithPrefix(meta: EntityMetadata, entity: Entity, prefix: string): string {\n  // Start with `Author` or `a`, depending on the caller\n  let result = prefix;\n  // Add `#1` if this is an em.create-d entity\n  const data = getInstanceData(entity);\n  const createId = data.createId;\n  if (createId) {\n    result += `#${createId}`;\n  }\n  // Add the `:1` but only after our flush is complete, otherwise the id is\n  // internally assigned but not really flushed/committed to the db yet\n  const dbId = entity.idTaggedMaybe;\n  if (data.pendingOperation !== \"insert\" && dbId) {\n    // Strip the tag because we add back the entity prefix\n    result += `:${keyToNumber(meta, dbId)}`;\n  }\n  return result;\n}\n\n/**\n * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too\n * on its `Object.create`-d instances.\n */\nexport function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void {\n  const data = new InstanceData(em, entity, (entity.constructor as any).metadata, isNew);\n  // This makes it non-enumerable to avoid Jest/recursive things tripping over it\n  Object.defineProperty(entity, \"__data\", { value: data, enumerable: false, writable: false, configurable: false });\n}\n"],"mappings":";;;;;;;;;;;AAiBA,SAAgB,gBAAgB,QAA8B;CAC5D,OAAO,WAAW,gBAAgB,MAAM;AAC1C;;;;;;AAOA,IAAsB,aAAtB,MAAwG;CACtG,OAAc,gBAAgB,QAA8B;EAC1D,OAAQ,OAA2B;CACrC;CAEA;CAIA,YAAY,IAAmB,OAAiB;EAC9C,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,8DAA8D;EAIhF,eAAe,IAAI,MAAM,KAAK;CAChC;CAKA,IAAI,wBAA8B;EAChC,OAAO;CACT;;CAeA,IAAI,aAAqB;EACvB,OAAO,QAAQ,YAAY,IAAI,GAAG,KAAK,EAAE;CAC3C;;;;;;;CAoBA,IAAI,cAAuB;EACzB,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,kBAA2B;EAC7B,OAAO,KAAK,OAAO;CACrB;CAEA,IAAI,gBAAyB;EAC3B,OAAO,KAAK,OAAO;CACrB;CAEA,WAAmB;EACjB,MAAM,OAAO,YAAY,IAAI;EAC7B,OAAO,mBAAmB,MAAM,MAAM,KAAK,IAAI;CACjD;CAEA,iBAAyB;EACvB,MAAM,OAAO,YAAY,IAAI;EAC7B,OAAO,mBAAmB,MAAM,MAAM,KAAK,OAAO;CACpD;CAEA,IAAW,KAAS;EAClB,OAAO,KAAK,OAAO;CACrB;;;;;;;;CASA,SAAwB;EACtB,OAAO,EAAE,IAAI,KAAK,WAAW,KAAK;CACpC;CAEA,CAAC,OAAO,eAAuB;EAC7B,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,CAAC,OAAO,IAAI,4BAA4B,KAAa;EACnD,OAAO,KAAK,SAAS;CACvB;AAIF;AAEA,SAAS,mBAAmB,MAAsB,QAAgB,QAAwB;CAExF,IAAI,SAAS;CAEb,MAAM,OAAO,gBAAgB,MAAM;CACnC,MAAM,WAAW,KAAK;CACtB,IAAI,UACF,UAAU,IAAI;CAIhB,MAAM,OAAO,OAAO;CACpB,IAAI,KAAK,qBAAqB,YAAY,MAExC,UAAU,IAAI,YAAY,MAAM,IAAI;CAEtC,OAAO;AACT;;;;;AAMA,SAAgB,eAAe,IAAmB,QAA8B,OAAsB;CACpG,MAAM,OAAO,IAAI,aAAa,IAAI,QAAS,OAAO,YAAoB,UAAU,KAAK;CAErF,OAAO,eAAe,QAAQ,UAAU;EAAE,OAAO;EAAM,YAAY;EAAO,UAAU;EAAO,cAAc;CAAM,CAAC;AAClH"}

package/build/Entity.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.cjs","names":["BaseEntity"],"sources":["../src/Entity.ts"],"sourcesContent":["import { type EntityManager, type TaggedId } from \"./EntityManager.ts\";\nimport { BaseEntity } from \"./index.ts\";\n\nexport function isEntity(maybeEntity: unknown): maybeEntity is Entity {\n  return maybeEntity instanceof BaseEntity;\n}\n\n/** All the types we support for entity `id` fields. */\nexport type IdType = number | string;\n\n/** A marker/base interface for all of our entity types. */\nexport interface Entity {\n  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */\n  id: IdType;\n  idMaybe: IdType | undefined;\n  /** The entity id that is always tagged, regardless of the idType config. */\n  idTagged: TaggedId;\n  idTaggedMaybe: TaggedId | undefined;\n  readonly em: EntityManager;\n  readonly isNewEntity: boolean;\n  readonly isDeletedEntity: boolean;\n  readonly isDirtyEntity: boolean;\n  readonly transientFields: Record<string, unknown>;\n  set(opts: unknown): void;\n  setPartial(opts: unknown): void;\n  setDeepPartial(opts: unknown): Promise<void>;\n  /**\n   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.\n   *\n   * Once an entity is persisted, we'll return `Author#1:1` to denote \"the previously-new author #1\n   * is now authors row id=1 in the database\".\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toString(): string;\n  /**\n   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toTaggedString(): string;\n}\n"],"mappings":";;;;;AAGA,SAAgB,SAAS,aAA6C;CACpE,OAAO,uBAAuBA,mBAAAA;AAChC"}
+{"version":3,"file":"Entity.cjs","names":["BaseEntity"],"sources":["../src/Entity.ts"],"sourcesContent":["import { type EntityManager, type TaggedId } from \"src/EntityManager.ts\";\nimport { BaseEntity } from \"src/index.ts\";\n\nexport function isEntity(maybeEntity: unknown): maybeEntity is Entity {\n  return maybeEntity instanceof BaseEntity;\n}\n\n/** All the types we support for entity `id` fields. */\nexport type IdType = number | string;\n\n/** A marker/base interface for all of our entity types. */\nexport interface Entity {\n  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */\n  id: IdType;\n  idMaybe: IdType | undefined;\n  /** The entity id that is always tagged, regardless of the idType config. */\n  idTagged: TaggedId;\n  idTaggedMaybe: TaggedId | undefined;\n  readonly em: EntityManager;\n  readonly isNewEntity: boolean;\n  readonly isDeletedEntity: boolean;\n  readonly isDirtyEntity: boolean;\n  readonly transientFields: Record<string, unknown>;\n  set(opts: unknown): void;\n  setPartial(opts: unknown): void;\n  setDeepPartial(opts: unknown): Promise<void>;\n  /**\n   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.\n   *\n   * Once an entity is persisted, we'll return `Author#1:1` to denote \"the previously-new author #1\n   * is now authors row id=1 in the database\".\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toString(): string;\n  /**\n   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toTaggedString(): string;\n}\n"],"mappings":";;;;;AAGA,SAAgB,SAAS,aAA6C;CACpE,OAAO,uBAAuBA,mBAAAA;AAChC"}

package/build/Entity.js.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.js","names":[],"sources":["../src/Entity.ts"],"sourcesContent":["import { type EntityManager, type TaggedId } from \"./EntityManager.ts\";\nimport { BaseEntity } from \"./index.ts\";\n\nexport function isEntity(maybeEntity: unknown): maybeEntity is Entity {\n  return maybeEntity instanceof BaseEntity;\n}\n\n/** All the types we support for entity `id` fields. */\nexport type IdType = number | string;\n\n/** A marker/base interface for all of our entity types. */\nexport interface Entity {\n  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */\n  id: IdType;\n  idMaybe: IdType | undefined;\n  /** The entity id that is always tagged, regardless of the idType config. */\n  idTagged: TaggedId;\n  idTaggedMaybe: TaggedId | undefined;\n  readonly em: EntityManager;\n  readonly isNewEntity: boolean;\n  readonly isDeletedEntity: boolean;\n  readonly isDirtyEntity: boolean;\n  readonly transientFields: Record<string, unknown>;\n  set(opts: unknown): void;\n  setPartial(opts: unknown): void;\n  setDeepPartial(opts: unknown): Promise<void>;\n  /**\n   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.\n   *\n   * Once an entity is persisted, we'll return `Author#1:1` to denote \"the previously-new author #1\n   * is now authors row id=1 in the database\".\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toString(): string;\n  /**\n   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toTaggedString(): string;\n}\n"],"mappings":";;;;AAGA,SAAgB,SAAS,aAA6C;CACpE,OAAO,uBAAuB;AAChC"}
+{"version":3,"file":"Entity.js","names":[],"sources":["../src/Entity.ts"],"sourcesContent":["import { type EntityManager, type TaggedId } from \"src/EntityManager.ts\";\nimport { BaseEntity } from \"src/index.ts\";\n\nexport function isEntity(maybeEntity: unknown): maybeEntity is Entity {\n  return maybeEntity instanceof BaseEntity;\n}\n\n/** All the types we support for entity `id` fields. */\nexport type IdType = number | string;\n\n/** A marker/base interface for all of our entity types. */\nexport interface Entity {\n  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */\n  id: IdType;\n  idMaybe: IdType | undefined;\n  /** The entity id that is always tagged, regardless of the idType config. */\n  idTagged: TaggedId;\n  idTaggedMaybe: TaggedId | undefined;\n  readonly em: EntityManager;\n  readonly isNewEntity: boolean;\n  readonly isDeletedEntity: boolean;\n  readonly isDirtyEntity: boolean;\n  readonly transientFields: Record<string, unknown>;\n  set(opts: unknown): void;\n  setPartial(opts: unknown): void;\n  setDeepPartial(opts: unknown): Promise<void>;\n  /**\n   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.\n   *\n   * Once an entity is persisted, we'll return `Author#1:1` to denote \"the previously-new author #1\n   * is now authors row id=1 in the database\".\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toString(): string;\n  /**\n   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.\n   *\n   * This is meant to be used for developer-facing logging and debugging, and not a user-facing\n   * name / display name.\n   */\n  toTaggedString(): string;\n}\n"],"mappings":";;;;AAGA,SAAgB,SAAS,aAA6C;CACpE,OAAO,uBAAuB;AAChC"}