joist-core 2.3.0-next.10 → 2.3.0-next.100

package/build/BaseEntity.cjs

@@ -0,0 +1,112 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_keys = require("./keys.cjs");
+const require_EntityMetadata = require("./EntityMetadata.cjs");
+const require_InstanceData = require("./InstanceData.cjs");
+require("./index.cjs");
+require("./Entity.cjs");
+//#region src/BaseEntity.ts
+/**
+* Returns the internal `__data` tracking field for `entity`.
+*
+* This should be treated as an internal API and may change without notice.
+*/
+function getInstanceData(entity) {
+	return BaseEntity.getInstanceData(entity);
+}
+/**
+* The base class for all entities.
+*
+* Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.
+*/
+var BaseEntity = class {
+	static getInstanceData(entity) {
+		return entity.__data;
+	}
+	__data;
+	constructor(em, isNew) {
+		if (isNew === void 0) throw new Error("Entities must be constructed by calling em.create or em.load");
+		baseEntityCstr(em, this, isNew);
+	}
+	get fullNonReactiveAccess() {
+		return this;
+	}
+	/** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */
+	get idUntagged() {
+		return require_keys.deTagId(require_EntityMetadata.getMetadata(this), this.id);
+	}
+	/**
+	* Returns whether the entity is new.
+	*
+	* This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity
+	* is no longer new; this only flips to `false` after the `flush` transaction has been committed.
+	*/
+	get isNewEntity() {
+		return this.__data.isNewEntity;
+	}
+	get isDeletedEntity() {
+		return this.__data.isDeletedEntity;
+	}
+	get isDirtyEntity() {
+		return this.__data.isDirtyEntity;
+	}
+	toString() {
+		const meta = require_EntityMetadata.getMetadata(this);
+		return toStringWithPrefix(meta, this, meta.type);
+	}
+	toTaggedString() {
+		const meta = require_EntityMetadata.getMetadata(this);
+		return toStringWithPrefix(meta, this, meta.tagName);
+	}
+	get em() {
+		return this.__data.em;
+	}
+	/**
+	* A very simple toJSON that just returns the id.
+	*
+	* This is for security reasons, to avoid accidentally logging sensitive data; you
+	* can specify more fields, and potentially nested return data, by using passing
+	* a {@link JsonHint} to `toJSON`.
+	*/
+	toJSON() {
+		return { id: this.idMaybe || null };
+	}
+	[Symbol.toStringTag]() {
+		return this.toString();
+	}
+	/**
+	* Hooks into node's `console.log` to avoid sprawling output of our relations/internal state.
+	*
+	* See https://nodejs.org/api/util.html#custom-inspection-functions-on-objects.
+	*/
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return this.toString();
+	}
+};
+function toStringWithPrefix(meta, entity, prefix) {
+	let result = prefix;
+	const data = getInstanceData(entity);
+	const createId = data.createId;
+	if (createId) result += `#${createId}`;
+	const dbId = entity.idTaggedMaybe;
+	if (data.pendingOperation !== "insert" && dbId) result += `:${require_keys.keyToNumber(meta, dbId)}`;
+	return result;
+}
+/**
+* The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too
+* on its `Object.create`-d instances.
+*/
+function baseEntityCstr(em, entity, isNew) {
+	const data = new require_InstanceData.InstanceData(em, entity, entity.constructor.metadata, isNew);
+	Object.defineProperty(entity, "__data", {
+		value: data,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+}
+//#endregion
+exports.BaseEntity = BaseEntity;
+exports.baseEntityCstr = baseEntityCstr;
+exports.getInstanceData = getInstanceData;
+
+//# sourceMappingURL=BaseEntity.cjs.map

package/build/BaseEntity.cjs.map

@@ -0,0 +1 @@
+{"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.d.cts

@@ -0,0 +1,73 @@
+import { InstanceData } from "./InstanceData.cjs";
+import "./index.cjs";
+import { EntityManager, TaggedId } from "./EntityManager.cjs";
+import { Entity, IdType } from "./Entity.cjs";
+//#region src/BaseEntity.d.ts
+/**
+ * Returns the internal `__data` tracking field for `entity`.
+ *
+ * This should be treated as an internal API and may change without notice.
+ */
+declare function getInstanceData(entity: Entity): InstanceData;
+/**
+ * The base class for all entities.
+ *
+ * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.
+ */
+declare abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {
+  static getInstanceData(entity: Entity): InstanceData;
+  protected readonly __data: InstanceData;
+  /** The single-arg constructor is our psuedo-public API that can only be called by the EntityManager. */
+  constructor(em: EntityManager);
+  get fullNonReactiveAccess(): this;
+  /** @returns the entity's id, tagged/untagged based on your config, or a runtime error if it's new/unassigned. */
+  abstract id: I;
+  /** @returns the entity's, tagged/untagged based on your config, or undefined if it's new/unassigned. */
+  abstract get idMaybe(): I | undefined;
+  /** @returns the entity's id, always tagged, or a runtime error if it's new/unassigned. */
+  abstract idTagged: TaggedId;
+  /** @returns the entity's id, always tagged, or undefined if it's new/unassigned. */
+  abstract get idTaggedMaybe(): TaggedId | undefined;
+  /** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */
+  get idUntagged(): string;
+  abstract set(opts: unknown): void;
+  /**
+   * Similar to `set` but applies "Partial API" semantics, i.e. `null` means unset and `undefined` means don't change.
+   */
+  abstract setPartial(opts: unknown): void;
+  /**
+   * Similar to `set` but applies "Partial API" semantics, i.e. `null` means unset and `undefined` means don't change.
+   */
+  abstract setDeepPartial(opts: unknown): Promise<void>;
+  /**
+   * Returns whether the entity is new.
+   *
+   * This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity
+   * is no longer new; this only flips to `false` after the `flush` transaction has been committed.
+   */
+  get isNewEntity(): boolean;
+  get isDeletedEntity(): boolean;
+  get isDirtyEntity(): boolean;
+  toString(): string;
+  toTaggedString(): string;
+  get em(): EM;
+  /**
+   * A very simple toJSON that just returns the id.
+   *
+   * This is for security reasons, to avoid accidentally logging sensitive data; you
+   * can specify more fields, and potentially nested return data, by using passing
+   * a {@link JsonHint} to `toJSON`.
+   */
+  toJSON(): object;
+  [Symbol.toStringTag](): string;
+  /** A bag of non-persisted state, typically for flags that control business logic behavior. */
+  readonly transientFields: Record<string, unknown>;
+}
+/**
+ * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too
+ * on its `Object.create`-d instances.
+ */
+declare function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void;
+//#endregion
+export { BaseEntity, baseEntityCstr, getInstanceData };
+//# sourceMappingURL=BaseEntity.d.cts.map

package/build/BaseEntity.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseEntity.d.cts","names":[],"sources":["../src/BaseEntity.ts"],"mappings":";;;;;;;;;;iBAiBgB,gBAAgB,QAAQ,SAAS;;;;;;uBAS3B,WAAW,WAAW,eAAe,UAAU,SAAS,mBAAmB;SACjF,gBAAgB,QAAQ,SAAS;qBAI5B,QAAS;;EAG5B,YAAY,IAAI;MAaZ;;WAKK,IAAI;;eAGA,WAAW;;WAGf,UAAU;;eAGN,iBAAiB;;MAG1B;WAIK,IAAI;;;;WAKJ,WAAW;;;;WAKX,eAAe,gBAAgB;;;;;;;MAQpC;MAIA;MAIA;EAIJ;EAKA;MAKW,MAAM;;;;;;;;EAWV;GAIN,OAAO;;WAcS,iBAAiB;;;;;;iBA0BpB,eAAe,IAAI,eAAe,QAAQ,sBAAsB"}

package/build/BaseEntity.d.mts

@@ -0,0 +1,73 @@
+import { InstanceData } from "./InstanceData.mjs";
+import "./index.mjs";
+import { EntityManager, TaggedId } from "./EntityManager.mjs";
+import { Entity, IdType } from "./Entity.mjs";
+//#region src/BaseEntity.d.ts
+/**
+ * Returns the internal `__data` tracking field for `entity`.
+ *
+ * This should be treated as an internal API and may change without notice.
+ */
+declare function getInstanceData(entity: Entity): InstanceData;
+/**
+ * The base class for all entities.
+ *
+ * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.
+ */
+declare abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {
+  static getInstanceData(entity: Entity): InstanceData;
+  protected readonly __data: InstanceData;
+  /** The single-arg constructor is our psuedo-public API that can only be called by the EntityManager. */
+  constructor(em: EntityManager);
+  get fullNonReactiveAccess(): this;
+  /** @returns the entity's id, tagged/untagged based on your config, or a runtime error if it's new/unassigned. */
+  abstract id: I;
+  /** @returns the entity's, tagged/untagged based on your config, or undefined if it's new/unassigned. */
+  abstract get idMaybe(): I | undefined;
+  /** @returns the entity's id, always tagged, or a runtime error if it's new/unassigned. */
+  abstract idTagged: TaggedId;
+  /** @returns the entity's id, always tagged, or undefined if it's new/unassigned. */
+  abstract get idTaggedMaybe(): TaggedId | undefined;
+  /** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */
+  get idUntagged(): string;
+  abstract set(opts: unknown): void;
+  /**
+   * Similar to `set` but applies "Partial API" semantics, i.e. `null` means unset and `undefined` means don't change.
+   */
+  abstract setPartial(opts: unknown): void;
+  /**
+   * Similar to `set` but applies "Partial API" semantics, i.e. `null` means unset and `undefined` means don't change.
+   */
+  abstract setDeepPartial(opts: unknown): Promise<void>;
+  /**
+   * Returns whether the entity is new.
+   *
+   * This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity
+   * is no longer new; this only flips to `false` after the `flush` transaction has been committed.
+   */
+  get isNewEntity(): boolean;
+  get isDeletedEntity(): boolean;
+  get isDirtyEntity(): boolean;
+  toString(): string;
+  toTaggedString(): string;
+  get em(): EM;
+  /**
+   * A very simple toJSON that just returns the id.
+   *
+   * This is for security reasons, to avoid accidentally logging sensitive data; you
+   * can specify more fields, and potentially nested return data, by using passing
+   * a {@link JsonHint} to `toJSON`.
+   */
+  toJSON(): object;
+  [Symbol.toStringTag](): string;
+  /** A bag of non-persisted state, typically for flags that control business logic behavior. */
+  readonly transientFields: Record<string, unknown>;
+}
+/**
+ * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too
+ * on its `Object.create`-d instances.
+ */
+declare function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void;
+//#endregion
+export { BaseEntity, baseEntityCstr, getInstanceData };
+//# sourceMappingURL=BaseEntity.d.mts.map

package/build/BaseEntity.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseEntity.d.mts","names":[],"sources":["../src/BaseEntity.ts"],"mappings":";;;;;;;;;;iBAiBgB,gBAAgB,QAAQ,SAAS;;;;;;uBAS3B,WAAW,WAAW,eAAe,UAAU,SAAS,mBAAmB;SACjF,gBAAgB,QAAQ,SAAS;qBAI5B,QAAS;;EAG5B,YAAY,IAAI;MAaZ;;WAKK,IAAI;;eAGA,WAAW;;WAGf,UAAU;;eAGN,iBAAiB;;MAG1B;WAIK,IAAI;;;;WAKJ,WAAW;;;;WAKX,eAAe,gBAAgB;;;;;;;MAQpC;MAIA;MAIA;EAIJ;EAKA;MAKW,MAAM;;;;;;;;EAWV;GAIN,OAAO;;WAcS,iBAAiB;;;;;;iBA0BpB,eAAe,IAAI,eAAe,QAAQ,sBAAsB"}

package/build/BaseEntity.js

@@ -1,120 +1,109 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntity = void 0;
-exports.getInstanceData = getInstanceData;
-exports.baseEntityCstr = baseEntityCstr;
-const index_1 = require("./index");
+import { deTagId, keyToNumber } from "./keys.js";
+import { getMetadata } from "./EntityMetadata.js";
+import { InstanceData } from "./InstanceData.js";
+import "./index.js";
+import "./Entity.js";
+//#region src/BaseEntity.ts
 /**
- * Returns the internal `__data` tracking field for `entity`.
- *
- * This should be treated as an internal API and may change without notice.
- */
+* Returns the internal `__data` tracking field for `entity`.
+*
+* This should be treated as an internal API and may change without notice.
+*/
 function getInstanceData(entity) {
-    return BaseEntity.getInstanceData(entity);
+	return BaseEntity.getInstanceData(entity);
 }
 /**
- * The base class for all entities.
- *
- * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.
- */
-class BaseEntity {
-    static getInstanceData(entity) {
-        return entity.__data;
-    }
-    // We use a protected field so that subclass getters can easily access `this.__data.relations`.
-    __data;
-    constructor(em, isNew) {
-        if (isNew === undefined) {
-            throw new Error("Entities must be constructed by calling em.create or em.load");
-        }
-        // This code path won't be reused for real entities, as they go through the `newEntity`
-        // construction process that lazifies the relations.
-        baseEntityCstr(em, this, isNew);
-    }
-    // This gives rules a way to access the fully typed object instead of their Reacted view.
-    // And we make it public so that a function that takes Reacted<...> can accept a Loaded<...>
-    // that sufficiently overlaps.
-    get fullNonReactiveAccess() {
-        return this;
-    }
-    /** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */
-    get idUntagged() {
-        return (0, index_1.deTagId)((0, index_1.getMetadata)(this), this.id);
-    }
-    /**
-     * Returns whether the entity is new.
-     *
-     * This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity
-     * is no longer new; this only flips to `false` after the `flush` transaction has been committed.
-     */
-    get isNewEntity() {
-        return this.__data.isNewEntity;
-    }
-    get isDeletedEntity() {
-        return this.__data.isDeletedEntity;
-    }
-    get isDirtyEntity() {
-        return this.__data.isDirtyEntity;
-    }
-    toString() {
-        const meta = (0, index_1.getMetadata)(this);
-        return toStringWithPrefix(meta, this, meta.type);
-    }
-    toTaggedString() {
-        const meta = (0, index_1.getMetadata)(this);
-        return toStringWithPrefix(meta, this, meta.tagName);
-    }
-    get em() {
-        return this.__data.em;
-    }
-    /**
-     * A very simple toJSON that just returns the id.
-     *
-     * This is for security reasons, to avoid accidentally logging sensitive data; you
-     * can specify more fields, and potentially nested return data, by using passing
-     * a {@link JsonHint} to `toJSON`.
-     */
-    toJSON() {
-        return { id: this.idMaybe || null };
-    }
-    [Symbol.toStringTag]() {
-        return this.toString();
-    }
-    /**
-     * Hooks into node's `console.log` to avoid sprawling output of our relations/internal state.
-     *
-     * See https://nodejs.org/api/util.html#custom-inspection-functions-on-objects.
-     */
-    [Symbol.for("nodejs.util.inspect.custom")]() {
-        return this.toString();
-    }
-}
-exports.BaseEntity = BaseEntity;
+* The base class for all entities.
+*
+* Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.
+*/
+var BaseEntity = class {
+	static getInstanceData(entity) {
+		return entity.__data;
+	}
+	__data;
+	constructor(em, isNew) {
+		if (isNew === void 0) throw new Error("Entities must be constructed by calling em.create or em.load");
+		baseEntityCstr(em, this, isNew);
+	}
+	get fullNonReactiveAccess() {
+		return this;
+	}
+	/** @returns the entity's id, always untagged, or a runtime error if it's unassigned. */
+	get idUntagged() {
+		return deTagId(getMetadata(this), this.id);
+	}
+	/**
+	* Returns whether the entity is new.
+	*
+	* This is not just `this.id === undefined`, because just assigning an id doesn't mean the entity
+	* is no longer new; this only flips to `false` after the `flush` transaction has been committed.
+	*/
+	get isNewEntity() {
+		return this.__data.isNewEntity;
+	}
+	get isDeletedEntity() {
+		return this.__data.isDeletedEntity;
+	}
+	get isDirtyEntity() {
+		return this.__data.isDirtyEntity;
+	}
+	toString() {
+		const meta = getMetadata(this);
+		return toStringWithPrefix(meta, this, meta.type);
+	}
+	toTaggedString() {
+		const meta = getMetadata(this);
+		return toStringWithPrefix(meta, this, meta.tagName);
+	}
+	get em() {
+		return this.__data.em;
+	}
+	/**
+	* A very simple toJSON that just returns the id.
+	*
+	* This is for security reasons, to avoid accidentally logging sensitive data; you
+	* can specify more fields, and potentially nested return data, by using passing
+	* a {@link JsonHint} to `toJSON`.
+	*/
+	toJSON() {
+		return { id: this.idMaybe || null };
+	}
+	[Symbol.toStringTag]() {
+		return this.toString();
+	}
+	/**
+	* Hooks into node's `console.log` to avoid sprawling output of our relations/internal state.
+	*
+	* See https://nodejs.org/api/util.html#custom-inspection-functions-on-objects.
+	*/
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return this.toString();
+	}
+};
 function toStringWithPrefix(meta, entity, prefix) {
-    // Start with `Author` or `a`, depending on the caller
-    let result = prefix;
-    // Add `#1` if this is an em.create-d entity
-    const data = getInstanceData(entity);
-    const createId = data.createId;
-    if (createId) {
-        result += `#${createId}`;
-    }
-    // Add the `:1` but only after our flush is complete, otherwise the id is
-    // internally assigned but not really flushed/committed to the db yet
-    const dbId = entity.idTaggedMaybe;
-    if (data.pendingOperation !== "insert" && dbId) {
-        // Strip the tag because we add back the entity prefix
-        result += `:${(0, index_1.keyToNumber)(meta, dbId)}`;
-    }
-    return result;
+	let result = prefix;
+	const data = getInstanceData(entity);
+	const createId = data.createId;
+	if (createId) result += `#${createId}`;
+	const dbId = entity.idTaggedMaybe;
+	if (data.pendingOperation !== "insert" && dbId) result += `:${keyToNumber(meta, dbId)}`;
+	return result;
 }
 /**
- * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too
- * on its `Object.create`-d instances.
- */
+* The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too
+* on its `Object.create`-d instances.
+*/
 function baseEntityCstr(em, entity, isNew) {
-    const data = new index_1.InstanceData(em, entity, entity.constructor.metadata, isNew);
-    // This makes it non-enumerable to avoid Jest/recursive things tripping over it
-    Object.defineProperty(entity, "__data", { value: data, enumerable: false, writable: false, configurable: false });
+	const data = new InstanceData(em, entity, entity.constructor.metadata, isNew);
+	Object.defineProperty(entity, "__data", {
+		value: data,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
 }
+//#endregion
+export { BaseEntity, baseEntityCstr, getInstanceData };
+
 //# sourceMappingURL=BaseEntity.js.map

package/build/BaseEntity.js.map

@@ -1 +1 @@
-{"version":3,"file":"BaseEntity.js","sourceRoot":"","sources":["../src/BaseEntity.ts"],"names":[],"mappings":"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"}
+{"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

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./index.cjs");
+require("./EntityManager.cjs");
+const require_BaseEntity = require("./BaseEntity.cjs");
+//#region src/Entity.ts
+function isEntity(maybeEntity) {
+	return maybeEntity instanceof require_BaseEntity.BaseEntity;
+}
+//#endregion
+exports.isEntity = isEntity;
+
+//# sourceMappingURL=Entity.cjs.map

package/build/Entity.cjs.map

@@ -0,0 +1 @@
+{"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.d.cts

@@ -0,0 +1,42 @@
+import { EntityManager, TaggedId } from "./EntityManager.cjs";
+//#region src/Entity.d.ts
+declare function isEntity(maybeEntity: unknown): maybeEntity is Entity;
+/** All the types we support for entity `id` fields. */
+type IdType = number | string;
+/** A marker/base interface for all of our entity types. */
+interface Entity {
+  /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */
+  id: IdType;
+  idMaybe: IdType | undefined;
+  /** The entity id that is always tagged, regardless of the idType config. */
+  idTagged: TaggedId;
+  idTaggedMaybe: TaggedId | undefined;
+  readonly em: EntityManager;
+  readonly isNewEntity: boolean;
+  readonly isDeletedEntity: boolean;
+  readonly isDirtyEntity: boolean;
+  readonly transientFields: Record<string, unknown>;
+  set(opts: unknown): void;
+  setPartial(opts: unknown): void;
+  setDeepPartial(opts: unknown): Promise<void>;
+  /**
+   * Returns `type:id`, i.e. `Author:1` for persisted entities and `Author#1` for new entities.
+   *
+   * Once an entity is persisted, we'll return `Author#1:1` to denote "the previously-new author #1
+   * is now authors row id=1 in the database".
+   *
+   * This is meant to be used for developer-facing logging and debugging, and not a user-facing
+   * name / display name.
+   */
+  toString(): string;
+  /**
+   * Returns `tag:id`, i.e. `a:1` for persisted entities and `a#1` for new entities.
+   *
+   * This is meant to be used for developer-facing logging and debugging, and not a user-facing
+   * name / display name.
+   */
+  toTaggedString(): string;
+}
+//#endregion
+export { Entity, IdType, isEntity };
+//# sourceMappingURL=Entity.d.cts.map

package/build/Entity.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entity.d.cts","names":[],"sources":["../src/Entity.ts"],"mappings":";;iBAGgB,SAAS,uBAAuB,eAAe;;KAKnD;;UAGK;;EAEf,IAAI;EACJ,SAAS;;EAET,UAAU;EACV,eAAe;WACN,IAAI;WACJ;WACA;WACA;WACA,iBAAiB;EAC1B,IAAI;EACJ,WAAW;EACX,eAAe,gBAAgB;;;;;;;;;;EAU/B;;;;;;;EAOA"}