joist-core 2.3.0 → 2.4.0-next.10

package/build/relations/AbstractRelationImpl.js

@@ -1,19 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractRelationImpl = void 0;
-exports.isCascadeDelete = isCascadeDelete;
-const EntityMetadata_1 = require("../EntityMetadata");
-const AbstractPropertyImpl_1 = require("./AbstractPropertyImpl");
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
+//#region src/relations/AbstractRelationImpl.ts
 /**
- * Defines common hooks that relations can respond to to keep the entity graph in sync.
- */
-class AbstractRelationImpl extends AbstractPropertyImpl_1.AbstractPropertyImpl {
-    constructor(entity) {
-        super(entity);
-    }
-}
-exports.AbstractRelationImpl = AbstractRelationImpl;
-function isCascadeDelete(relation, fieldName) {
-    return (0, EntityMetadata_1.getBaseAndSelfMetas)((0, EntityMetadata_1.getMetadata)(relation.entity)).some((meta) => meta.config.__data.cascadeDeleteFields.includes(fieldName));
-}
+* Defines common hooks that relations can respond to to keep the entity graph in sync.
+*/
+var AbstractRelationImpl = class extends AbstractPropertyImpl {
+	constructor(entity) {
+		super(entity);
+	}
+};
+//#endregion
+export { AbstractRelationImpl };
+
 //# sourceMappingURL=AbstractRelationImpl.js.map

package/build/relations/AbstractRelationImpl.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRelationImpl.js","sourceRoot":"","sources":["../../src/relations/AbstractRelationImpl.ts"],"names":[],"mappings":";;;AAoDA,0CAIC;AAxDD,sDAAqE;AACrE,iEAA8D;AAE9D;;GAEG;AACH,MAAsB,oBAA2B,SAAQ,2CAAuB;IAC9E,YAAY,MAAS;QACnB,KAAK,CAAC,MAAM,CAAC,CAAC;IAChB,CAAC;CAyCF;AA5CD,oDA4CC;AAED,SAAgB,eAAe,CAAC,QAAwC,EAAE,SAAiB;IACzF,OAAO,IAAA,oCAAmB,EAAC,IAAA,4BAAW,EAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CACrE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAC,SAAgB,CAAC,CAClE,CAAC;AACJ,CAAC"}
+{"version":3,"file":"AbstractRelationImpl.js","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"sourcesContent":["import { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\n\n/**\n * Defines common hooks that relations can respond to to keep the entity graph in sync.\n */\nexport abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {\n  constructor(entity: T) {\n    super(entity);\n  }\n\n  /** Called with the opts from a `new` or `em.create` call, i.e. on a new entity. */\n  abstract setFromOpts(value: U): void;\n\n  /** Similar to setFromOpts, but called post-construction. */\n  abstract set(value: U): void;\n\n  /** Whether this relation is loaded. */\n  abstract get isLoaded(): boolean;\n\n  /** Whether this relation is preloaded. */\n  abstract get isPreloaded(): boolean;\n\n  /** Loads the other side of this relation. */\n  abstract load(opts?: { forceReload?: boolean }): Promise<any>;\n\n  /** Whether the relation from the preload cache, if preloaded. */\n  abstract preload(): void;\n\n  abstract get get(): U | undefined;\n\n  /**\n   * Called when our entity has been `em.delete`-d and then `em.flush` is being called,\n   * so we can unset any foreign keys to the being-deleted entity and clear out any pointers\n   * to it. I.e.:\n   *\n   * - `em.delete(author)`\n   * - `em.flush` loads all `author.books`\n   * - Unsets their `book.author` to let their validation rules know\n   */\n  abstract cleanupOnEntityDeleted(): Promise<void>;\n\n  /**\n   * Called to cascade deletes into the relation if it has cascade behavior enabled.  This function is called twice,\n   * once on the initial `EntityManager.delete` call in a potentially unloaded state, then again from a `beforeDelete`\n   * hook after the relation is fully loaded.\n   */\n  abstract maybeCascadeDelete(): void;\n\n  abstract get fieldName(): string;\n}\n"],"mappings":";;;;;AAKA,IAAsB,uBAAtB,cAAyD,qBAAwB;CAC/E,YAAY,QAAW;EACrB,MAAM,MAAM;CACd;AAyCF"}

package/build/relations/AsyncProperty.cjs

@@ -0,0 +1,75 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_AbstractPropertyImpl = require("./AbstractPropertyImpl.cjs");
+const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
+require("./hasProperty.cjs");
+const require_newEntity = require("../newEntity.cjs");
+require("../Entity.cjs");
+//#region src/relations/AsyncProperty.ts
+/**
+* Creates a derived value calculated from a SQL query.
+*
+* Unlike `hasProperty`, the lambda receives the entity and is expected
+* to perform its own SQL queries rather than relying on in-memory graph data.
+*
+* - For new (un-flushed) entities, `load` throws because the entity has no id yet.
+* - The result is cached until the next `em.flush`.
+*/
+function hasAsyncProperty(fn) {
+	return require_newEntity.lazyField((entity) => {
+		return new AsyncPropertyImpl(entity, fn);
+	});
+}
+var AsyncPropertyImpl = class extends require_relations_AbstractPropertyImpl.AbstractPropertyImpl {
+	fn;
+	#loadPromise;
+	#loaded = false;
+	#value;
+	constructor(entity, fn) {
+		super(entity);
+		this.fn = fn;
+	}
+	load(opts) {
+		if (this.entity.isNewEntity) throw new Error("AsyncProperty cannot be loaded on a new entity that has not been flushed yet");
+		if (opts?.forceReload) {
+			this.#loadPromise = void 0;
+			this.#loaded = false;
+		}
+		if (this.#loaded) return Promise.resolve(this.#value);
+		return this.#loadPromise ??= this.fn(this.entity).then((value) => {
+			this.#value = value;
+			this.#loaded = true;
+			return value;
+		});
+	}
+	get get() {
+		if (this.entity.isNewEntity) throw new Error("AsyncProperty cannot be accessed on a new entity that has not been flushed yet");
+		if (!this.#loaded) throw new Error("AsyncProperty has not been loaded yet");
+		return this.#value;
+	}
+	get isLoaded() {
+		if (this.entity.isNewEntity) return false;
+		return this.#loaded;
+	}
+	/** Called after em.flush to invalidate the cached value. */
+	resetAfterFlush() {
+		this.#loadPromise = void 0;
+		this.#loaded = false;
+		this.#value = void 0;
+	}
+	[require_relations_PropertySymbols.PropertyT] = void 0;
+};
+/** Type guard utility for determining if an entity field is an AsyncProperty. */
+function isAsyncProperty(maybe) {
+	return maybe instanceof AsyncPropertyImpl;
+}
+/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
+function isLoadedAsyncProperty(maybe) {
+	return isAsyncProperty(maybe) && maybe.isLoaded;
+}
+//#endregion
+exports.AsyncPropertyImpl = AsyncPropertyImpl;
+exports.hasAsyncProperty = hasAsyncProperty;
+exports.isAsyncProperty = isAsyncProperty;
+exports.isLoadedAsyncProperty = isLoadedAsyncProperty;
+
+//# sourceMappingURL=AsyncProperty.cjs.map

package/build/relations/AsyncProperty.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncProperty.cjs","names":["lazyField","AbstractPropertyImpl","#loadPromise","#loaded","#value","PropertyT"],"sources":["../../src/relations/AsyncProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"src/relations/hasProperty.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\n\nexport interface AsyncProperty<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n}\n\n/**\n * Creates a derived value calculated from a SQL query.\n *\n * Unlike `hasProperty`, the lambda receives the entity and is expected\n * to perform its own SQL queries rather than relying on in-memory graph data.\n *\n * - For new (un-flushed) entities, `load` throws because the entity has no id yet.\n * - The result is cached until the next `em.flush`.\n */\nexport function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V> {\n  return lazyField((entity: T) => {\n    return new AsyncPropertyImpl(entity, fn);\n  });\n}\n\nexport class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {\n  #loadPromise: Promise<V> | undefined;\n  #loaded = false;\n  #value: V | undefined;\n\n  constructor(\n    entity: T,\n    private fn: (entity: T) => Promise<V>,\n  ) {\n    super(entity);\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be loaded on a new entity that has not been flushed yet\");\n    }\n    if (opts?.forceReload) {\n      this.#loadPromise = undefined;\n      this.#loaded = false;\n    }\n    if (this.#loaded) {\n      return Promise.resolve(this.#value as V);\n    }\n    return (this.#loadPromise ??= this.fn(this.entity).then((value) => {\n      this.#value = value;\n      this.#loaded = true;\n      return value;\n    }));\n  }\n\n  get get(): V {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be accessed on a new entity that has not been flushed yet\");\n    }\n    if (!this.#loaded) throw new Error(\"AsyncProperty has not been loaded yet\");\n    return this.#value as V;\n  }\n\n  get isLoaded(): boolean {\n    if (this.entity.isNewEntity) return false;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value. */\n  resetAfterFlush(): void {\n    this.#loadPromise = undefined;\n    this.#loaded = false;\n    this.#value = undefined;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncProperty. */\nexport function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> {\n  return maybe instanceof AsyncPropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */\nexport function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any> {\n  return isAsyncProperty(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAsC,IAA+C;CACnG,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAI,kBAAkB,QAAQ,EAAE;CACzC,CAAC;AACH;AAEA,IAAa,oBAAb,cAA4DC,uCAAAA,qBAAuD;CAOvG;CANV;CACA,UAAU;CACV;CAEA,YACE,QACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;CAGV;CAEA,KAAK,MAA8C;EACjD,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,8EAA8E;EAEhG,IAAI,MAAM,aAAa;GACrB,KAAKC,eAAe,KAAA;GACpB,KAAKC,UAAU;EACjB;EACA,IAAI,KAAKA,SACP,OAAO,QAAQ,QAAQ,KAAKC,MAAW;EAEzC,OAAQ,KAAKF,iBAAiB,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU;GACjE,KAAKE,SAAS;GACd,KAAKD,UAAU;GACf,OAAO;EACT,CAAC;CACH;CAEA,IAAI,MAAS;EACX,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,gFAAgF;EAElG,IAAI,CAAC,KAAKA,SAAS,MAAM,IAAI,MAAM,uCAAuC;EAC1E,OAAO,KAAKC;CACd;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,OAAO,aAAa,OAAO;EACpC,OAAO,KAAKD;CACd;;CAGA,kBAAwB;EACtB,KAAKD,eAAe,KAAA;EACpB,KAAKC,UAAU;EACf,KAAKC,SAAS,KAAA;CAChB;CAEA,CAACC,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,gBAAgB,OAA8C;CAC5E,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,sBAAsB,OAAyE;CAC7G,OAAO,gBAAgB,KAAK,KAAK,MAAM;AACzC"}

package/build/relations/AsyncProperty.d.cts

@@ -0,0 +1,40 @@
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.cjs";
+import { PropertyT } from "./PropertySymbols.cjs";
+import { LoadedProperty, Property } from "./hasProperty.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/AsyncProperty.d.ts
+interface AsyncProperty<T extends Entity, V> extends Property<T, V> {
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<V>;
+}
+/**
+ * Creates a derived value calculated from a SQL query.
+ *
+ * Unlike `hasProperty`, the lambda receives the entity and is expected
+ * to perform its own SQL queries rather than relying on in-memory graph data.
+ *
+ * - For new (un-flushed) entities, `load` throws because the entity has no id yet.
+ * - The result is cached until the next `em.flush`.
+ */
+declare function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V>;
+declare class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {
+  #private;
+  private fn;
+  constructor(entity: T, fn: (entity: T) => Promise<V>);
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<V>;
+  get get(): V;
+  get isLoaded(): boolean;
+  /** Called after em.flush to invalidate the cached value. */
+  resetAfterFlush(): void;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is an AsyncProperty. */
+declare function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any>;
+/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
+declare function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any>;
+//#endregion
+export { AsyncProperty, AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty };
+//# sourceMappingURL=AsyncProperty.d.cts.map

package/build/relations/AsyncProperty.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncProperty.d.cts","names":[],"sources":["../../src/relations/AsyncProperty.ts"],"mappings":";;;;;UAMiB,cAAc,UAAU,QAAQ,WAAW,SAAS,GAAG;EACtE,KAAK;IAAS;MAA0B,QAAQ;;;;;;;;;;;iBAYlC,iBAAiB,UAAU,QAAQ,GAAG,KAAK,QAAQ,MAAM,QAAQ,KAAK,SAAS,GAAG;cAMrF,kBAAkB,UAAU,QAAQ,WAAW,qBAAqB,cAAc,cAAc,GAAG;;UAOpG;EAFV,YACE,QAAQ,GACA,KAAK,QAAQ,MAAM,QAAQ;EAKrC,KAAK;IAAS;MAA0B,QAAQ;MAkB5C,OAAO;MAQP;;EAMJ;GAMC,YAAiC;;;iBAIpB,gBAAgB,aAAa,SAAS;;iBAKtC,sBAAsB,aAAa,SAAS,0BAA0B"}

package/build/relations/AsyncProperty.d.mts

@@ -0,0 +1,40 @@
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.mjs";
+import { PropertyT } from "./PropertySymbols.mjs";
+import { LoadedProperty, Property } from "./hasProperty.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/AsyncProperty.d.ts
+interface AsyncProperty<T extends Entity, V> extends Property<T, V> {
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<V>;
+}
+/**
+ * Creates a derived value calculated from a SQL query.
+ *
+ * Unlike `hasProperty`, the lambda receives the entity and is expected
+ * to perform its own SQL queries rather than relying on in-memory graph data.
+ *
+ * - For new (un-flushed) entities, `load` throws because the entity has no id yet.
+ * - The result is cached until the next `em.flush`.
+ */
+declare function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V>;
+declare class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {
+  #private;
+  private fn;
+  constructor(entity: T, fn: (entity: T) => Promise<V>);
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<V>;
+  get get(): V;
+  get isLoaded(): boolean;
+  /** Called after em.flush to invalidate the cached value. */
+  resetAfterFlush(): void;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is an AsyncProperty. */
+declare function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any>;
+/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
+declare function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any>;
+//#endregion
+export { AsyncProperty, AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty };
+//# sourceMappingURL=AsyncProperty.d.mts.map

package/build/relations/AsyncProperty.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncProperty.d.mts","names":[],"sources":["../../src/relations/AsyncProperty.ts"],"mappings":";;;;;UAMiB,cAAc,UAAU,QAAQ,WAAW,SAAS,GAAG;EACtE,KAAK;IAAS;MAA0B,QAAQ;;;;;;;;;;;iBAYlC,iBAAiB,UAAU,QAAQ,GAAG,KAAK,QAAQ,MAAM,QAAQ,KAAK,SAAS,GAAG;cAMrF,kBAAkB,UAAU,QAAQ,WAAW,qBAAqB,cAAc,cAAc,GAAG;;UAOpG;EAFV,YACE,QAAQ,GACA,KAAK,QAAQ,MAAM,QAAQ;EAKrC,KAAK;IAAS;MAA0B,QAAQ;MAkB5C,OAAO;MAQP;;EAMJ;GAMC,YAAiC;;;iBAIpB,gBAAgB,aAAa,SAAS;;iBAKtC,sBAAsB,aAAa,SAAS,0BAA0B"}

package/build/relations/AsyncProperty.js

@@ -1,80 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncPropertyImpl = void 0;
-exports.hasAsyncProperty = hasAsyncProperty;
-exports.isAsyncProperty = isAsyncProperty;
-exports.isLoadedAsyncProperty = isLoadedAsyncProperty;
-const newEntity_1 = require("../newEntity");
-const AbstractPropertyImpl_1 = require("./AbstractPropertyImpl");
-const hasProperty_1 = require("./hasProperty");
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
+import { PropertyT } from "./PropertySymbols.js";
+import "./hasProperty.js";
+import { lazyField } from "../newEntity.js";
+import "../Entity.js";
+//#region src/relations/AsyncProperty.ts
 /**
- * Creates a derived value calculated from a SQL query.
- *
- * Unlike `hasProperty`, the lambda receives the entity and is expected
- * to perform its own SQL queries rather than relying on in-memory graph data.
- *
- * - For new (un-flushed) entities, `load` throws because the entity has no id yet.
- * - The result is cached until the next `em.flush`.
- */
+* Creates a derived value calculated from a SQL query.
+*
+* Unlike `hasProperty`, the lambda receives the entity and is expected
+* to perform its own SQL queries rather than relying on in-memory graph data.
+*
+* - For new (un-flushed) entities, `load` throws because the entity has no id yet.
+* - The result is cached until the next `em.flush`.
+*/
 function hasAsyncProperty(fn) {
-    return (0, newEntity_1.lazyField)((entity) => {
-        return new AsyncPropertyImpl(entity, fn);
-    });
+	return lazyField((entity) => {
+		return new AsyncPropertyImpl(entity, fn);
+	});
 }
-class AsyncPropertyImpl extends AbstractPropertyImpl_1.AbstractPropertyImpl {
-    fn;
-    #loadPromise;
-    #loaded = false;
-    #value;
-    constructor(entity, fn) {
-        super(entity);
-        this.fn = fn;
-    }
-    load(opts) {
-        if (this.entity.isNewEntity) {
-            throw new Error("AsyncProperty cannot be loaded on a new entity that has not been flushed yet");
-        }
-        if (opts?.forceReload) {
-            this.#loadPromise = undefined;
-            this.#loaded = false;
-        }
-        if (this.#loaded) {
-            return Promise.resolve(this.#value);
-        }
-        return (this.#loadPromise ??= this.fn(this.entity).then((value) => {
-            this.#value = value;
-            this.#loaded = true;
-            return value;
-        }));
-    }
-    get get() {
-        if (this.entity.isNewEntity) {
-            throw new Error("AsyncProperty cannot be accessed on a new entity that has not been flushed yet");
-        }
-        if (!this.#loaded)
-            throw new Error("AsyncProperty has not been loaded yet");
-        return this.#value;
-    }
-    get isLoaded() {
-        if (this.entity.isNewEntity)
-            return false;
-        return this.#loaded;
-    }
-    /** Called after em.flush to invalidate the cached value. */
-    resetAfterFlush() {
-        this.#loadPromise = undefined;
-        this.#loaded = false;
-        this.#value = undefined;
-    }
-    [hasProperty_1.PropertyT] = undefined;
-}
-exports.AsyncPropertyImpl = AsyncPropertyImpl;
+var AsyncPropertyImpl = class extends AbstractPropertyImpl {
+	fn;
+	#loadPromise;
+	#loaded = false;
+	#value;
+	constructor(entity, fn) {
+		super(entity);
+		this.fn = fn;
+	}
+	load(opts) {
+		if (this.entity.isNewEntity) throw new Error("AsyncProperty cannot be loaded on a new entity that has not been flushed yet");
+		if (opts?.forceReload) {
+			this.#loadPromise = void 0;
+			this.#loaded = false;
+		}
+		if (this.#loaded) return Promise.resolve(this.#value);
+		return this.#loadPromise ??= this.fn(this.entity).then((value) => {
+			this.#value = value;
+			this.#loaded = true;
+			return value;
+		});
+	}
+	get get() {
+		if (this.entity.isNewEntity) throw new Error("AsyncProperty cannot be accessed on a new entity that has not been flushed yet");
+		if (!this.#loaded) throw new Error("AsyncProperty has not been loaded yet");
+		return this.#value;
+	}
+	get isLoaded() {
+		if (this.entity.isNewEntity) return false;
+		return this.#loaded;
+	}
+	/** Called after em.flush to invalidate the cached value. */
+	resetAfterFlush() {
+		this.#loadPromise = void 0;
+		this.#loaded = false;
+		this.#value = void 0;
+	}
+	[PropertyT] = void 0;
+};
 /** Type guard utility for determining if an entity field is an AsyncProperty. */
 function isAsyncProperty(maybe) {
-    return maybe instanceof AsyncPropertyImpl;
+	return maybe instanceof AsyncPropertyImpl;
 }
 /** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
 function isLoadedAsyncProperty(maybe) {
-    return isAsyncProperty(maybe) && maybe.isLoaded;
+	return isAsyncProperty(maybe) && maybe.isLoaded;
 }
+//#endregion
+export { AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty };
+
 //# sourceMappingURL=AsyncProperty.js.map

package/build/relations/AsyncProperty.js.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncProperty.js","sourceRoot":"","sources":["../../src/relations/AsyncProperty.ts"],"names":[],"mappings":";;;AAkBA,4CAMC;AA2DD,0CAEC;AAGD,sDAEC;AAzFD,4CAAyC;AACzC,iEAA8D;AAC9D,+CAAoD;AAMpD;;;;;;;;GAQG;AACH,SAAgB,gBAAgB,CAC9B,EAA6B;IAE7B,OAAO,IAAA,qBAAS,EAAC,CAAC,MAAS,EAAE,EAAE;QAC7B,OAAO,IAAI,iBAAiB,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAa,iBACX,SAAQ,2CAAuB;IASrB;IANV,YAAY,CAAyB;IACrC,OAAO,GAAG,KAAK,CAAC;IAChB,MAAM,CAAgB;IAEtB,YACE,MAAS,EACD,EAA6B;QAErC,KAAK,CAAC,MAAM,CAAC,CAAC;QAFN,OAAE,GAAF,EAAE,CAA2B;IAGvC,CAAC;IAED,IAAI,CAAC,IAAgC;QACnC,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,8EAA8E,CAAC,CAAC;QAClG,CAAC;QACD,IAAI,IAAI,EAAE,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;YAC9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,MAAW,CAAC,CAAC;QAC3C,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;YAChE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAED,IAAI,GAAG;QACL,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;QACpG,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC,MAAW,CAAC;IAC1B,CAAC;IAED,IAAI,QAAQ;QACV,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW;YAAE,OAAO,KAAK,CAAC;QAC1C,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,4DAA4D;IAC5D,eAAe;QACb,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;IAC1B,CAAC;IAED,CAAC,uBAAS,CAAC,GAAG,SAAqB,CAAC;CACrC;AAtDD,8CAsDC;AAED,iFAAiF;AACjF,SAAgB,eAAe,CAAC,KAAU;IACxC,OAAO,KAAK,YAAY,iBAAiB,CAAC;AAC5C,CAAC;AAED,uFAAuF;AACvF,SAAgB,qBAAqB,CAAC,KAAU;IAC9C,OAAO,eAAe,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC;AAClD,CAAC"}
+{"version":3,"file":"AsyncProperty.js","names":["#loadPromise","#loaded","#value"],"sources":["../../src/relations/AsyncProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"src/relations/hasProperty.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\n\nexport interface AsyncProperty<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n}\n\n/**\n * Creates a derived value calculated from a SQL query.\n *\n * Unlike `hasProperty`, the lambda receives the entity and is expected\n * to perform its own SQL queries rather than relying on in-memory graph data.\n *\n * - For new (un-flushed) entities, `load` throws because the entity has no id yet.\n * - The result is cached until the next `em.flush`.\n */\nexport function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V> {\n  return lazyField((entity: T) => {\n    return new AsyncPropertyImpl(entity, fn);\n  });\n}\n\nexport class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {\n  #loadPromise: Promise<V> | undefined;\n  #loaded = false;\n  #value: V | undefined;\n\n  constructor(\n    entity: T,\n    private fn: (entity: T) => Promise<V>,\n  ) {\n    super(entity);\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be loaded on a new entity that has not been flushed yet\");\n    }\n    if (opts?.forceReload) {\n      this.#loadPromise = undefined;\n      this.#loaded = false;\n    }\n    if (this.#loaded) {\n      return Promise.resolve(this.#value as V);\n    }\n    return (this.#loadPromise ??= this.fn(this.entity).then((value) => {\n      this.#value = value;\n      this.#loaded = true;\n      return value;\n    }));\n  }\n\n  get get(): V {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be accessed on a new entity that has not been flushed yet\");\n    }\n    if (!this.#loaded) throw new Error(\"AsyncProperty has not been loaded yet\");\n    return this.#value as V;\n  }\n\n  get isLoaded(): boolean {\n    if (this.entity.isNewEntity) return false;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value. */\n  resetAfterFlush(): void {\n    this.#loadPromise = undefined;\n    this.#loaded = false;\n    this.#value = undefined;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncProperty. */\nexport function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> {\n  return maybe instanceof AsyncPropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */\nexport function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any> {\n  return isAsyncProperty(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAsC,IAA+C;CACnG,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,kBAAkB,QAAQ,EAAE;CACzC,CAAC;AACH;AAEA,IAAa,oBAAb,cAA4D,qBAAuD;CAOvG;CANV;CACA,UAAU;CACV;CAEA,YACE,QACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;CAGV;CAEA,KAAK,MAA8C;EACjD,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,8EAA8E;EAEhG,IAAI,MAAM,aAAa;GACrB,KAAKA,eAAe,KAAA;GACpB,KAAKC,UAAU;EACjB;EACA,IAAI,KAAKA,SACP,OAAO,QAAQ,QAAQ,KAAKC,MAAW;EAEzC,OAAQ,KAAKF,iBAAiB,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU;GACjE,KAAKE,SAAS;GACd,KAAKD,UAAU;GACf,OAAO;EACT,CAAC;CACH;CAEA,IAAI,MAAS;EACX,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,gFAAgF;EAElG,IAAI,CAAC,KAAKA,SAAS,MAAM,IAAI,MAAM,uCAAuC;EAC1E,OAAO,KAAKC;CACd;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,OAAO,aAAa,OAAO;EACpC,OAAO,KAAKD;CACd;;CAGA,kBAAwB;EACtB,KAAKD,eAAe,KAAA;EACpB,KAAKC,UAAU;EACf,KAAKC,SAAS,KAAA;CAChB;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,gBAAgB,OAA8C;CAC5E,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,sBAAsB,OAAyE;CAC7G,OAAO,gBAAgB,KAAK,KAAK,MAAM;AACzC"}

package/build/relations/AsyncReactiveField.cjs

@@ -0,0 +1,110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_AbstractPropertyImpl = require("./AbstractPropertyImpl.cjs");
+const require_normalizeHints = require("../normalizeHints.cjs");
+const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
+const require_fields = require("../fields.cjs");
+const require_utils = require("../utils.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+require("../index.cjs");
+require("../Entity.cjs");
+//#region src/relations/AsyncReactiveField.ts
+/**
+* An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
+* a `ReactiveField`, but when the value needs to be calculated from SQL because
+* it would be too expensive to calculate in-memory.
+*
+* Its hint is split in two: the `loadHint` names data that is both reacted-to *and*
+* loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is
+* only reacted-to (its changes recompute the value) but is left in the database rather
+* than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
+* changes, but only the `loadHint`'s data is populated.
+*/
+function hasAsyncReactiveField(loadHint, reactiveHint, fn) {
+	return require_newEntity.lazyField((entity, fieldName) => {
+		return new AsyncReactiveFieldImpl(entity, fieldName, loadHint, reactiveHint, fn);
+	});
+}
+var AsyncReactiveFieldImpl = class extends require_relations_AbstractPropertyImpl.AbstractPropertyImpl {
+	fieldName;
+	fn;
+	#loadHint;
+	#reactiveHint;
+	#loadPromise;
+	#loaded;
+	#useFactoryValue = false;
+	constructor(entity, fieldName, loadHint, reactiveHint, fn) {
+		super(entity);
+		this.fieldName = fieldName;
+		this.fn = fn;
+		this.#loadHint = loadHint;
+		this.#reactiveHint = reactiveHint;
+		this.#loaded = false;
+	}
+	/**
+	* Our combined load + reactive-only hint, so that we react to changes within both.
+	*
+	* The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`
+	* half only triggers recalculation, so its data stays in the database.
+	*/
+	get reactiveHint() {
+		const hint = require_normalizeHints.deepNormalizeHint(this.#loadHint);
+		require_utils.mergeNormalizedHints(hint, require_normalizeHints.deepNormalizeHint(this.#reactiveHint));
+		return hint;
+	}
+	load(opts) {
+		return this.#loadPromise ??= this.entity.em.populate(this.entity, { hint: this.loadHint }).then(() => {
+			return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity);
+		}).then((newValue) => {
+			require_fields.setField(this.entity, this.fieldName, newValue);
+			this.#loadPromise = void 0;
+			this.#loaded = true;
+			return newValue;
+		}).catch((e) => {
+			this.#loadPromise = void 0;
+			throw e;
+		});
+	}
+	/** Returns the previously-calculated value. */
+	get get() {
+		if (this.isSet) return this.fieldValue;
+		else throw new Error(`${this.fieldName} has not been derived yet`);
+	}
+	get fieldValue() {
+		return require_fields.getField(this.entity, this.fieldName);
+	}
+	get isSet() {
+		return require_fields.isFieldSet(this.entity, this.fieldName);
+	}
+	get isLoaded() {
+		const hintLoaded = require_loading_loadHints.isLoaded(this.entity, this.loadHint);
+		if (hintLoaded) this.#loaded = true;
+		return hintLoaded;
+	}
+	get loadHint() {
+		const meta = require_EntityMetadata.getMetadata(this.entity);
+		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= require_reactivity_reactiveHints.convertToLoadHint(meta, this.#loadHint);
+	}
+	setFactoryValue(newValue) {
+		this.#useFactoryValue = true;
+		require_fields.setField(this.entity, this.fieldName, newValue);
+	}
+	[require_relations_PropertySymbols.PropertyT] = void 0;
+};
+/** Type guard utility for determining if an entity field is an AsyncReactiveField. */
+function isAsyncReactiveField(maybe) {
+	return maybe instanceof AsyncReactiveFieldImpl;
+}
+/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
+function isLoadedAsyncReactiveField(maybe) {
+	return isAsyncReactiveField(maybe) && maybe.isLoaded;
+}
+//#endregion
+exports.AsyncReactiveFieldImpl = AsyncReactiveFieldImpl;
+exports.hasAsyncReactiveField = hasAsyncReactiveField;
+exports.isAsyncReactiveField = isAsyncReactiveField;
+exports.isLoadedAsyncReactiveField = isLoadedAsyncReactiveField;
+
+//# sourceMappingURL=AsyncReactiveField.cjs.map

package/build/relations/AsyncReactiveField.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncReactiveField.cjs","names":["lazyField","AbstractPropertyImpl","#loadHint","#reactiveHint","#loaded","deepNormalizeHint","#loadPromise","#useFactoryValue","getField","isFieldSet","isLoaded","getMetadata","convertToLoadHint","PropertyT"],"sources":["../../src/relations/AsyncReactiveField.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"src/fields.ts\";\nimport { type ReactiveField, deepNormalizeHint, isLoaded } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { mergeNormalizedHints } from \"src/utils.ts\";\n\n/**\n * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to\n * a `ReactiveField`, but when the value needs to be calculated from SQL because\n * it would be too expensive to calculate in-memory.\n *\n * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*\n * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is\n * only reacted-to (its changes recompute the value) but is left in the database rather\n * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint\n * changes, but only the `loadHint`'s data is populated.\n */\nexport function hasAsyncReactiveField<\n  T extends Entity,\n  const H1 extends ReactiveHint<T>,\n  const H2 extends ReactiveHint<T>,\n  V,\n>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new AsyncReactiveFieldImpl(entity, fieldName as keyof T & string, loadHint, reactiveHint, fn);\n  });\n}\n\nexport class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>\n{\n  readonly #loadHint: H1;\n  readonly #reactiveHint: H2;\n  #loadPromise: any;\n  #loaded: boolean;\n  #useFactoryValue = false;\n\n  constructor(\n    entity: T,\n    public fieldName: keyof T & string,\n    loadHint: H1,\n    reactiveHint: H2,\n    private fn: (entity: Reacted<T, H1>) => Promise<V>,\n  ) {\n    super(entity);\n    this.#loadHint = loadHint;\n    this.#reactiveHint = reactiveHint;\n    this.#loaded = false;\n  }\n\n  /**\n   * Our combined load + reactive-only hint, so that we react to changes within both.\n   *\n   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`\n   * half only triggers recalculation, so its data stays in the database.\n   */\n  get reactiveHint(): ReactiveHint<any> {\n    // We do this in a getter (instead of the constructor) b/c it might be a little expensive,\n    // and I'm pretty sure this is only called on boot, when hooking up the reactivity.\n    const hint = deepNormalizeHint(this.#loadHint);\n    mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));\n    return hint;\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    // if (!this.isSet || opts?.forceReload) {\n    return (this.#loadPromise ??= this.entity.em\n      .populate(this.entity, { hint: this.loadHint } as any)\n      .then(() => {\n        // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value\n        return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity as Reacted<T, H1>);\n      })\n      .then((newValue) => {\n        setField(this.entity, this.fieldName, newValue);\n        this.#loadPromise = undefined;\n        this.#loaded = true;\n        return newValue;\n      })\n      .catch((e) => {\n        // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make\n        // sure that the next `.load` call tries again.\n        this.#loadPromise = undefined;\n        throw e;\n      }));\n    // }\n    // return tryResolve(() => this.get);\n  }\n\n  /** Returns the previously-calculated value. */\n  get get(): V {\n    // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure\n    // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally\n    // calculated from DB queries, we can only return the previously-calculated value, if set.\n    if (this.isSet) {\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    const hintLoaded = isLoaded(this.entity, this.loadHint);\n    if (hintLoaded) {\n      this.#loaded = true;\n    }\n    return hintLoaded;\n  }\n\n  get loadHint(): any {\n    // Only convert the loadHint, so we don't pull the reactiveHint-referenced data into memory\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    this.#useFactoryValue = true;\n    setField(this.entity, this.fieldName, newValue);\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncReactiveField. */\nexport function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return maybe instanceof AsyncReactiveFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */\nexport function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return isAsyncReactiveField(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,sBAKd,UAAc,cAAkB,IAAiE;CACjG,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,uBAAuB,QAAQ,WAA+B,UAAU,cAAc,EAAE;CACrG,CAAC;AACH;AAEA,IAAa,yBAAb,cACUC,uCAAAA,qBAEV;CASW;CAGC;CAXV;CACA;CACA;CACA;CACA,mBAAmB;CAEnB,YACE,QACA,WACA,UACA,cACA,IACA;EACA,MAAM,MAAM;EALL,KAAA,YAAA;EAGC,KAAA,KAAA;EAGR,KAAKC,YAAY;EACjB,KAAKC,gBAAgB;EACrB,KAAKC,UAAU;CACjB;;;;;;;CAQA,IAAI,eAAkC;EAGpC,MAAM,OAAOC,uBAAAA,kBAAkB,KAAKH,SAAS;EAC7C,cAAA,qBAAqB,MAAMG,uBAAAA,kBAAkB,KAAKF,aAAa,CAAC;EAChE,OAAO;CACT;CAEA,KAAK,MAA8C;EAEjD,OAAQ,KAAKG,iBAAiB,KAAK,OAAO,GACvC,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CACrD,WAAW;GAEV,OAAO,KAAKC,mBAAmB,KAAK,aAAa,KAAK,GAAG,KAAK,MAAwB;EACxF,CAAC,CAAC,CACD,MAAM,aAAa;GAClB,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;GAC9C,KAAKD,eAAe,KAAA;GACpB,KAAKF,UAAU;GACf,OAAO;EACT,CAAC,CAAC,CACD,OAAO,MAAM;GAGZ,KAAKE,eAAe,KAAA;GACpB,MAAM;EACR,CAAC;CAGL;;CAGA,IAAI,MAAS;EAIX,IAAI,KAAK,OACP,OAAO,KAAK;OAEZ,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,aAAgB;EAClB,OAAOE,eAAAA,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAOC,eAAAA,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EACb,MAAM,aAAaC,0BAAAA,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACtD,IAAI,YACF,KAAKN,UAAU;EAEjB,OAAO;CACT;CAEA,IAAI,WAAgB;EAElB,MAAM,OAAOO,uBAAAA,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAeC,iCAAAA,kBAAkB,MAAM,KAAKV,SAAS;CAC/G;CAEA,gBAAgB,UAAqB;EACnC,KAAKK,mBAAmB;EACxB,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;CAChD;CAEA,CAACM,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,qBAAqB,OAA8C;CACjF,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,2BAA2B,OAA8C;CACvF,OAAO,qBAAqB,KAAK,KAAK,MAAM;AAC9C"}

package/build/relations/AsyncReactiveField.d.cts

@@ -0,0 +1,50 @@
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.cjs";
+import { PropertyT } from "./PropertySymbols.cjs";
+import { ReactiveField } from "./ReactiveField.cjs";
+import { Reacted, ReactiveHint } from "../reactivity/reactiveHints.cjs";
+import "../index.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/AsyncReactiveField.d.ts
+/**
+ * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
+ * a `ReactiveField`, but when the value needs to be calculated from SQL because
+ * it would be too expensive to calculate in-memory.
+ *
+ * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*
+ * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is
+ * only reacted-to (its changes recompute the value) but is left in the database rather
+ * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
+ * changes, but only the `loadHint`'s data is populated.
+ */
+declare function hasAsyncReactiveField<T extends Entity, const H1 extends ReactiveHint<T>, const H2 extends ReactiveHint<T>, V>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V>;
+declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V> extends AbstractPropertyImpl<T> implements ReactiveField<T, V> {
+  #private;
+  fieldName: keyof T & string;
+  private fn;
+  constructor(entity: T, fieldName: keyof T & string, loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>);
+  /**
+   * Our combined load + reactive-only hint, so that we react to changes within both.
+   *
+   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`
+   * half only triggers recalculation, so its data stays in the database.
+   */
+  get reactiveHint(): ReactiveHint<any>;
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<V>;
+  /** Returns the previously-calculated value. */
+  get get(): V;
+  get fieldValue(): V;
+  get isSet(): boolean;
+  get isLoaded(): boolean;
+  get loadHint(): any;
+  setFactoryValue(newValue: any): void;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is an AsyncReactiveField. */
+declare function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
+declare function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+//#endregion
+export { AsyncReactiveFieldImpl, hasAsyncReactiveField, isAsyncReactiveField, isLoadedAsyncReactiveField };
+//# sourceMappingURL=AsyncReactiveField.d.cts.map

package/build/relations/AsyncReactiveField.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncReactiveField.d.cts","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAqBgB,sBACd,UAAU,cACJ,WAAW,aAAa,UACxB,WAAW,aAAa,IAC9B,GACA,UAAU,IAAI,cAAc,IAAI,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,KAAK,cAAc,GAAG;cAMnF,uBAAuB,UAAU,QAAQ,WAAW,aAAa,IAAI,WAAW,aAAa,IAAI,WACpG,qBAAqB,cAClB,cAAc,GAAG;;EAUnB,iBAAiB;UAGhB;EALV,YACE,QAAQ,GACD,iBAAiB,YACxB,UAAU,IACV,cAAc,IACN,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ;;;;;;;MAc9C,gBAAgB;EAQpB,KAAK;IAAS;MAA0B,QAAQ;;MAyB5C,OAAO;MAWP,cAAc;MAId;MAIA;MAQA;EAMJ,gBAAgB;GAKf,YAAiC;;;iBAIpB,qBAAqB,aAAa,SAAS;;iBAK3C,2BAA2B,aAAa,SAAS"}

package/build/relations/AsyncReactiveField.d.mts

@@ -0,0 +1,50 @@
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.mjs";
+import { PropertyT } from "./PropertySymbols.mjs";
+import { ReactiveField } from "./ReactiveField.mjs";
+import { Reacted, ReactiveHint } from "../reactivity/reactiveHints.mjs";
+import "../index.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/AsyncReactiveField.d.ts
+/**
+ * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
+ * a `ReactiveField`, but when the value needs to be calculated from SQL because
+ * it would be too expensive to calculate in-memory.
+ *
+ * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*
+ * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is
+ * only reacted-to (its changes recompute the value) but is left in the database rather
+ * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
+ * changes, but only the `loadHint`'s data is populated.
+ */
+declare function hasAsyncReactiveField<T extends Entity, const H1 extends ReactiveHint<T>, const H2 extends ReactiveHint<T>, V>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V>;
+declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V> extends AbstractPropertyImpl<T> implements ReactiveField<T, V> {
+  #private;
+  fieldName: keyof T & string;
+  private fn;
+  constructor(entity: T, fieldName: keyof T & string, loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>);
+  /**
+   * Our combined load + reactive-only hint, so that we react to changes within both.
+   *
+   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`
+   * half only triggers recalculation, so its data stays in the database.
+   */
+  get reactiveHint(): ReactiveHint<any>;
+  load(opts?: {
+    forceReload?: boolean;
+  }): Promise<V>;
+  /** Returns the previously-calculated value. */
+  get get(): V;
+  get fieldValue(): V;
+  get isSet(): boolean;
+  get isLoaded(): boolean;
+  get loadHint(): any;
+  setFactoryValue(newValue: any): void;
+  [PropertyT]: T;
+}
+/** Type guard utility for determining if an entity field is an AsyncReactiveField. */
+declare function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
+declare function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+//#endregion
+export { AsyncReactiveFieldImpl, hasAsyncReactiveField, isAsyncReactiveField, isLoadedAsyncReactiveField };
+//# sourceMappingURL=AsyncReactiveField.d.mts.map

package/build/relations/AsyncReactiveField.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncReactiveField.d.mts","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAqBgB,sBACd,UAAU,cACJ,WAAW,aAAa,UACxB,WAAW,aAAa,IAC9B,GACA,UAAU,IAAI,cAAc,IAAI,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,KAAK,cAAc,GAAG;cAMnF,uBAAuB,UAAU,QAAQ,WAAW,aAAa,IAAI,WAAW,aAAa,IAAI,WACpG,qBAAqB,cAClB,cAAc,GAAG;;EAUnB,iBAAiB;UAGhB;EALV,YACE,QAAQ,GACD,iBAAiB,YACxB,UAAU,IACV,cAAc,IACN,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ;;;;;;;MAc9C,gBAAgB;EAQpB,KAAK;IAAS;MAA0B,QAAQ;;MAyB5C,OAAO;MAWP,cAAc;MAId;MAIA;MAQA;EAMJ,gBAAgB;GAKf,YAAiC;;;iBAIpB,qBAAqB,aAAa,SAAS;;iBAK3C,2BAA2B,aAAa,SAAS"}