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

package/build/relations/hasOneDerived.js

@@ -1,7 +1,7 @@
+import { CustomReference } from "./CustomReference.js";
+import { isLoaded } from "../loading/loadHints.js";
 import "./Reference.js";
-import { isLoaded } from "../loadHints.js";
 import { lazyField } from "../newEntity.js";
-import { CustomReference } from "./CustomReference.js";
 import "../index.js";
 import "../Entity.js";
 //#region src/relations/hasOneDerived.ts

package/build/relations/hasOneDerived.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasOneDerived.js","names":[],"sources":["../../src/relations/hasOneDerived.ts"],"sourcesContent":["import { isLoaded } from \"..//index.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type LoadHint, type Loaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { CustomReference } from \"./CustomReference.ts\";\nimport { type Reference } from \"./Reference.ts\";\n\n/**\n * Creates a CustomReference that can conditionally walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneDerived<\n  T extends Entity,\n  U extends Entity,\n  N extends never | undefined,\n  V extends U | N,\n  const H extends LoadHint<T>,\n>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => entity.em.populate(entity, { hint: loadHint, ...opts }),\n      get: () => get(entity as Loaded<T, H>),\n      isLoaded: () => isLoaded(entity, loadHint as LoadHint<T>),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,cAMd,UAAa,KAAsD;CACnE,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAAS,OAAO,GAAG,SAAS,QAAQ;IAAE,MAAM;IAAU,GAAG;GAAK,CAAC;GAC9E,WAAW,IAAI,MAAsB;GACrC,gBAAgB,SAAS,QAAQ,QAAuB;GACxD;EACF,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasOneDerived.js","names":[],"sources":["../../src/relations/hasOneDerived.ts"],"sourcesContent":["import { isLoaded } from \"..//index.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport type { LoadHint, Loaded } from \"../loading/loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { CustomReference } from \"./CustomReference.ts\";\nimport { type Reference } from \"./Reference.ts\";\n\n/**\n * Creates a CustomReference that can conditionally walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneDerived<\n  T extends Entity,\n  U extends Entity,\n  N extends never | undefined,\n  V extends U | N,\n  const H extends LoadHint<T>,\n>(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => entity.em.populate(entity, { hint: loadHint, ...opts }),\n      get: () => get(entity as Loaded<T, H>),\n      isLoaded: () => isLoaded(entity, loadHint as LoadHint<T>),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,cAMd,UAAa,KAAsD;CACnE,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAAS,OAAO,GAAG,SAAS,QAAQ;IAAE,MAAM;IAAU,GAAG;GAAK,CAAC;GAC9E,WAAW,IAAI,MAAsB;GACrC,gBAAgB,SAAS,QAAQ,QAAuB;GACxD;EACF,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasOneThrough.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
 const require_relations_CustomReference = require("./CustomReference.cjs");
+const require_newEntity = require("../newEntity.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
-const require_loadLens = require("../loadLens.cjs");
+const require_loading_loadLens = require("../loading/loadLens.cjs");
 require("../index.cjs");
 //#region src/relations/hasOneThrough.ts
 /**
@@ -13,14 +13,14 @@ require("../index.cjs");
 * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, "author")`.
 */
 function hasOneThrough(lens) {
-	const paths = require_loadLens.lensToPath(lens);
-	const loadHint = require_loadLens.lensPathToLoadHint(paths);
+	const paths = require_loading_loadLens.lensToPath(lens);
+	const loadHint = require_loading_loadLens.lensPathToLoadHint(paths);
 	return require_newEntity.lazyField((entity) => {
 		const meta = require_EntityMetadata.getMetadata(entity);
 		return new require_relations_CustomReference.CustomReference(entity, {
-			load: (entity, opts) => require_loadLens.loadLensPath(entity, paths, opts),
-			get: () => require_loadLens.getLensPath(meta, entity, paths),
-			isLoaded: () => require_loadLens.isLensLoadedPath(entity, paths),
+			load: (entity, opts) => require_loading_loadLens.loadLensPath(entity, paths, opts),
+			get: () => require_loading_loadLens.getLensPath(meta, entity, paths),
+			isLoaded: () => require_loading_loadLens.isLensLoadedPath(entity, paths),
 			loadHint
 		});
 	});

package/build/relations/hasOneThrough.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasOneThrough.cjs","names":["lensToPath","lensPathToLoadHint","lazyField","getMetadata","CustomReference","loadLensPath","getLensPath","isLensLoadedPath"],"sources":["../../src/relations/hasOneThrough.ts"],"sourcesContent":["import {\n  CustomReference,\n  type Entity,\n  type Lens,\n  type Reference,\n  getLensPath,\n  getMetadata,\n  isLensLoadedPath,\n  lensPathToLoadHint,\n  lensToPath,\n  loadLensPath,\n} from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\n\n/**\n * Creates a CustomReference that will walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(\n  lens: (lens: Lens<T>) => Lens<V>,\n): Reference<T, U, N> {\n  const paths = lensToPath(lens);\n  const loadHint = lensPathToLoadHint<T>(paths);\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => loadLensPath(entity, paths, opts),\n      get: () => getLensPath(meta, entity, paths),\n      isLoaded: () => isLensLoadedPath(entity, paths),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAqBA,SAAgB,cACd,MACoB;CACpB,MAAM,QAAQA,iBAAAA,WAAW,IAAI;CAC7B,MAAM,WAAWC,iBAAAA,mBAAsB,KAAK;CAC5C,OAAOC,kBAAAA,WAAW,WAAc;EAC9B,MAAM,OAAOC,uBAAAA,YAAY,MAAM;EAC/B,OAAO,IAAIC,kCAAAA,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAASC,iBAAAA,aAAa,QAAQ,OAAO,IAAI;GACxD,WAAWC,iBAAAA,YAAY,MAAM,QAAQ,KAAK;GAC1C,gBAAgBC,iBAAAA,iBAAiB,QAAQ,KAAK;GAC9C;EACF,CAAC;CACH,CAAC;AACH"}
+{"version":3,"file":"hasOneThrough.cjs","names":["lensToPath","lensPathToLoadHint","lazyField","getMetadata","CustomReference","loadLensPath","getLensPath","isLensLoadedPath"],"sources":["../../src/relations/hasOneThrough.ts"],"sourcesContent":["import {\n  CustomReference,\n  type Entity,\n  type Lens,\n  type Reference,\n  getLensPath,\n  getMetadata,\n  isLensLoadedPath,\n  lensPathToLoadHint,\n  lensToPath,\n  loadLensPath,\n} from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\n\n/**\n * Creates a CustomReference that will walk across references in the object graph.\n *\n * I.e. A BookReview \"has one author\" through the `review -> book -> author` relation.\n *\n * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, \"author\")`.\n */\nexport function hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(\n  lens: (lens: Lens<T>) => Lens<V>,\n): Reference<T, U, N> {\n  const paths = lensToPath(lens);\n  const loadHint = lensPathToLoadHint<T>(paths);\n  return lazyField((entity: T) => {\n    const meta = getMetadata(entity);\n    return new CustomReference<T, U, N>(entity, {\n      load: (entity, opts) => loadLensPath(entity, paths, opts),\n      get: () => getLensPath(meta, entity, paths),\n      isLoaded: () => isLensLoadedPath(entity, paths),\n      loadHint,\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAqBA,SAAgB,cACd,MACoB;CACpB,MAAM,QAAQA,yBAAAA,WAAW,IAAI;CAC7B,MAAM,WAAWC,yBAAAA,mBAAsB,KAAK;CAC5C,OAAOC,kBAAAA,WAAW,WAAc;EAC9B,MAAM,OAAOC,uBAAAA,YAAY,MAAM;EAC/B,OAAO,IAAIC,kCAAAA,gBAAyB,QAAQ;GAC1C,OAAO,QAAQ,SAASC,yBAAAA,aAAa,QAAQ,OAAO,IAAI;GACxD,WAAWC,yBAAAA,YAAY,MAAM,QAAQ,KAAK;GAC1C,gBAAgBC,yBAAAA,iBAAiB,QAAQ,KAAK;GAC9C;EACF,CAAC;CACH,CAAC;AACH"}

package/build/relations/hasOneThrough.d.cts

@@ -1,5 +1,5 @@
 import { Reference } from "./Reference.cjs";
-import { Lens } from "../loadLens.cjs";
+import { Lens } from "../loading/loadLens.cjs";
 import "../index.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasOneThrough.d.ts

package/build/relations/hasOneThrough.d.mts

@@ -1,5 +1,5 @@
 import { Reference } from "./Reference.mjs";
-import { Lens } from "../loadLens.mjs";
+import { Lens } from "../loading/loadLens.mjs";
 import "../index.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasOneThrough.d.ts

package/build/relations/hasOneThrough.js

@@ -1,7 +1,7 @@
-import { lazyField } from "../newEntity.js";
 import { CustomReference } from "./CustomReference.js";
+import { lazyField } from "../newEntity.js";
 import { getMetadata } from "../EntityMetadata.js";
-import { getLensPath, isLensLoadedPath, lensPathToLoadHint, lensToPath, loadLensPath } from "../loadLens.js";
+import { getLensPath, isLensLoadedPath, lensPathToLoadHint, lensToPath, loadLensPath } from "../loading/loadLens.js";
 import "../index.js";
 //#region src/relations/hasOneThrough.ts
 /**

package/build/relations/hasProperty.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
 const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
-const require_reactiveHints = require("../reactiveHints.cjs");
-const require_loadHints = require("../loadHints.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
+const require_loading_loadHints = require("../loading/loadHints.cjs");
 const require_utils = require("../utils.cjs");
 const require_newEntity = require("../newEntity.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
@@ -64,7 +64,7 @@ var PropertyImpl = class {
 		return require_utils.tryResolve(() => this.get);
 	}
 	get loadHint() {
-		if (!this.#hint) this.#hint = require_reactiveHints.convertToLoadHint(require_EntityMetadata.getMetadata(this.#entity), this.#reactiveHint);
+		if (!this.#hint) this.#hint = require_reactivity_reactiveHints.convertToLoadHint(require_EntityMetadata.getMetadata(this.#entity), this.#reactiveHint);
 		return this.#hint;
 	}
 	get reactiveHint() {
@@ -83,7 +83,7 @@ var PropertyImpl = class {
 				}, [this.#entity]);
 			}
 			this.#isCheckingLoaded = true;
-			this.#loaded = require_loadHints.isLoaded(this.#entity, this.loadHint);
+			this.#loaded = require_loading_loadHints.isLoaded(this.#entity, this.loadHint);
 			this.#isCheckingLoaded = false;
 		}
 		return !!this.#loaded;

package/build/relations/hasProperty.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hasProperty.cjs","names":["lazyField","#entity","#hint","#reactiveHint","#loadPromise","#loaded","tryResolve","convertToLoadHint","getMetadata","#isCheckingLoaded","RecursiveCycleError","isLoaded","PropertyT"],"sources":["../../src/relations/hasProperty.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getMetadata } from \"../EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"../reactiveHints.ts\";\nimport { tryResolve } from \"../utils.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"./RecursiveCycleError.ts\";\n\nexport { PropertyT };\n\nexport interface Property<T extends Entity, V> {\n  // Differentiate from AsyncMethod\n  [PropertyT]: T;\n  isLoaded: boolean;\n  load(): Promise<V>;\n}\n\nexport interface LoadedProperty<T extends Entity, V> {\n  get: V;\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>) => V,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, loadHint, fn);\n  });\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(\n  reactiveHint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, reactiveHint as any, fn as any, { isReactive: true });\n  });\n}\n\nexport class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {\n  // We'll probe for loaded if undefined\n  #loaded: boolean | undefined = undefined;\n  #isCheckingLoaded = false;\n  #loadPromise: any;\n\n  readonly #entity: T;\n  #hint: H | undefined;\n  #reactiveHint: ReactiveHint<T> | undefined;\n  constructor(\n    entity: T,\n    private fieldName: string,\n    hint: H | ReactiveHint<T>,\n    private fn: (entity: Loaded<T, H>) => V,\n    private opts: { isReactive?: boolean } = {},\n  ) {\n    const { isReactive = false } = opts;\n    this.#entity = entity;\n    this.#hint = isReactive ? undefined : (hint as H);\n    this.#reactiveHint = isReactive ? (hint as ReactiveHint<T>) : undefined;\n  }\n\n  load(): Promise<V> {\n    if (!this.isLoaded) {\n      const { loadHint, fn } = this;\n      return (this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {\n        this.#loaded = true;\n        return fn(loaded);\n      }));\n    }\n    return tryResolve(() => this.get);\n  }\n\n  get loadHint(): H {\n    if (!this.#hint) {\n      // Would be nice to statically (but lazily?) cache this...\n      this.#hint = convertToLoadHint(getMetadata(this.#entity), this.#reactiveHint as any) as H;\n    }\n    return this.#hint;\n  }\n\n  get reactiveHint(): ReactiveHint<T> | undefined {\n    return this.#reactiveHint;\n  }\n\n  get get(): V {\n    return this.fn(this.#entity as Loaded<T, H>);\n  }\n\n  get isLoaded() {\n    // Probe the first time, which is useful for factories that are DeepNew\n    if (this.#loaded === undefined) {\n      if (this.#isCheckingLoaded) {\n        this.#isCheckingLoaded = false;\n        throw new RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);\n      }\n      this.#isCheckingLoaded = true;\n      this.#loaded = isLoaded(this.#entity, this.loadHint);\n      this.#isCheckingLoaded = false;\n    }\n    return !!this.#loaded;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a Property. */\nexport function isProperty(maybeProperty: any): maybeProperty is Property<any, any> {\n  return maybeProperty instanceof PropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Property. */\nexport function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any> {\n  return isProperty(maybeProperty) && maybeProperty.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmCA,SAAgB,YACd,UACA,IACgB;CAChB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,UAAU,EAAE;CACzD,CAAC;AACH;;;;;;;;;AAUA,SAAgB,oBACd,cACA,IACgB;CAChB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,cAAqB,IAAW,EAAE,YAAY,KAAK,CAAC;CACjG,CAAC;AACH;AAEA,IAAa,eAAb,MAAgG;CAWpF;CAEA;CACA;CAZV,UAA+B,KAAA;CAC/B,oBAAoB;CACpB;CAEA;CACA;CACA;CACA,YACE,QACA,WACA,MACA,IACA,OAAyC,CAAC,GAC1C;EAJQ,KAAA,YAAA;EAEA,KAAA,KAAA;EACA,KAAA,OAAA;EAER,MAAM,EAAE,aAAa,UAAU;EAC/B,KAAKC,UAAU;EACf,KAAKC,QAAQ,aAAa,KAAA,IAAa;EACvC,KAAKC,gBAAgB,aAAc,OAA2B,KAAA;CAChE;CAEA,OAAmB;EACjB,IAAI,CAAC,KAAK,UAAU;GAClB,MAAM,EAAE,UAAU,OAAO;GACzB,OAAQ,KAAKC,iBAAiB,KAAKH,QAAQ,GAAG,SAAS,KAAKA,SAAS,QAAQ,CAAC,CAAC,MAAM,WAAW;IAC9F,KAAKI,UAAU;IACf,OAAO,GAAG,MAAM;GAClB,CAAC;EACH;EACA,OAAOC,cAAAA,iBAAiB,KAAK,GAAG;CAClC;CAEA,IAAI,WAAc;EAChB,IAAI,CAAC,KAAKJ,OAER,KAAKA,QAAQK,sBAAAA,kBAAkBC,uBAAAA,YAAY,KAAKP,OAAO,GAAG,KAAKE,aAAoB;EAErF,OAAO,KAAKD;CACd;CAEA,IAAI,eAA4C;EAC9C,OAAO,KAAKC;CACd;CAEA,IAAI,MAAS;EACX,OAAO,KAAK,GAAG,KAAKF,OAAuB;CAC7C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKI,YAAY,KAAA,GAAW;GAC9B,IAAI,KAAKI,mBAAmB;IAC1B,KAAKA,oBAAoB;IACzB,MAAM,IAAIC,sCAAAA,oBAAoB;KAAE,QAAQ,KAAKT;KAAS,WAAW,KAAK;IAAU,GAAG,CAAC,KAAKA,OAAO,CAAC;GACnG;GACA,KAAKQ,oBAAoB;GACzB,KAAKJ,UAAUM,kBAAAA,SAAS,KAAKV,SAAS,KAAK,QAAQ;GACnD,KAAKQ,oBAAoB;EAC3B;EACA,OAAO,CAAC,CAAC,KAAKJ;CAChB;CAEA,CAACO,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,WAAW,eAAyD;CAClF,OAAO,yBAAyB;AAClC;;AAGA,SAAgB,iBAAiB,eAAoF;CACnH,OAAO,WAAW,aAAa,KAAK,cAAc;AACpD"}
+{"version":3,"file":"hasProperty.cjs","names":["lazyField","#entity","#hint","#reactiveHint","#loadPromise","#loaded","tryResolve","convertToLoadHint","getMetadata","#isCheckingLoaded","RecursiveCycleError","isLoaded","PropertyT"],"sources":["../../src/relations/hasProperty.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getMetadata } from \"../EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"../loading/loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"../reactivity/reactiveHints.ts\";\nimport { tryResolve } from \"../utils.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"./RecursiveCycleError.ts\";\n\nexport { PropertyT };\n\nexport interface Property<T extends Entity, V> {\n  // Differentiate from AsyncMethod\n  [PropertyT]: T;\n  isLoaded: boolean;\n  load(): Promise<V>;\n}\n\nexport interface LoadedProperty<T extends Entity, V> {\n  get: V;\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>) => V,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, loadHint, fn);\n  });\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(\n  reactiveHint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, reactiveHint as any, fn as any, { isReactive: true });\n  });\n}\n\nexport class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {\n  // We'll probe for loaded if undefined\n  #loaded: boolean | undefined = undefined;\n  #isCheckingLoaded = false;\n  #loadPromise: any;\n\n  readonly #entity: T;\n  #hint: H | undefined;\n  #reactiveHint: ReactiveHint<T> | undefined;\n  constructor(\n    entity: T,\n    private fieldName: string,\n    hint: H | ReactiveHint<T>,\n    private fn: (entity: Loaded<T, H>) => V,\n    private opts: { isReactive?: boolean } = {},\n  ) {\n    const { isReactive = false } = opts;\n    this.#entity = entity;\n    this.#hint = isReactive ? undefined : (hint as H);\n    this.#reactiveHint = isReactive ? (hint as ReactiveHint<T>) : undefined;\n  }\n\n  load(): Promise<V> {\n    if (!this.isLoaded) {\n      const { loadHint, fn } = this;\n      return (this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {\n        this.#loaded = true;\n        return fn(loaded);\n      }));\n    }\n    return tryResolve(() => this.get);\n  }\n\n  get loadHint(): H {\n    if (!this.#hint) {\n      // Would be nice to statically (but lazily?) cache this...\n      this.#hint = convertToLoadHint(getMetadata(this.#entity), this.#reactiveHint as any) as H;\n    }\n    return this.#hint;\n  }\n\n  get reactiveHint(): ReactiveHint<T> | undefined {\n    return this.#reactiveHint;\n  }\n\n  get get(): V {\n    return this.fn(this.#entity as Loaded<T, H>);\n  }\n\n  get isLoaded() {\n    // Probe the first time, which is useful for factories that are DeepNew\n    if (this.#loaded === undefined) {\n      if (this.#isCheckingLoaded) {\n        this.#isCheckingLoaded = false;\n        throw new RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);\n      }\n      this.#isCheckingLoaded = true;\n      this.#loaded = isLoaded(this.#entity, this.loadHint);\n      this.#isCheckingLoaded = false;\n    }\n    return !!this.#loaded;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a Property. */\nexport function isProperty(maybeProperty: any): maybeProperty is Property<any, any> {\n  return maybeProperty instanceof PropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Property. */\nexport function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any> {\n  return isProperty(maybeProperty) && maybeProperty.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmCA,SAAgB,YACd,UACA,IACgB;CAChB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,UAAU,EAAE;CACzD,CAAC;AACH;;;;;;;;;AAUA,SAAgB,oBACd,cACA,IACgB;CAChB,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,cAAqB,IAAW,EAAE,YAAY,KAAK,CAAC;CACjG,CAAC;AACH;AAEA,IAAa,eAAb,MAAgG;CAWpF;CAEA;CACA;CAZV,UAA+B,KAAA;CAC/B,oBAAoB;CACpB;CAEA;CACA;CACA;CACA,YACE,QACA,WACA,MACA,IACA,OAAyC,CAAC,GAC1C;EAJQ,KAAA,YAAA;EAEA,KAAA,KAAA;EACA,KAAA,OAAA;EAER,MAAM,EAAE,aAAa,UAAU;EAC/B,KAAKC,UAAU;EACf,KAAKC,QAAQ,aAAa,KAAA,IAAa;EACvC,KAAKC,gBAAgB,aAAc,OAA2B,KAAA;CAChE;CAEA,OAAmB;EACjB,IAAI,CAAC,KAAK,UAAU;GAClB,MAAM,EAAE,UAAU,OAAO;GACzB,OAAQ,KAAKC,iBAAiB,KAAKH,QAAQ,GAAG,SAAS,KAAKA,SAAS,QAAQ,CAAC,CAAC,MAAM,WAAW;IAC9F,KAAKI,UAAU;IACf,OAAO,GAAG,MAAM;GAClB,CAAC;EACH;EACA,OAAOC,cAAAA,iBAAiB,KAAK,GAAG;CAClC;CAEA,IAAI,WAAc;EAChB,IAAI,CAAC,KAAKJ,OAER,KAAKA,QAAQK,iCAAAA,kBAAkBC,uBAAAA,YAAY,KAAKP,OAAO,GAAG,KAAKE,aAAoB;EAErF,OAAO,KAAKD;CACd;CAEA,IAAI,eAA4C;EAC9C,OAAO,KAAKC;CACd;CAEA,IAAI,MAAS;EACX,OAAO,KAAK,GAAG,KAAKF,OAAuB;CAC7C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKI,YAAY,KAAA,GAAW;GAC9B,IAAI,KAAKI,mBAAmB;IAC1B,KAAKA,oBAAoB;IACzB,MAAM,IAAIC,sCAAAA,oBAAoB;KAAE,QAAQ,KAAKT;KAAS,WAAW,KAAK;IAAU,GAAG,CAAC,KAAKA,OAAO,CAAC;GACnG;GACA,KAAKQ,oBAAoB;GACzB,KAAKJ,UAAUM,0BAAAA,SAAS,KAAKV,SAAS,KAAK,QAAQ;GACnD,KAAKQ,oBAAoB;EAC3B;EACA,OAAO,CAAC,CAAC,KAAKJ;CAChB;CAEA,CAACO,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,WAAW,eAAyD;CAClF,OAAO,yBAAyB;AAClC;;AAGA,SAAgB,iBAAiB,eAAoF;CACnH,OAAO,WAAW,aAAa,KAAK,cAAc;AACpD"}

package/build/relations/hasProperty.d.cts

@@ -1,6 +1,6 @@
 import { PropertyT } from "./PropertySymbols.cjs";
-import { LoadHint, Loaded } from "../loadHints.cjs";
-import { MaybeReactedPropertyEntity, Reacted, ReactiveHint } from "../reactiveHints.cjs";
+import { LoadHint, Loaded } from "../loading/loadHints.cjs";
+import { MaybeReactedPropertyEntity, Reacted, ReactiveHint } from "../reactivity/reactiveHints.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/hasProperty.d.ts
 interface Property<T extends Entity, V> {

package/build/relations/hasProperty.d.mts

@@ -1,6 +1,6 @@
 import { PropertyT } from "./PropertySymbols.mjs";
-import { LoadHint, Loaded } from "../loadHints.mjs";
-import { MaybeReactedPropertyEntity, Reacted, ReactiveHint } from "../reactiveHints.mjs";
+import { LoadHint, Loaded } from "../loading/loadHints.mjs";
+import { MaybeReactedPropertyEntity, Reacted, ReactiveHint } from "../reactivity/reactiveHints.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/hasProperty.d.ts
 interface Property<T extends Entity, V> {

package/build/relations/hasProperty.js

@@ -1,7 +1,7 @@
 import { PropertyT } from "./PropertySymbols.js";
 import { RecursiveCycleError } from "./RecursiveCycleError.js";
-import { convertToLoadHint } from "../reactiveHints.js";
-import { isLoaded } from "../loadHints.js";
+import { convertToLoadHint } from "../reactivity/reactiveHints.js";
+import { isLoaded } from "../loading/loadHints.js";
 import { tryResolve } from "../utils.js";
 import { lazyField } from "../newEntity.js";
 import { getMetadata } from "../EntityMetadata.js";

package/build/relations/hasProperty.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasProperty.js","names":["#entity","#hint","#reactiveHint","#loadPromise","#loaded","#isCheckingLoaded"],"sources":["../../src/relations/hasProperty.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getMetadata } from \"../EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"../loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"../reactiveHints.ts\";\nimport { tryResolve } from \"../utils.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"./RecursiveCycleError.ts\";\n\nexport { PropertyT };\n\nexport interface Property<T extends Entity, V> {\n  // Differentiate from AsyncMethod\n  [PropertyT]: T;\n  isLoaded: boolean;\n  load(): Promise<V>;\n}\n\nexport interface LoadedProperty<T extends Entity, V> {\n  get: V;\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>) => V,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, loadHint, fn);\n  });\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(\n  reactiveHint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, reactiveHint as any, fn as any, { isReactive: true });\n  });\n}\n\nexport class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {\n  // We'll probe for loaded if undefined\n  #loaded: boolean | undefined = undefined;\n  #isCheckingLoaded = false;\n  #loadPromise: any;\n\n  readonly #entity: T;\n  #hint: H | undefined;\n  #reactiveHint: ReactiveHint<T> | undefined;\n  constructor(\n    entity: T,\n    private fieldName: string,\n    hint: H | ReactiveHint<T>,\n    private fn: (entity: Loaded<T, H>) => V,\n    private opts: { isReactive?: boolean } = {},\n  ) {\n    const { isReactive = false } = opts;\n    this.#entity = entity;\n    this.#hint = isReactive ? undefined : (hint as H);\n    this.#reactiveHint = isReactive ? (hint as ReactiveHint<T>) : undefined;\n  }\n\n  load(): Promise<V> {\n    if (!this.isLoaded) {\n      const { loadHint, fn } = this;\n      return (this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {\n        this.#loaded = true;\n        return fn(loaded);\n      }));\n    }\n    return tryResolve(() => this.get);\n  }\n\n  get loadHint(): H {\n    if (!this.#hint) {\n      // Would be nice to statically (but lazily?) cache this...\n      this.#hint = convertToLoadHint(getMetadata(this.#entity), this.#reactiveHint as any) as H;\n    }\n    return this.#hint;\n  }\n\n  get reactiveHint(): ReactiveHint<T> | undefined {\n    return this.#reactiveHint;\n  }\n\n  get get(): V {\n    return this.fn(this.#entity as Loaded<T, H>);\n  }\n\n  get isLoaded() {\n    // Probe the first time, which is useful for factories that are DeepNew\n    if (this.#loaded === undefined) {\n      if (this.#isCheckingLoaded) {\n        this.#isCheckingLoaded = false;\n        throw new RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);\n      }\n      this.#isCheckingLoaded = true;\n      this.#loaded = isLoaded(this.#entity, this.loadHint);\n      this.#isCheckingLoaded = false;\n    }\n    return !!this.#loaded;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a Property. */\nexport function isProperty(maybeProperty: any): maybeProperty is Property<any, any> {\n  return maybeProperty instanceof PropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Property. */\nexport function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any> {\n  return isProperty(maybeProperty) && maybeProperty.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmCA,SAAgB,YACd,UACA,IACgB;CAChB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,UAAU,EAAE;CACzD,CAAC;AACH;;;;;;;;;AAUA,SAAgB,oBACd,cACA,IACgB;CAChB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,cAAqB,IAAW,EAAE,YAAY,KAAK,CAAC;CACjG,CAAC;AACH;AAEA,IAAa,eAAb,MAAgG;CAWpF;CAEA;CACA;CAZV,UAA+B,KAAA;CAC/B,oBAAoB;CACpB;CAEA;CACA;CACA;CACA,YACE,QACA,WACA,MACA,IACA,OAAyC,CAAC,GAC1C;EAJQ,KAAA,YAAA;EAEA,KAAA,KAAA;EACA,KAAA,OAAA;EAER,MAAM,EAAE,aAAa,UAAU;EAC/B,KAAKA,UAAU;EACf,KAAKC,QAAQ,aAAa,KAAA,IAAa;EACvC,KAAKC,gBAAgB,aAAc,OAA2B,KAAA;CAChE;CAEA,OAAmB;EACjB,IAAI,CAAC,KAAK,UAAU;GAClB,MAAM,EAAE,UAAU,OAAO;GACzB,OAAQ,KAAKC,iBAAiB,KAAKH,QAAQ,GAAG,SAAS,KAAKA,SAAS,QAAQ,CAAC,CAAC,MAAM,WAAW;IAC9F,KAAKI,UAAU;IACf,OAAO,GAAG,MAAM;GAClB,CAAC;EACH;EACA,OAAO,iBAAiB,KAAK,GAAG;CAClC;CAEA,IAAI,WAAc;EAChB,IAAI,CAAC,KAAKH,OAER,KAAKA,QAAQ,kBAAkB,YAAY,KAAKD,OAAO,GAAG,KAAKE,aAAoB;EAErF,OAAO,KAAKD;CACd;CAEA,IAAI,eAA4C;EAC9C,OAAO,KAAKC;CACd;CAEA,IAAI,MAAS;EACX,OAAO,KAAK,GAAG,KAAKF,OAAuB;CAC7C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKI,YAAY,KAAA,GAAW;GAC9B,IAAI,KAAKC,mBAAmB;IAC1B,KAAKA,oBAAoB;IACzB,MAAM,IAAI,oBAAoB;KAAE,QAAQ,KAAKL;KAAS,WAAW,KAAK;IAAU,GAAG,CAAC,KAAKA,OAAO,CAAC;GACnG;GACA,KAAKK,oBAAoB;GACzB,KAAKD,UAAU,SAAS,KAAKJ,SAAS,KAAK,QAAQ;GACnD,KAAKK,oBAAoB;EAC3B;EACA,OAAO,CAAC,CAAC,KAAKD;CAChB;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,WAAW,eAAyD;CAClF,OAAO,yBAAyB;AAClC;;AAGA,SAAgB,iBAAiB,eAAoF;CACnH,OAAO,WAAW,aAAa,KAAK,cAAc;AACpD"}
+{"version":3,"file":"hasProperty.js","names":["#entity","#hint","#reactiveHint","#loadPromise","#loaded","#isCheckingLoaded"],"sources":["../../src/relations/hasProperty.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { getMetadata } from \"../EntityMetadata.ts\";\nimport { type LoadHint, type Loaded, isLoaded } from \"../loading/loadHints.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport {\n  type MaybeReactedPropertyEntity,\n  type Reacted,\n  type ReactiveHint,\n  convertToLoadHint,\n} from \"../reactivity/reactiveHints.ts\";\nimport { tryResolve } from \"../utils.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\nimport { RecursiveCycleError } from \"./RecursiveCycleError.ts\";\n\nexport { PropertyT };\n\nexport interface Property<T extends Entity, V> {\n  // Differentiate from AsyncMethod\n  [PropertyT]: T;\n  isLoaded: boolean;\n  load(): Promise<V>;\n}\n\nexport interface LoadedProperty<T extends Entity, V> {\n  get: V;\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasProperty<T extends Entity, const H extends LoadHint<T>, V>(\n  loadHint: H,\n  fn: (entity: Loaded<T, H>) => V,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, loadHint, fn);\n  });\n}\n\n/**\n * Creates a calculated derived value from a load hint + lambda.\n *\n * The property can be accessed by default as a promise, with `someProperty.load()`.\n *\n * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,\n * with `someProperty.get`.\n */\nexport function hasReactiveProperty<T extends Entity, const H extends ReactiveHint<T>, V>(\n  reactiveHint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedPropertyEntity<V>,\n): Property<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new PropertyImpl(entity, fieldName, reactiveHint as any, fn as any, { isReactive: true });\n  });\n}\n\nexport class PropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements Property<T, V> {\n  // We'll probe for loaded if undefined\n  #loaded: boolean | undefined = undefined;\n  #isCheckingLoaded = false;\n  #loadPromise: any;\n\n  readonly #entity: T;\n  #hint: H | undefined;\n  #reactiveHint: ReactiveHint<T> | undefined;\n  constructor(\n    entity: T,\n    private fieldName: string,\n    hint: H | ReactiveHint<T>,\n    private fn: (entity: Loaded<T, H>) => V,\n    private opts: { isReactive?: boolean } = {},\n  ) {\n    const { isReactive = false } = opts;\n    this.#entity = entity;\n    this.#hint = isReactive ? undefined : (hint as H);\n    this.#reactiveHint = isReactive ? (hint as ReactiveHint<T>) : undefined;\n  }\n\n  load(): Promise<V> {\n    if (!this.isLoaded) {\n      const { loadHint, fn } = this;\n      return (this.#loadPromise ??= this.#entity.em.populate(this.#entity, loadHint).then((loaded) => {\n        this.#loaded = true;\n        return fn(loaded);\n      }));\n    }\n    return tryResolve(() => this.get);\n  }\n\n  get loadHint(): H {\n    if (!this.#hint) {\n      // Would be nice to statically (but lazily?) cache this...\n      this.#hint = convertToLoadHint(getMetadata(this.#entity), this.#reactiveHint as any) as H;\n    }\n    return this.#hint;\n  }\n\n  get reactiveHint(): ReactiveHint<T> | undefined {\n    return this.#reactiveHint;\n  }\n\n  get get(): V {\n    return this.fn(this.#entity as Loaded<T, H>);\n  }\n\n  get isLoaded() {\n    // Probe the first time, which is useful for factories that are DeepNew\n    if (this.#loaded === undefined) {\n      if (this.#isCheckingLoaded) {\n        this.#isCheckingLoaded = false;\n        throw new RecursiveCycleError({ entity: this.#entity, fieldName: this.fieldName }, [this.#entity]);\n      }\n      this.#isCheckingLoaded = true;\n      this.#loaded = isLoaded(this.#entity, this.loadHint);\n      this.#isCheckingLoaded = false;\n    }\n    return !!this.#loaded;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a Property. */\nexport function isProperty(maybeProperty: any): maybeProperty is Property<any, any> {\n  return maybeProperty instanceof PropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Property. */\nexport function isLoadedProperty(maybeProperty: any): maybeProperty is Property<any, any> & LoadedProperty<any, any> {\n  return isProperty(maybeProperty) && maybeProperty.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmCA,SAAgB,YACd,UACA,IACgB;CAChB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,UAAU,EAAE;CACzD,CAAC;AACH;;;;;;;;;AAUA,SAAgB,oBACd,cACA,IACgB;CAChB,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,aAAa,QAAQ,WAAW,cAAqB,IAAW,EAAE,YAAY,KAAK,CAAC;CACjG,CAAC;AACH;AAEA,IAAa,eAAb,MAAgG;CAWpF;CAEA;CACA;CAZV,UAA+B,KAAA;CAC/B,oBAAoB;CACpB;CAEA;CACA;CACA;CACA,YACE,QACA,WACA,MACA,IACA,OAAyC,CAAC,GAC1C;EAJQ,KAAA,YAAA;EAEA,KAAA,KAAA;EACA,KAAA,OAAA;EAER,MAAM,EAAE,aAAa,UAAU;EAC/B,KAAKA,UAAU;EACf,KAAKC,QAAQ,aAAa,KAAA,IAAa;EACvC,KAAKC,gBAAgB,aAAc,OAA2B,KAAA;CAChE;CAEA,OAAmB;EACjB,IAAI,CAAC,KAAK,UAAU;GAClB,MAAM,EAAE,UAAU,OAAO;GACzB,OAAQ,KAAKC,iBAAiB,KAAKH,QAAQ,GAAG,SAAS,KAAKA,SAAS,QAAQ,CAAC,CAAC,MAAM,WAAW;IAC9F,KAAKI,UAAU;IACf,OAAO,GAAG,MAAM;GAClB,CAAC;EACH;EACA,OAAO,iBAAiB,KAAK,GAAG;CAClC;CAEA,IAAI,WAAc;EAChB,IAAI,CAAC,KAAKH,OAER,KAAKA,QAAQ,kBAAkB,YAAY,KAAKD,OAAO,GAAG,KAAKE,aAAoB;EAErF,OAAO,KAAKD;CACd;CAEA,IAAI,eAA4C;EAC9C,OAAO,KAAKC;CACd;CAEA,IAAI,MAAS;EACX,OAAO,KAAK,GAAG,KAAKF,OAAuB;CAC7C;CAEA,IAAI,WAAW;EAEb,IAAI,KAAKI,YAAY,KAAA,GAAW;GAC9B,IAAI,KAAKC,mBAAmB;IAC1B,KAAKA,oBAAoB;IACzB,MAAM,IAAI,oBAAoB;KAAE,QAAQ,KAAKL;KAAS,WAAW,KAAK;IAAU,GAAG,CAAC,KAAKA,OAAO,CAAC;GACnG;GACA,KAAKK,oBAAoB;GACzB,KAAKD,UAAU,SAAS,KAAKJ,SAAS,KAAK,QAAQ;GACnD,KAAKK,oBAAoB;EAC3B;EACA,OAAO,CAAC,CAAC,KAAKD;CAChB;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,WAAW,eAAyD;CAClF,OAAO,yBAAyB;AAClC;;AAGA,SAAgB,iBAAiB,eAAoF;CACnH,OAAO,WAAW,aAAa,KAAK,cAAc;AACpD"}

package/build/relations/index.cjs

@@ -1,29 +1,29 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_Collection = require("./Collection.cjs");
+const require_relations_CustomCollection = require("./CustomCollection.cjs");
 const require_relations_EnumCollection = require("./EnumCollection.cjs");
-const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
-const require_relations_hasProperty = require("./hasProperty.cjs");
-const require_relations_LazyField = require("./LazyField.cjs");
-const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
-const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
-const require_relations_Reference = require("./Reference.cjs");
-const require_relations_ReactiveReference = require("./ReactiveReference.cjs");
-const require_relations_OneToOneReference = require("./OneToOneReference.cjs");
+const require_relations_CustomReference = require("./CustomReference.cjs");
 const require_relations_ReactiveGetter = require("./ReactiveGetter.cjs");
 const require_relations_Relation = require("./Relation.cjs");
 const require_relations_ReadOnlyCollection = require("./ReadOnlyCollection.cjs");
+const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
 const require_relations_RecursiveCollection = require("./RecursiveCollection.cjs");
-const require_relations_CustomCollection = require("./CustomCollection.cjs");
-const require_relations_CustomReference = require("./CustomReference.cjs");
 const require_relations_hasAsyncMethod = require("./hasAsyncMethod.cjs");
+const require_relations_hasProperty = require("./hasProperty.cjs");
 const require_relations_AsyncProperty = require("./AsyncProperty.cjs");
+const require_relations_LazyField = require("./LazyField.cjs");
 const require_relations_hasManyDerived = require("./hasManyDerived.cjs");
 const require_relations_hasManyThrough = require("./hasManyThrough.cjs");
+const require_relations_Reference = require("./Reference.cjs");
 const require_relations_hasOneDerived = require("./hasOneDerived.cjs");
 const require_relations_hasOneThrough = require("./hasOneThrough.cjs");
 const require_relations_ManyToManyCollection = require("./ManyToManyCollection.cjs");
 const require_relations_ManyToManyLargeCollection = require("./ManyToManyLargeCollection.cjs");
+const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
+const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
 const require_relations_OneToManyLargeCollection = require("./OneToManyLargeCollection.cjs");
+const require_relations_ReactiveReference = require("./ReactiveReference.cjs");
+const require_relations_OneToOneReference = require("./OneToOneReference.cjs");
 const require_relations_PolymorphicReference = require("./PolymorphicReference.cjs");
 const require_relations_ReactiveField = require("./ReactiveField.cjs");
 const require_relations_ReactiveManyToMany = require("./ReactiveManyToMany.cjs");

package/build/relations/index.js

@@ -1,28 +1,28 @@
 import { isCollection, isLoadedCollection } from "./Collection.js";
+import { CustomCollection, hasCustomCollection } from "./CustomCollection.js";
 import { EnumCollectionImpl, hasEnumCollection } from "./EnumCollection.js";
-import { RecursiveCycleError } from "./RecursiveCycleError.js";
-import { PropertyImpl, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty } from "./hasProperty.js";
-import { LazyFieldImpl, hasLazyField, isLazyField, isLoadedLazyField } from "./LazyField.js";
-import { OneToManyCollection, hasMany } from "./OneToManyCollection.js";
-import { ManyToOneReferenceImpl, hasOne, isManyToOneReference } from "./ManyToOneReference.js";
-import { isLoadedReference, isReference } from "./Reference.js";
-import { ReactiveReferenceImpl, hasReactiveReference, isReactiveReference } from "./ReactiveReference.js";
-import { OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.js";
+import { CustomReference, hasCustomReference } from "./CustomReference.js";
 import { hasReactiveGetter, isReactiveGetter } from "./ReactiveGetter.js";
 import { isRelation } from "./Relation.js";
 import { isLoadedReadOnlyCollection, isReadOnlyCollection } from "./ReadOnlyCollection.js";
+import { RecursiveCycleError } from "./RecursiveCycleError.js";
 import { hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents } from "./RecursiveCollection.js";
-import { CustomCollection, hasCustomCollection } from "./CustomCollection.js";
-import { CustomReference, hasCustomReference } from "./CustomReference.js";
 import { hasAsyncMethod } from "./hasAsyncMethod.js";
+import { PropertyImpl, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty } from "./hasProperty.js";
 import { AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty } from "./AsyncProperty.js";
+import { LazyFieldImpl, hasLazyField, isLazyField, isLoadedLazyField } from "./LazyField.js";
 import { hasManyDerived } from "./hasManyDerived.js";
 import { hasManyThrough } from "./hasManyThrough.js";
+import { isLoadedReference, isReference } from "./Reference.js";
 import { hasOneDerived } from "./hasOneDerived.js";
 import { hasOneThrough } from "./hasOneThrough.js";
 import { ManyToManyCollection, hasManyToMany } from "./ManyToManyCollection.js";
 import { ManyToManyLargeCollection, hasLargeManyToMany } from "./ManyToManyLargeCollection.js";
+import { OneToManyCollection, hasMany } from "./OneToManyCollection.js";
+import { ManyToOneReferenceImpl, hasOne, isManyToOneReference } from "./ManyToOneReference.js";
 import { OneToManyLargeCollection, hasLargeMany } from "./OneToManyLargeCollection.js";
+import { ReactiveReferenceImpl, hasReactiveReference, isReactiveReference } from "./ReactiveReference.js";
+import { OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.js";
 import { PolymorphicReferenceImpl, hasOnePolymorphic, isPolymorphicReference } from "./PolymorphicReference.js";
 import { hasReactiveField, isReactiveField } from "./ReactiveField.js";
 import { ReactiveManyToManyImpl, hasReactiveManyToMany, isReactiveManyToMany } from "./ReactiveManyToMany.js";

package/build/rules.cjs

@@ -1,12 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_fields = require("./fields.cjs");
-require("./typeMap.cjs");
-require("./changes.cjs");
 const require_relations_Reference = require("./relations/Reference.cjs");
-require("./reactiveHints.cjs");
-const require_utils = require("./utils.cjs");
 const require_relations_AsyncReactiveField = require("./relations/AsyncReactiveField.cjs");
 require("./relations/index.cjs");
+const require_utils = require("./utils.cjs");
+require("./typeMap.cjs");
+require("./changes.cjs");
 const require_EntityManager = require("./EntityManager.cjs");
 require("./Entity.cjs");
 //#region src/rules.ts

package/build/rules.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"rules.cjs","names":["groupBy","maybePromiseThen","getField","isAsyncReactiveField","isLoadedReference","getEmInternalApi"],"sources":["../src/rules.ts"],"sourcesContent":["import { type Changes, type EntityChanges } from \"./changes.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { getEmInternalApi } from \"./EntityManager.ts\";\nimport { getField } from \"./fields.ts\";\nimport { type ReactiveHint } from \"./reactiveHints.ts\";\nimport { type ManyToOneReferenceImpl, isAsyncReactiveField, isLoadedReference } from \"./relations/index.ts\";\nimport { type FieldsOf } from \"./typeMap.ts\";\nimport { type MaybePromise, groupBy, maybePromiseThen } from \"./utils.ts\";\n\nexport enum ValidationCode {\n  required = \"required\",\n  cannotBeUpdated = \"not-updatable\",\n  cannotBeChanged = \"not-changeable\",\n  numeric = \"not-numeric\",\n  minValue = \"under-min\",\n  maxValue = \"over-max\",\n}\n\n/**\n * The return type of `ValidationRule` lambdas.\n *\n * We're flexible and allow rules to return a variety of shapes, like just a string, string[], etc.\n *\n * Returning `undefined` means the rule passed.\n */\nexport type ValidationRuleResult = string | string[] | GenericError | GenericError[] | undefined | void;\n\n/** An entity validation rule. */\nexport type ValidationRule<T extends Entity> = (entity: T) => MaybePromise<ValidationRuleResult>;\n\n/** Internal metadata for an async/reactive validation rule. */\nexport type ValidationRuleInternal<T extends Entity> = {\n  name: string;\n  hint: ReactiveHint<T> | undefined;\n  fn: ValidationRule<T>;\n};\n\n/** A generic error which contains a message, and optional field/codes. */\nexport type GenericError = { message: string; field?: string; code?: string };\n\n/** Combines the GenericError with the `entity` that caused it. */\nexport type ValidationError = { entity: Entity } & GenericError;\n\nexport type ValidationRuleOptsFn<T extends Entity> = (entity: T) => MaybePromise<boolean>;\nexport type ValidationRuleOpts<T extends Entity> = {\n  unless?: ValidationRuleOptsFn<T>;\n  if?: ValidationRuleOptsFn<T>;\n};\n\nfunction errorMessage(errors: ValidationError[]): string {\n  if (errors.length === 1) {\n    return `Validation error: ${errors[0].entity.toString()} ${errors[0].message}`;\n  } else {\n    const message = [...groupBy(errors, (e) => e.entity.toString()).entries()]\n      .map(([entityToString, errors]) => `${entityToString} ${errors.map((e) => e.message).join(\", \")}`)\n      .join(\", \");\n    return `Validation errors (${errors.length}): ${message}`;\n  }\n}\n\nexport class ValidationErrors extends Error {\n  public errors: Array<GenericError | ValidationError>;\n  public readonly toJSON: () => string;\n  constructor(errors: ValidationError[]);\n  constructor(message: string);\n  constructor(messageOrErrors: ValidationError[] | string) {\n    super(typeof messageOrErrors === \"string\" ? messageOrErrors : errorMessage(messageOrErrors));\n    this.errors = typeof messageOrErrors === \"string\" ? [{ message: messageOrErrors }] : messageOrErrors;\n    // Jest clones without prototype, so explictly setting this as a property rather than a class method\n    // https://github.com/jestjs/jest/issues/11958\n    this.toJSON = () => `ValidationErrors: ${this.message}`;\n  }\n}\n\nfunction ruleWithOpts<T extends Entity>(\n  opts: ValidationRuleOpts<T> | undefined,\n  fn: (entity: T) => ValidationRuleResult,\n): ValidationRule<T> {\n  return (entity) => {\n    // Since all of our rules are sync, we run the rule first, then check if we should have run it second since this\n    // may be an async operation.  This way we can avoid running promises if we don't have to.\n    const result = fn(entity);\n    if (result === undefined) return;\n    const { unless, if: _if } = opts ?? {};\n    if (unless === undefined && _if === undefined) return result;\n    const shouldRun = [unless ?? (() => false), _if ?? (() => true)].map((fn) => fn(entity));\n    return maybePromiseThen(\n      shouldRun.some((r) => r instanceof Promise) ? Promise.all(shouldRun) : (shouldRun as boolean[]),\n      ([unless, _if]) => (!unless && _if ? result : undefined),\n    );\n  };\n}\n\n/**\n * The fields of `F` that have their own column, i.e. what a required rule can check.\n *\n * The filter is an allow-list (\"keep kinds primitive/enum/m2o/poly\"), not a deny-list (\"drop kind\n * o2o\"), because of how it degrades when `T` is generic/uninferred: `FieldsOf<T>` is then `never`,\n * and `never extends X` is true for any `X`, so an allow-list keeps every key (permissive, exactly\n * like the unfiltered `keyof FieldsOf<T>` before it) while a deny-list would drop every key and\n * break valid calls like `newRequiredRule(\"city\")`.\n */\ntype ColumnBackedFields<F> = {\n  [K in keyof F as F[K] extends { kind: \"primitive\" | \"enum\" | \"m2o\" | \"poly\" } ? K : never]: F[K];\n};\n\n/**\n * Creates a validation rule for required fields.\n *\n * This is added automatically by codegen to entities based on FK not-nulls.\n */\nexport function newRequiredRule<T extends Entity>(\n  key: keyof ColumnBackedFields<FieldsOf<T>> & string,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    // Use getField so that we peer through relations\n    if (getField(entity, key) === undefined) {\n      // Sanity check for AsyncReactiveFields--this should be cheap to just always do; alternatively we could\n      // have a RQF-specific `rqfRequiredRule` so that other `newRequiredRule` users don't pay the cost of these\n      // two `if` checks`.\n      if (entity.isNewEntity && isAsyncReactiveField((entity as any)[key])) {\n        throw new Error(\n          `AsyncReactiveField ${entity.constructor.name}.${key} must have a default value, either in the database or with config.setDefault (see the 4th step in https://joist-orm.io/modeling/reactive-fields/#async-reactive-fields.`,\n        );\n      }\n      return { field: key, code: ValidationCode.required, message: `${key} is required` };\n    }\n  });\n}\n\n/**\n * Like `newRequiredRule`, but for `lazy` columns (i.e. codegen only wires this up for `lazy` fields).\n *\n * On an already-persisted entity that hasn't loaded the column, we skip the check rather than force-load\n * (or falsely fail) a value that was required when the row was last saved. It still fires on create and\n * when the field is explicitly loaded-then-unset.\n */\nexport function newRequiredLazyFieldRule<T extends Entity>(\n  key: keyof FieldsOf<T> & string,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    if (!entity.isNewEntity && !(entity as any)[key].isLoaded) return;\n    if (getField(entity, key) === undefined) {\n      return { field: key, code: ValidationCode.required, message: `${key} is required` };\n    }\n  });\n}\n\n/**\n * Creates a validation rule that a field cannot be updated; it can only be set on creation.\n *\n * If the optional `unless` function returns true, then the update is allowed.\n */\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  opts?: ValidationRuleOpts<T>,\n): CannotBeUpdatedRule<T>;\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  unless?: ValidationRuleOptsFn<T>,\n): CannotBeUpdatedRule<T>;\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  optsOrUnless?: ValidationRuleOpts<T> | ValidationRuleOptsFn<T>,\n): CannotBeUpdatedRule<T> {\n  const opts = typeof optsOrUnless === \"function\" ? { unless: optsOrUnless } : (optsOrUnless ?? {});\n  const fn = ruleWithOpts(opts, (entity: T) => {\n    // For now putting the `EntityChanges` cast here to avoid breaking cannotBeUpdated rules\n    // on base types, see Publisher.ts's `cannotBeUpdated(\"type\")` repro.\n    if ((entity as any as EntityChanges<T>).changes[field].hasUpdated) {\n      const value = (entity as any)[field];\n      // If we're being changed b/c of an em.merge, that is okay\n      if (isLoadedReference(value) && getEmInternalApi(entity.em).isMerging(value.get)) return;\n      return { field, code: ValidationCode.cannotBeUpdated, message: `${field} cannot be updated` };\n    }\n    return;\n  });\n  return Object.assign(fn, { field, immutable: opts.unless === undefined && opts.if === undefined });\n}\n\n/**\n * Creates a validation rule that a field cannot be changed once set.\n *\n * If the optional `unless` function returns true, then the update is allowed.\n */\nexport function cannotBeChanged<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  opts?: ValidationRuleOpts<T>,\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity: T) => {\n    const changes = (entity as any as EntityChanges<T>).changes[field];\n    if (changes.kind === \"m2m\" || changes.kind === \"o2m\" || changes.kind === \"m2mEnum\") {\n      throw new Error(\"cannotBeChanged is only supported on primitive & m2o fields\");\n    } else if (changes.hasUpdated) {\n      const originalValue = changes.originalValue;\n      if (originalValue === undefined) return;\n      const value = getField(entity, field);\n      if (getEmInternalApi(entity.em).isMerging(value)) return;\n      return { field, code: ValidationCode.cannotBeChanged, message: `${field} cannot be changed` };\n    }\n    return;\n  });\n}\n\ntype CannotBeUpdatedRule<T extends Entity> = ValidationRule<T> & { field: string; immutable: boolean };\n\nexport function isCannotBeUpdatedRule(rule: Function): rule is CannotBeUpdatedRule<any> {\n  return \"field\" in rule && \"immutable\" in rule;\n}\n\n/** For STI, enforces subtype-specific relations/FKs at runtime. */\nexport function mustBeSubType<T extends Entity, K extends keyof Changes<T> & string>(\n  relationName: K,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const m2o = (entity as any)[relationName] as ManyToOneReferenceImpl<any, any, any>;\n    const other = m2o.get;\n    const otherCstr = m2o.otherMeta.cstr;\n    if (other && !(other instanceof otherCstr)) {\n      return `${relationName} must be a ${otherCstr.name} not ${other}`;\n    }\n  });\n}\n\n/**\n * Creates a validation rule that a field value cannot be smaller than a\n * certain value.\n *\n * @param field The field to validate\n * @param minValue The inclusive minimum value. e.g 0 range is [0, Infinity]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation\n *\n * @example\n * // Age cannot be smaller than 0\n * config.addRule(minValueRule(\"age\", 0));\n */\nexport function minValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  minValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const value = entity[field];\n    // Ignore undefined and null values. These should be handled by required rules\n    if (value === undefined || value === null) return;\n    // Show an error when the value type is not a number\n    if (typeof value !== \"number\") {\n      return { field, code: ValidationCode.numeric, message: `${field} must be a number` };\n    }\n    // Show an error when the value is smaller than the minimum value\n    if (value < minValue) {\n      return {\n        field,\n        code: ValidationCode.minValue,\n        message: `${field} must be greater than or equal to ${minValue}`,\n      };\n    }\n    return;\n  });\n}\n\n/**\n * Creates a validation rule that a field value cannot be greater than a\n * certain value.\n *\n * @param field The field to validate\n * @param maxValue The include maximum value. e.g 10 range is [-Infinity, 10]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation\n *\n * @example\n * // Age cannot be greater than 150\n * config.addRule(maxValueRule(\"age\", 150));\n */\nexport function maxValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  maxValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const value = entity[field];\n    // Ignore undefined and null values. These should be handled by required rules\n    if (value === undefined || value === null) return;\n    // Show an error when the value type is not a number\n    if (typeof value !== \"number\") {\n      return { field, code: ValidationCode.numeric, message: `${field} must be a number` };\n    }\n    // Show an error when the value is smaller than the minimum value\n    if (value > maxValue) {\n      return {\n        field,\n        code: ValidationCode.maxValue,\n        message: `${field} must be smaller than or equal to ${maxValue}`,\n      };\n    }\n    return;\n  });\n}\n\n/**\n * Creates a validation rule that a field value must be within a range of\n * certain values\n *\n * @param field The field to validate\n * @param minValue The inclusive minimum value. e.g  0 [0,   Infinity]\n * @param maxValue The include maximum value.   e.g 10 [-Infinity, 10]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation * @example\n *\n * // Age must be between 0 and 150\n * config.addRule(rangeValueRule(\"age\", 0, 150));\n */\nexport function rangeValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  minValue: number,\n  maxValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    // Check min and max value rules.  Because these are called without opts, it should be safe to treat them as sync.\n    const minValueResult = minValueRule<T, K>(field, minValue)(entity) as ValidationRuleResult;\n    const maxValueResult = maxValueRule<T, K>(field, maxValue)(entity) as ValidationRuleResult;\n    // Return any errors or nothing\n    if (minValueResult) return minValueResult;\n    if (maxValueResult) return maxValueResult;\n    return;\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"rules.cjs","names":["groupBy","maybePromiseThen","getField","isAsyncReactiveField","isLoadedReference","getEmInternalApi"],"sources":["../src/rules.ts"],"sourcesContent":["import { type Changes, type EntityChanges } from \"./changes.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { getEmInternalApi } from \"./EntityManager.ts\";\nimport { getField } from \"./fields.ts\";\nimport type { ReactiveHint } from \"./reactivity/reactiveHints.ts\";\nimport { type ManyToOneReferenceImpl, isAsyncReactiveField, isLoadedReference } from \"./relations/index.ts\";\nimport { type FieldsOf } from \"./typeMap.ts\";\nimport { type MaybePromise, groupBy, maybePromiseThen } from \"./utils.ts\";\n\nexport enum ValidationCode {\n  required = \"required\",\n  cannotBeUpdated = \"not-updatable\",\n  cannotBeChanged = \"not-changeable\",\n  numeric = \"not-numeric\",\n  minValue = \"under-min\",\n  maxValue = \"over-max\",\n}\n\n/**\n * The return type of `ValidationRule` lambdas.\n *\n * We're flexible and allow rules to return a variety of shapes, like just a string, string[], etc.\n *\n * Returning `undefined` means the rule passed.\n */\nexport type ValidationRuleResult = string | string[] | GenericError | GenericError[] | undefined | void;\n\n/** An entity validation rule. */\nexport type ValidationRule<T extends Entity> = (entity: T) => MaybePromise<ValidationRuleResult>;\n\n/** Internal metadata for an async/reactive validation rule. */\nexport type ValidationRuleInternal<T extends Entity> = {\n  name: string;\n  hint: ReactiveHint<T> | undefined;\n  fn: ValidationRule<T>;\n};\n\n/** A generic error which contains a message, and optional field/codes. */\nexport type GenericError = { message: string; field?: string; code?: string };\n\n/** Combines the GenericError with the `entity` that caused it. */\nexport type ValidationError = { entity: Entity } & GenericError;\n\nexport type ValidationRuleOptsFn<T extends Entity> = (entity: T) => MaybePromise<boolean>;\nexport type ValidationRuleOpts<T extends Entity> = {\n  unless?: ValidationRuleOptsFn<T>;\n  if?: ValidationRuleOptsFn<T>;\n};\n\nfunction errorMessage(errors: ValidationError[]): string {\n  if (errors.length === 1) {\n    return `Validation error: ${errors[0].entity.toString()} ${errors[0].message}`;\n  } else {\n    const message = [...groupBy(errors, (e) => e.entity.toString()).entries()]\n      .map(([entityToString, errors]) => `${entityToString} ${errors.map((e) => e.message).join(\", \")}`)\n      .join(\", \");\n    return `Validation errors (${errors.length}): ${message}`;\n  }\n}\n\nexport class ValidationErrors extends Error {\n  public errors: Array<GenericError | ValidationError>;\n  public readonly toJSON: () => string;\n  constructor(errors: ValidationError[]);\n  constructor(message: string);\n  constructor(messageOrErrors: ValidationError[] | string) {\n    super(typeof messageOrErrors === \"string\" ? messageOrErrors : errorMessage(messageOrErrors));\n    this.errors = typeof messageOrErrors === \"string\" ? [{ message: messageOrErrors }] : messageOrErrors;\n    // Jest clones without prototype, so explictly setting this as a property rather than a class method\n    // https://github.com/jestjs/jest/issues/11958\n    this.toJSON = () => `ValidationErrors: ${this.message}`;\n  }\n}\n\nfunction ruleWithOpts<T extends Entity>(\n  opts: ValidationRuleOpts<T> | undefined,\n  fn: (entity: T) => ValidationRuleResult,\n): ValidationRule<T> {\n  return (entity) => {\n    // Since all of our rules are sync, we run the rule first, then check if we should have run it second since this\n    // may be an async operation.  This way we can avoid running promises if we don't have to.\n    const result = fn(entity);\n    if (result === undefined) return;\n    const { unless, if: _if } = opts ?? {};\n    if (unless === undefined && _if === undefined) return result;\n    const shouldRun = [unless ?? (() => false), _if ?? (() => true)].map((fn) => fn(entity));\n    return maybePromiseThen(\n      shouldRun.some((r) => r instanceof Promise) ? Promise.all(shouldRun) : (shouldRun as boolean[]),\n      ([unless, _if]) => (!unless && _if ? result : undefined),\n    );\n  };\n}\n\n/**\n * The fields of `F` that have their own column, i.e. what a required rule can check.\n *\n * The filter is an allow-list (\"keep kinds primitive/enum/m2o/poly\"), not a deny-list (\"drop kind\n * o2o\"), because of how it degrades when `T` is generic/uninferred: `FieldsOf<T>` is then `never`,\n * and `never extends X` is true for any `X`, so an allow-list keeps every key (permissive, exactly\n * like the unfiltered `keyof FieldsOf<T>` before it) while a deny-list would drop every key and\n * break valid calls like `newRequiredRule(\"city\")`.\n */\ntype ColumnBackedFields<F> = {\n  [K in keyof F as F[K] extends { kind: \"primitive\" | \"enum\" | \"m2o\" | \"poly\" } ? K : never]: F[K];\n};\n\n/**\n * Creates a validation rule for required fields.\n *\n * This is added automatically by codegen to entities based on FK not-nulls.\n */\nexport function newRequiredRule<T extends Entity>(\n  key: keyof ColumnBackedFields<FieldsOf<T>> & string,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    // Use getField so that we peer through relations\n    if (getField(entity, key) === undefined) {\n      // Sanity check for AsyncReactiveFields--this should be cheap to just always do; alternatively we could\n      // have a RQF-specific `rqfRequiredRule` so that other `newRequiredRule` users don't pay the cost of these\n      // two `if` checks`.\n      if (entity.isNewEntity && isAsyncReactiveField((entity as any)[key])) {\n        throw new Error(\n          `AsyncReactiveField ${entity.constructor.name}.${key} must have a default value, either in the database or with config.setDefault (see the 4th step in https://joist-orm.io/modeling/reactive-fields/#async-reactive-fields.`,\n        );\n      }\n      return { field: key, code: ValidationCode.required, message: `${key} is required` };\n    }\n  });\n}\n\n/**\n * Like `newRequiredRule`, but for `lazy` columns (i.e. codegen only wires this up for `lazy` fields).\n *\n * On an already-persisted entity that hasn't loaded the column, we skip the check rather than force-load\n * (or falsely fail) a value that was required when the row was last saved. It still fires on create and\n * when the field is explicitly loaded-then-unset.\n */\nexport function newRequiredLazyFieldRule<T extends Entity>(\n  key: keyof FieldsOf<T> & string,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    if (!entity.isNewEntity && !(entity as any)[key].isLoaded) return;\n    if (getField(entity, key) === undefined) {\n      return { field: key, code: ValidationCode.required, message: `${key} is required` };\n    }\n  });\n}\n\n/**\n * Creates a validation rule that a field cannot be updated; it can only be set on creation.\n *\n * If the optional `unless` function returns true, then the update is allowed.\n */\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  opts?: ValidationRuleOpts<T>,\n): CannotBeUpdatedRule<T>;\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  unless?: ValidationRuleOptsFn<T>,\n): CannotBeUpdatedRule<T>;\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  optsOrUnless?: ValidationRuleOpts<T> | ValidationRuleOptsFn<T>,\n): CannotBeUpdatedRule<T> {\n  const opts = typeof optsOrUnless === \"function\" ? { unless: optsOrUnless } : (optsOrUnless ?? {});\n  const fn = ruleWithOpts(opts, (entity: T) => {\n    // For now putting the `EntityChanges` cast here to avoid breaking cannotBeUpdated rules\n    // on base types, see Publisher.ts's `cannotBeUpdated(\"type\")` repro.\n    if ((entity as any as EntityChanges<T>).changes[field].hasUpdated) {\n      const value = (entity as any)[field];\n      // If we're being changed b/c of an em.merge, that is okay\n      if (isLoadedReference(value) && getEmInternalApi(entity.em).isMerging(value.get)) return;\n      return { field, code: ValidationCode.cannotBeUpdated, message: `${field} cannot be updated` };\n    }\n    return;\n  });\n  return Object.assign(fn, { field, immutable: opts.unless === undefined && opts.if === undefined });\n}\n\n/**\n * Creates a validation rule that a field cannot be changed once set.\n *\n * If the optional `unless` function returns true, then the update is allowed.\n */\nexport function cannotBeChanged<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  opts?: ValidationRuleOpts<T>,\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity: T) => {\n    const changes = (entity as any as EntityChanges<T>).changes[field];\n    if (changes.kind === \"m2m\" || changes.kind === \"o2m\" || changes.kind === \"m2mEnum\") {\n      throw new Error(\"cannotBeChanged is only supported on primitive & m2o fields\");\n    } else if (changes.hasUpdated) {\n      const originalValue = changes.originalValue;\n      if (originalValue === undefined) return;\n      const value = getField(entity, field);\n      if (getEmInternalApi(entity.em).isMerging(value)) return;\n      return { field, code: ValidationCode.cannotBeChanged, message: `${field} cannot be changed` };\n    }\n    return;\n  });\n}\n\ntype CannotBeUpdatedRule<T extends Entity> = ValidationRule<T> & { field: string; immutable: boolean };\n\nexport function isCannotBeUpdatedRule(rule: Function): rule is CannotBeUpdatedRule<any> {\n  return \"field\" in rule && \"immutable\" in rule;\n}\n\n/** For STI, enforces subtype-specific relations/FKs at runtime. */\nexport function mustBeSubType<T extends Entity, K extends keyof Changes<T> & string>(\n  relationName: K,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const m2o = (entity as any)[relationName] as ManyToOneReferenceImpl<any, any, any>;\n    const other = m2o.get;\n    const otherCstr = m2o.otherMeta.cstr;\n    if (other && !(other instanceof otherCstr)) {\n      return `${relationName} must be a ${otherCstr.name} not ${other}`;\n    }\n  });\n}\n\n/**\n * Creates a validation rule that a field value cannot be smaller than a\n * certain value.\n *\n * @param field The field to validate\n * @param minValue The inclusive minimum value. e.g 0 range is [0, Infinity]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation\n *\n * @example\n * // Age cannot be smaller than 0\n * config.addRule(minValueRule(\"age\", 0));\n */\nexport function minValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  minValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const value = entity[field];\n    // Ignore undefined and null values. These should be handled by required rules\n    if (value === undefined || value === null) return;\n    // Show an error when the value type is not a number\n    if (typeof value !== \"number\") {\n      return { field, code: ValidationCode.numeric, message: `${field} must be a number` };\n    }\n    // Show an error when the value is smaller than the minimum value\n    if (value < minValue) {\n      return {\n        field,\n        code: ValidationCode.minValue,\n        message: `${field} must be greater than or equal to ${minValue}`,\n      };\n    }\n    return;\n  });\n}\n\n/**\n * Creates a validation rule that a field value cannot be greater than a\n * certain value.\n *\n * @param field The field to validate\n * @param maxValue The include maximum value. e.g 10 range is [-Infinity, 10]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation\n *\n * @example\n * // Age cannot be greater than 150\n * config.addRule(maxValueRule(\"age\", 150));\n */\nexport function maxValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  maxValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const value = entity[field];\n    // Ignore undefined and null values. These should be handled by required rules\n    if (value === undefined || value === null) return;\n    // Show an error when the value type is not a number\n    if (typeof value !== \"number\") {\n      return { field, code: ValidationCode.numeric, message: `${field} must be a number` };\n    }\n    // Show an error when the value is smaller than the minimum value\n    if (value > maxValue) {\n      return {\n        field,\n        code: ValidationCode.maxValue,\n        message: `${field} must be smaller than or equal to ${maxValue}`,\n      };\n    }\n    return;\n  });\n}\n\n/**\n * Creates a validation rule that a field value must be within a range of\n * certain values\n *\n * @param field The field to validate\n * @param minValue The inclusive minimum value. e.g  0 [0,   Infinity]\n * @param maxValue The include maximum value.   e.g 10 [-Infinity, 10]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation * @example\n *\n * // Age must be between 0 and 150\n * config.addRule(rangeValueRule(\"age\", 0, 150));\n */\nexport function rangeValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  minValue: number,\n  maxValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    // Check min and max value rules.  Because these are called without opts, it should be safe to treat them as sync.\n    const minValueResult = minValueRule<T, K>(field, minValue)(entity) as ValidationRuleResult;\n    const maxValueResult = maxValueRule<T, K>(field, maxValue)(entity) as ValidationRuleResult;\n    // Return any errors or nothing\n    if (minValueResult) return minValueResult;\n    if (maxValueResult) return maxValueResult;\n    return;\n  });\n}\n"],"mappings":"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"}

package/build/rules.d.cts

@@ -1,7 +1,7 @@
 import { FieldsOf } from "./typeMap.cjs";
 import { Changes } from "./changes.cjs";
 import { MaybePromise } from "./utils.cjs";
-import { ReactiveHint } from "./reactiveHints.cjs";
+import { ReactiveHint } from "./reactivity/reactiveHints.cjs";
 import { Entity } from "./Entity.cjs";
 //#region src/rules.d.ts
 declare enum ValidationCode {

package/build/rules.d.mts

@@ -1,7 +1,7 @@
 import { FieldsOf } from "./typeMap.mjs";
 import { Changes } from "./changes.mjs";
 import { MaybePromise } from "./utils.mjs";
-import { ReactiveHint } from "./reactiveHints.mjs";
+import { ReactiveHint } from "./reactivity/reactiveHints.mjs";
 import { Entity } from "./Entity.mjs";
 //#region src/rules.d.ts
 declare enum ValidationCode {

package/build/rules.js

@@ -1,11 +1,10 @@
 import { getField } from "./fields.js";
-import "./typeMap.js";
-import "./changes.js";
 import { isLoadedReference } from "./relations/Reference.js";
-import "./reactiveHints.js";
-import { groupBy, maybePromiseThen } from "./utils.js";
 import { isAsyncReactiveField } from "./relations/AsyncReactiveField.js";
 import "./relations/index.js";
+import { groupBy, maybePromiseThen } from "./utils.js";
+import "./typeMap.js";
+import "./changes.js";
 import { getEmInternalApi } from "./EntityManager.js";
 import "./Entity.js";
 //#region src/rules.ts

package/build/rules.js.map

@@ -1 +1 @@
-{"version":3,"file":"rules.js","names":[],"sources":["../src/rules.ts"],"sourcesContent":["import { type Changes, type EntityChanges } from \"./changes.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { getEmInternalApi } from \"./EntityManager.ts\";\nimport { getField } from \"./fields.ts\";\nimport { type ReactiveHint } from \"./reactiveHints.ts\";\nimport { type ManyToOneReferenceImpl, isAsyncReactiveField, isLoadedReference } from \"./relations/index.ts\";\nimport { type FieldsOf } from \"./typeMap.ts\";\nimport { type MaybePromise, groupBy, maybePromiseThen } from \"./utils.ts\";\n\nexport enum ValidationCode {\n  required = \"required\",\n  cannotBeUpdated = \"not-updatable\",\n  cannotBeChanged = \"not-changeable\",\n  numeric = \"not-numeric\",\n  minValue = \"under-min\",\n  maxValue = \"over-max\",\n}\n\n/**\n * The return type of `ValidationRule` lambdas.\n *\n * We're flexible and allow rules to return a variety of shapes, like just a string, string[], etc.\n *\n * Returning `undefined` means the rule passed.\n */\nexport type ValidationRuleResult = string | string[] | GenericError | GenericError[] | undefined | void;\n\n/** An entity validation rule. */\nexport type ValidationRule<T extends Entity> = (entity: T) => MaybePromise<ValidationRuleResult>;\n\n/** Internal metadata for an async/reactive validation rule. */\nexport type ValidationRuleInternal<T extends Entity> = {\n  name: string;\n  hint: ReactiveHint<T> | undefined;\n  fn: ValidationRule<T>;\n};\n\n/** A generic error which contains a message, and optional field/codes. */\nexport type GenericError = { message: string; field?: string; code?: string };\n\n/** Combines the GenericError with the `entity` that caused it. */\nexport type ValidationError = { entity: Entity } & GenericError;\n\nexport type ValidationRuleOptsFn<T extends Entity> = (entity: T) => MaybePromise<boolean>;\nexport type ValidationRuleOpts<T extends Entity> = {\n  unless?: ValidationRuleOptsFn<T>;\n  if?: ValidationRuleOptsFn<T>;\n};\n\nfunction errorMessage(errors: ValidationError[]): string {\n  if (errors.length === 1) {\n    return `Validation error: ${errors[0].entity.toString()} ${errors[0].message}`;\n  } else {\n    const message = [...groupBy(errors, (e) => e.entity.toString()).entries()]\n      .map(([entityToString, errors]) => `${entityToString} ${errors.map((e) => e.message).join(\", \")}`)\n      .join(\", \");\n    return `Validation errors (${errors.length}): ${message}`;\n  }\n}\n\nexport class ValidationErrors extends Error {\n  public errors: Array<GenericError | ValidationError>;\n  public readonly toJSON: () => string;\n  constructor(errors: ValidationError[]);\n  constructor(message: string);\n  constructor(messageOrErrors: ValidationError[] | string) {\n    super(typeof messageOrErrors === \"string\" ? messageOrErrors : errorMessage(messageOrErrors));\n    this.errors = typeof messageOrErrors === \"string\" ? [{ message: messageOrErrors }] : messageOrErrors;\n    // Jest clones without prototype, so explictly setting this as a property rather than a class method\n    // https://github.com/jestjs/jest/issues/11958\n    this.toJSON = () => `ValidationErrors: ${this.message}`;\n  }\n}\n\nfunction ruleWithOpts<T extends Entity>(\n  opts: ValidationRuleOpts<T> | undefined,\n  fn: (entity: T) => ValidationRuleResult,\n): ValidationRule<T> {\n  return (entity) => {\n    // Since all of our rules are sync, we run the rule first, then check if we should have run it second since this\n    // may be an async operation.  This way we can avoid running promises if we don't have to.\n    const result = fn(entity);\n    if (result === undefined) return;\n    const { unless, if: _if } = opts ?? {};\n    if (unless === undefined && _if === undefined) return result;\n    const shouldRun = [unless ?? (() => false), _if ?? (() => true)].map((fn) => fn(entity));\n    return maybePromiseThen(\n      shouldRun.some((r) => r instanceof Promise) ? Promise.all(shouldRun) : (shouldRun as boolean[]),\n      ([unless, _if]) => (!unless && _if ? result : undefined),\n    );\n  };\n}\n\n/**\n * The fields of `F` that have their own column, i.e. what a required rule can check.\n *\n * The filter is an allow-list (\"keep kinds primitive/enum/m2o/poly\"), not a deny-list (\"drop kind\n * o2o\"), because of how it degrades when `T` is generic/uninferred: `FieldsOf<T>` is then `never`,\n * and `never extends X` is true for any `X`, so an allow-list keeps every key (permissive, exactly\n * like the unfiltered `keyof FieldsOf<T>` before it) while a deny-list would drop every key and\n * break valid calls like `newRequiredRule(\"city\")`.\n */\ntype ColumnBackedFields<F> = {\n  [K in keyof F as F[K] extends { kind: \"primitive\" | \"enum\" | \"m2o\" | \"poly\" } ? K : never]: F[K];\n};\n\n/**\n * Creates a validation rule for required fields.\n *\n * This is added automatically by codegen to entities based on FK not-nulls.\n */\nexport function newRequiredRule<T extends Entity>(\n  key: keyof ColumnBackedFields<FieldsOf<T>> & string,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    // Use getField so that we peer through relations\n    if (getField(entity, key) === undefined) {\n      // Sanity check for AsyncReactiveFields--this should be cheap to just always do; alternatively we could\n      // have a RQF-specific `rqfRequiredRule` so that other `newRequiredRule` users don't pay the cost of these\n      // two `if` checks`.\n      if (entity.isNewEntity && isAsyncReactiveField((entity as any)[key])) {\n        throw new Error(\n          `AsyncReactiveField ${entity.constructor.name}.${key} must have a default value, either in the database or with config.setDefault (see the 4th step in https://joist-orm.io/modeling/reactive-fields/#async-reactive-fields.`,\n        );\n      }\n      return { field: key, code: ValidationCode.required, message: `${key} is required` };\n    }\n  });\n}\n\n/**\n * Like `newRequiredRule`, but for `lazy` columns (i.e. codegen only wires this up for `lazy` fields).\n *\n * On an already-persisted entity that hasn't loaded the column, we skip the check rather than force-load\n * (or falsely fail) a value that was required when the row was last saved. It still fires on create and\n * when the field is explicitly loaded-then-unset.\n */\nexport function newRequiredLazyFieldRule<T extends Entity>(\n  key: keyof FieldsOf<T> & string,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    if (!entity.isNewEntity && !(entity as any)[key].isLoaded) return;\n    if (getField(entity, key) === undefined) {\n      return { field: key, code: ValidationCode.required, message: `${key} is required` };\n    }\n  });\n}\n\n/**\n * Creates a validation rule that a field cannot be updated; it can only be set on creation.\n *\n * If the optional `unless` function returns true, then the update is allowed.\n */\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  opts?: ValidationRuleOpts<T>,\n): CannotBeUpdatedRule<T>;\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  unless?: ValidationRuleOptsFn<T>,\n): CannotBeUpdatedRule<T>;\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  optsOrUnless?: ValidationRuleOpts<T> | ValidationRuleOptsFn<T>,\n): CannotBeUpdatedRule<T> {\n  const opts = typeof optsOrUnless === \"function\" ? { unless: optsOrUnless } : (optsOrUnless ?? {});\n  const fn = ruleWithOpts(opts, (entity: T) => {\n    // For now putting the `EntityChanges` cast here to avoid breaking cannotBeUpdated rules\n    // on base types, see Publisher.ts's `cannotBeUpdated(\"type\")` repro.\n    if ((entity as any as EntityChanges<T>).changes[field].hasUpdated) {\n      const value = (entity as any)[field];\n      // If we're being changed b/c of an em.merge, that is okay\n      if (isLoadedReference(value) && getEmInternalApi(entity.em).isMerging(value.get)) return;\n      return { field, code: ValidationCode.cannotBeUpdated, message: `${field} cannot be updated` };\n    }\n    return;\n  });\n  return Object.assign(fn, { field, immutable: opts.unless === undefined && opts.if === undefined });\n}\n\n/**\n * Creates a validation rule that a field cannot be changed once set.\n *\n * If the optional `unless` function returns true, then the update is allowed.\n */\nexport function cannotBeChanged<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  opts?: ValidationRuleOpts<T>,\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity: T) => {\n    const changes = (entity as any as EntityChanges<T>).changes[field];\n    if (changes.kind === \"m2m\" || changes.kind === \"o2m\" || changes.kind === \"m2mEnum\") {\n      throw new Error(\"cannotBeChanged is only supported on primitive & m2o fields\");\n    } else if (changes.hasUpdated) {\n      const originalValue = changes.originalValue;\n      if (originalValue === undefined) return;\n      const value = getField(entity, field);\n      if (getEmInternalApi(entity.em).isMerging(value)) return;\n      return { field, code: ValidationCode.cannotBeChanged, message: `${field} cannot be changed` };\n    }\n    return;\n  });\n}\n\ntype CannotBeUpdatedRule<T extends Entity> = ValidationRule<T> & { field: string; immutable: boolean };\n\nexport function isCannotBeUpdatedRule(rule: Function): rule is CannotBeUpdatedRule<any> {\n  return \"field\" in rule && \"immutable\" in rule;\n}\n\n/** For STI, enforces subtype-specific relations/FKs at runtime. */\nexport function mustBeSubType<T extends Entity, K extends keyof Changes<T> & string>(\n  relationName: K,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const m2o = (entity as any)[relationName] as ManyToOneReferenceImpl<any, any, any>;\n    const other = m2o.get;\n    const otherCstr = m2o.otherMeta.cstr;\n    if (other && !(other instanceof otherCstr)) {\n      return `${relationName} must be a ${otherCstr.name} not ${other}`;\n    }\n  });\n}\n\n/**\n * Creates a validation rule that a field value cannot be smaller than a\n * certain value.\n *\n * @param field The field to validate\n * @param minValue The inclusive minimum value. e.g 0 range is [0, Infinity]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation\n *\n * @example\n * // Age cannot be smaller than 0\n * config.addRule(minValueRule(\"age\", 0));\n */\nexport function minValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  minValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const value = entity[field];\n    // Ignore undefined and null values. These should be handled by required rules\n    if (value === undefined || value === null) return;\n    // Show an error when the value type is not a number\n    if (typeof value !== \"number\") {\n      return { field, code: ValidationCode.numeric, message: `${field} must be a number` };\n    }\n    // Show an error when the value is smaller than the minimum value\n    if (value < minValue) {\n      return {\n        field,\n        code: ValidationCode.minValue,\n        message: `${field} must be greater than or equal to ${minValue}`,\n      };\n    }\n    return;\n  });\n}\n\n/**\n * Creates a validation rule that a field value cannot be greater than a\n * certain value.\n *\n * @param field The field to validate\n * @param maxValue The include maximum value. e.g 10 range is [-Infinity, 10]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation\n *\n * @example\n * // Age cannot be greater than 150\n * config.addRule(maxValueRule(\"age\", 150));\n */\nexport function maxValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  maxValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const value = entity[field];\n    // Ignore undefined and null values. These should be handled by required rules\n    if (value === undefined || value === null) return;\n    // Show an error when the value type is not a number\n    if (typeof value !== \"number\") {\n      return { field, code: ValidationCode.numeric, message: `${field} must be a number` };\n    }\n    // Show an error when the value is smaller than the minimum value\n    if (value > maxValue) {\n      return {\n        field,\n        code: ValidationCode.maxValue,\n        message: `${field} must be smaller than or equal to ${maxValue}`,\n      };\n    }\n    return;\n  });\n}\n\n/**\n * Creates a validation rule that a field value must be within a range of\n * certain values\n *\n * @param field The field to validate\n * @param minValue The inclusive minimum value. e.g  0 [0,   Infinity]\n * @param maxValue The include maximum value.   e.g 10 [-Infinity, 10]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation * @example\n *\n * // Age must be between 0 and 150\n * config.addRule(rangeValueRule(\"age\", 0, 150));\n */\nexport function rangeValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  minValue: number,\n  maxValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    // Check min and max value rules.  Because these are called without opts, it should be safe to treat them as sync.\n    const minValueResult = minValueRule<T, K>(field, minValue)(entity) as ValidationRuleResult;\n    const maxValueResult = maxValueRule<T, K>(field, maxValue)(entity) as ValidationRuleResult;\n    // Return any errors or nothing\n    if (minValueResult) return minValueResult;\n    if (maxValueResult) return maxValueResult;\n    return;\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"rules.js","names":[],"sources":["../src/rules.ts"],"sourcesContent":["import { type Changes, type EntityChanges } from \"./changes.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { getEmInternalApi } from \"./EntityManager.ts\";\nimport { getField } from \"./fields.ts\";\nimport type { ReactiveHint } from \"./reactivity/reactiveHints.ts\";\nimport { type ManyToOneReferenceImpl, isAsyncReactiveField, isLoadedReference } from \"./relations/index.ts\";\nimport { type FieldsOf } from \"./typeMap.ts\";\nimport { type MaybePromise, groupBy, maybePromiseThen } from \"./utils.ts\";\n\nexport enum ValidationCode {\n  required = \"required\",\n  cannotBeUpdated = \"not-updatable\",\n  cannotBeChanged = \"not-changeable\",\n  numeric = \"not-numeric\",\n  minValue = \"under-min\",\n  maxValue = \"over-max\",\n}\n\n/**\n * The return type of `ValidationRule` lambdas.\n *\n * We're flexible and allow rules to return a variety of shapes, like just a string, string[], etc.\n *\n * Returning `undefined` means the rule passed.\n */\nexport type ValidationRuleResult = string | string[] | GenericError | GenericError[] | undefined | void;\n\n/** An entity validation rule. */\nexport type ValidationRule<T extends Entity> = (entity: T) => MaybePromise<ValidationRuleResult>;\n\n/** Internal metadata for an async/reactive validation rule. */\nexport type ValidationRuleInternal<T extends Entity> = {\n  name: string;\n  hint: ReactiveHint<T> | undefined;\n  fn: ValidationRule<T>;\n};\n\n/** A generic error which contains a message, and optional field/codes. */\nexport type GenericError = { message: string; field?: string; code?: string };\n\n/** Combines the GenericError with the `entity` that caused it. */\nexport type ValidationError = { entity: Entity } & GenericError;\n\nexport type ValidationRuleOptsFn<T extends Entity> = (entity: T) => MaybePromise<boolean>;\nexport type ValidationRuleOpts<T extends Entity> = {\n  unless?: ValidationRuleOptsFn<T>;\n  if?: ValidationRuleOptsFn<T>;\n};\n\nfunction errorMessage(errors: ValidationError[]): string {\n  if (errors.length === 1) {\n    return `Validation error: ${errors[0].entity.toString()} ${errors[0].message}`;\n  } else {\n    const message = [...groupBy(errors, (e) => e.entity.toString()).entries()]\n      .map(([entityToString, errors]) => `${entityToString} ${errors.map((e) => e.message).join(\", \")}`)\n      .join(\", \");\n    return `Validation errors (${errors.length}): ${message}`;\n  }\n}\n\nexport class ValidationErrors extends Error {\n  public errors: Array<GenericError | ValidationError>;\n  public readonly toJSON: () => string;\n  constructor(errors: ValidationError[]);\n  constructor(message: string);\n  constructor(messageOrErrors: ValidationError[] | string) {\n    super(typeof messageOrErrors === \"string\" ? messageOrErrors : errorMessage(messageOrErrors));\n    this.errors = typeof messageOrErrors === \"string\" ? [{ message: messageOrErrors }] : messageOrErrors;\n    // Jest clones without prototype, so explictly setting this as a property rather than a class method\n    // https://github.com/jestjs/jest/issues/11958\n    this.toJSON = () => `ValidationErrors: ${this.message}`;\n  }\n}\n\nfunction ruleWithOpts<T extends Entity>(\n  opts: ValidationRuleOpts<T> | undefined,\n  fn: (entity: T) => ValidationRuleResult,\n): ValidationRule<T> {\n  return (entity) => {\n    // Since all of our rules are sync, we run the rule first, then check if we should have run it second since this\n    // may be an async operation.  This way we can avoid running promises if we don't have to.\n    const result = fn(entity);\n    if (result === undefined) return;\n    const { unless, if: _if } = opts ?? {};\n    if (unless === undefined && _if === undefined) return result;\n    const shouldRun = [unless ?? (() => false), _if ?? (() => true)].map((fn) => fn(entity));\n    return maybePromiseThen(\n      shouldRun.some((r) => r instanceof Promise) ? Promise.all(shouldRun) : (shouldRun as boolean[]),\n      ([unless, _if]) => (!unless && _if ? result : undefined),\n    );\n  };\n}\n\n/**\n * The fields of `F` that have their own column, i.e. what a required rule can check.\n *\n * The filter is an allow-list (\"keep kinds primitive/enum/m2o/poly\"), not a deny-list (\"drop kind\n * o2o\"), because of how it degrades when `T` is generic/uninferred: `FieldsOf<T>` is then `never`,\n * and `never extends X` is true for any `X`, so an allow-list keeps every key (permissive, exactly\n * like the unfiltered `keyof FieldsOf<T>` before it) while a deny-list would drop every key and\n * break valid calls like `newRequiredRule(\"city\")`.\n */\ntype ColumnBackedFields<F> = {\n  [K in keyof F as F[K] extends { kind: \"primitive\" | \"enum\" | \"m2o\" | \"poly\" } ? K : never]: F[K];\n};\n\n/**\n * Creates a validation rule for required fields.\n *\n * This is added automatically by codegen to entities based on FK not-nulls.\n */\nexport function newRequiredRule<T extends Entity>(\n  key: keyof ColumnBackedFields<FieldsOf<T>> & string,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    // Use getField so that we peer through relations\n    if (getField(entity, key) === undefined) {\n      // Sanity check for AsyncReactiveFields--this should be cheap to just always do; alternatively we could\n      // have a RQF-specific `rqfRequiredRule` so that other `newRequiredRule` users don't pay the cost of these\n      // two `if` checks`.\n      if (entity.isNewEntity && isAsyncReactiveField((entity as any)[key])) {\n        throw new Error(\n          `AsyncReactiveField ${entity.constructor.name}.${key} must have a default value, either in the database or with config.setDefault (see the 4th step in https://joist-orm.io/modeling/reactive-fields/#async-reactive-fields.`,\n        );\n      }\n      return { field: key, code: ValidationCode.required, message: `${key} is required` };\n    }\n  });\n}\n\n/**\n * Like `newRequiredRule`, but for `lazy` columns (i.e. codegen only wires this up for `lazy` fields).\n *\n * On an already-persisted entity that hasn't loaded the column, we skip the check rather than force-load\n * (or falsely fail) a value that was required when the row was last saved. It still fires on create and\n * when the field is explicitly loaded-then-unset.\n */\nexport function newRequiredLazyFieldRule<T extends Entity>(\n  key: keyof FieldsOf<T> & string,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    if (!entity.isNewEntity && !(entity as any)[key].isLoaded) return;\n    if (getField(entity, key) === undefined) {\n      return { field: key, code: ValidationCode.required, message: `${key} is required` };\n    }\n  });\n}\n\n/**\n * Creates a validation rule that a field cannot be updated; it can only be set on creation.\n *\n * If the optional `unless` function returns true, then the update is allowed.\n */\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  opts?: ValidationRuleOpts<T>,\n): CannotBeUpdatedRule<T>;\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  unless?: ValidationRuleOptsFn<T>,\n): CannotBeUpdatedRule<T>;\nexport function cannotBeUpdated<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  optsOrUnless?: ValidationRuleOpts<T> | ValidationRuleOptsFn<T>,\n): CannotBeUpdatedRule<T> {\n  const opts = typeof optsOrUnless === \"function\" ? { unless: optsOrUnless } : (optsOrUnless ?? {});\n  const fn = ruleWithOpts(opts, (entity: T) => {\n    // For now putting the `EntityChanges` cast here to avoid breaking cannotBeUpdated rules\n    // on base types, see Publisher.ts's `cannotBeUpdated(\"type\")` repro.\n    if ((entity as any as EntityChanges<T>).changes[field].hasUpdated) {\n      const value = (entity as any)[field];\n      // If we're being changed b/c of an em.merge, that is okay\n      if (isLoadedReference(value) && getEmInternalApi(entity.em).isMerging(value.get)) return;\n      return { field, code: ValidationCode.cannotBeUpdated, message: `${field} cannot be updated` };\n    }\n    return;\n  });\n  return Object.assign(fn, { field, immutable: opts.unless === undefined && opts.if === undefined });\n}\n\n/**\n * Creates a validation rule that a field cannot be changed once set.\n *\n * If the optional `unless` function returns true, then the update is allowed.\n */\nexport function cannotBeChanged<T extends Entity, K extends keyof Changes<T> & string>(\n  field: K,\n  opts?: ValidationRuleOpts<T>,\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity: T) => {\n    const changes = (entity as any as EntityChanges<T>).changes[field];\n    if (changes.kind === \"m2m\" || changes.kind === \"o2m\" || changes.kind === \"m2mEnum\") {\n      throw new Error(\"cannotBeChanged is only supported on primitive & m2o fields\");\n    } else if (changes.hasUpdated) {\n      const originalValue = changes.originalValue;\n      if (originalValue === undefined) return;\n      const value = getField(entity, field);\n      if (getEmInternalApi(entity.em).isMerging(value)) return;\n      return { field, code: ValidationCode.cannotBeChanged, message: `${field} cannot be changed` };\n    }\n    return;\n  });\n}\n\ntype CannotBeUpdatedRule<T extends Entity> = ValidationRule<T> & { field: string; immutable: boolean };\n\nexport function isCannotBeUpdatedRule(rule: Function): rule is CannotBeUpdatedRule<any> {\n  return \"field\" in rule && \"immutable\" in rule;\n}\n\n/** For STI, enforces subtype-specific relations/FKs at runtime. */\nexport function mustBeSubType<T extends Entity, K extends keyof Changes<T> & string>(\n  relationName: K,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const m2o = (entity as any)[relationName] as ManyToOneReferenceImpl<any, any, any>;\n    const other = m2o.get;\n    const otherCstr = m2o.otherMeta.cstr;\n    if (other && !(other instanceof otherCstr)) {\n      return `${relationName} must be a ${otherCstr.name} not ${other}`;\n    }\n  });\n}\n\n/**\n * Creates a validation rule that a field value cannot be smaller than a\n * certain value.\n *\n * @param field The field to validate\n * @param minValue The inclusive minimum value. e.g 0 range is [0, Infinity]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation\n *\n * @example\n * // Age cannot be smaller than 0\n * config.addRule(minValueRule(\"age\", 0));\n */\nexport function minValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  minValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const value = entity[field];\n    // Ignore undefined and null values. These should be handled by required rules\n    if (value === undefined || value === null) return;\n    // Show an error when the value type is not a number\n    if (typeof value !== \"number\") {\n      return { field, code: ValidationCode.numeric, message: `${field} must be a number` };\n    }\n    // Show an error when the value is smaller than the minimum value\n    if (value < minValue) {\n      return {\n        field,\n        code: ValidationCode.minValue,\n        message: `${field} must be greater than or equal to ${minValue}`,\n      };\n    }\n    return;\n  });\n}\n\n/**\n * Creates a validation rule that a field value cannot be greater than a\n * certain value.\n *\n * @param field The field to validate\n * @param maxValue The include maximum value. e.g 10 range is [-Infinity, 10]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation\n *\n * @example\n * // Age cannot be greater than 150\n * config.addRule(maxValueRule(\"age\", 150));\n */\nexport function maxValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  maxValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    const value = entity[field];\n    // Ignore undefined and null values. These should be handled by required rules\n    if (value === undefined || value === null) return;\n    // Show an error when the value type is not a number\n    if (typeof value !== \"number\") {\n      return { field, code: ValidationCode.numeric, message: `${field} must be a number` };\n    }\n    // Show an error when the value is smaller than the minimum value\n    if (value > maxValue) {\n      return {\n        field,\n        code: ValidationCode.maxValue,\n        message: `${field} must be smaller than or equal to ${maxValue}`,\n      };\n    }\n    return;\n  });\n}\n\n/**\n * Creates a validation rule that a field value must be within a range of\n * certain values\n *\n * @param field The field to validate\n * @param minValue The inclusive minimum value. e.g  0 [0,   Infinity]\n * @param maxValue The include maximum value.   e.g 10 [-Infinity, 10]\n * @param opts Optional validation rule options that control when the rule should run:\n *   - unless: Function that returns true to skip validation\n *   - if: Function that returns true to run validation * @example\n *\n * // Age must be between 0 and 150\n * config.addRule(rangeValueRule(\"age\", 0, 150));\n */\nexport function rangeValueRule<T extends Entity, K extends keyof T & string>(\n  field: K,\n  minValue: number,\n  maxValue: number,\n  opts: ValidationRuleOpts<T> = {},\n): ValidationRule<T> {\n  return ruleWithOpts(opts, (entity) => {\n    // Check min and max value rules.  Because these are called without opts, it should be safe to treat them as sync.\n    const minValueResult = minValueRule<T, K>(field, minValue)(entity) as ValidationRuleResult;\n    const maxValueResult = maxValueRule<T, K>(field, maxValue)(entity) as ValidationRuleResult;\n    // Return any errors or nothing\n    if (minValueResult) return minValueResult;\n    if (maxValueResult) return maxValueResult;\n    return;\n  });\n}\n"],"mappings":"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"}

package/build/{TypeInfo.cjs → serde/TypeInfo.cjs}

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/TypeInfo.ts
+//#region src/serde/TypeInfo.ts
 /**
 * Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.
 * The output compatibility checks compare these names, so normalize only spellings of the same type.

package/build/serde/TypeInfo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.cjs","names":[],"sources":["../../src/serde/TypeInfo.ts"],"sourcesContent":["// Keep compatibility metadata a runtime leaf in both CJS and ESM builds.\nimport type { EntityMetadata } from \"../EntityMetadata.ts\";\n\n/**\n * Runtime proof that values can share scalar conversions.\n *\n * PostgreSQL compares projected SQL rows and chooses a common SQL type before Joist decodes them.\n * A compound uses one decoder per output column and retains an encoder for later comparisons and\n * coalesce fallbacks. TypeScript result types are erased, and equal SQL storage types do not imply\n * equal logical domains.\n *\n * I.e. Author.id and Book.author_id are compatible Author IDs despite having separate serdes, while\n * Book.id must not decode as an Author ID just because both use int4. Author.age and Author.age.sum()\n * both expose TypeScript numbers but produce int4 and int8 driver values. Enum, custom-mapper, and\n * JSON-schema domain tokens also prevent unrelated conversions from mixing.\n *\n * Compatibility requires exact equality of canonical `dbType`, `domain`, and `idMeta`. An absent\n * descriptor is unknown, not an identity codec. `idMeta` identifies scalar IDs only; arrays retain\n * their element domain separately so they cannot select a polymorphic IN component. Raw `sql<R>`\n * annotations supply no runtime evidence. This descriptor does not implement conversions.\n */\nexport interface TypeInfo {\n  dbType: string;\n  domain: unknown;\n  idMeta?: EntityMetadata;\n  /** Internal conversion proof, consistent for equal dbType/domain/idMeta; not another compatibility key. */\n  arrayElementSafe?: boolean;\n}\n\n/**\n * Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.\n * The output compatibility checks compare these names, so normalize only spellings of the same type.\n *\n * I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.\n * Keeping these spellings distinct would reject compatible outputs just because their serdes use\n * different names for the same representation.\n *\n * I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number\n * and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder\n * cannot handle the common SQL type. This function does not choose or apply a conversion.\n *\n * I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,\n * which matters when a set operation compares rows. A user-defined `app.email` domain over text can\n * also impose constraints that text does not. Unknown names remain unchanged, including their schema\n * and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.\n */\nexport function canonicalDbType(dbType: string): string {\n  if (dbType.endsWith(\"[]\")) return `${canonicalDbType(dbType.slice(0, -2))}[]`;\n  switch (dbType) {\n    case \"smallint\":\n      return \"int2\";\n    case \"int\":\n    case \"integer\":\n      return \"int4\";\n    case \"bigint\":\n      return \"int8\";\n    case \"decimal\":\n      return \"numeric\";\n    case \"real\":\n      return \"float4\";\n    case \"double precision\":\n      return \"float8\";\n    case \"boolean\":\n      return \"bool\";\n    case \"character varying\":\n      return \"varchar\";\n    case \"character\":\n      return \"bpchar\";\n    case \"timestamp without time zone\":\n      return \"timestamp\";\n    case \"timestamp with time zone\":\n      return \"timestamptz\";\n    case \"time without time zone\":\n      return \"time\";\n    case \"time with time zone\":\n      return \"timetz\";\n    default:\n      return dbType;\n  }\n}\n\nconst arrayDomains = new Map<unknown, Map<EntityMetadata | undefined, symbol>>();\n\n// Both classic pg and lazy binary reads decode these physical arrays, not an unparsed array string.\nconst arrayElementDbTypes = new Set([\n  \"bool\",\n  \"bytea\",\n  \"int2\",\n  \"int4\",\n  \"int8\",\n  \"float4\",\n  \"float8\",\n  \"numeric\",\n  \"text\",\n  \"varchar\",\n  \"bpchar\",\n  \"uuid\",\n  \"json\",\n  \"jsonb\",\n]);\n\n/**\n * Describes elementwise conversion only for known physical array parsers and stable domain conversion.\n *\n * I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar\n * `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.\n * Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers\n * in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.\n */\nexport function arrayOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined {\n  if (!outputType?.arrayElementSafe || !arrayElementDbTypes.has(outputType.dbType)) return undefined;\n  let domains = arrayDomains.get(outputType.domain);\n  if (!domains) arrayDomains.set(outputType.domain, (domains = new Map()));\n  let domain = domains.get(outputType.idMeta);\n  if (!domain) domains.set(outputType.idMeta, (domain = Symbol(\"joist.arrayOutput\")));\n  return { dbType: `${outputType.dbType}[]`, domain };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,gBAAgB,QAAwB;CACtD,IAAI,OAAO,SAAS,IAAI,GAAG,OAAO,GAAG,gBAAgB,OAAO,MAAM,GAAG,EAAE,CAAC,EAAE;CAC1E,QAAQ,QAAR;EACE,KAAK,YACH,OAAO;EACT,KAAK;EACL,KAAK,WACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,oBACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,qBACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,KAAK,+BACH,OAAO;EACT,KAAK,4BACH,OAAO;EACT,KAAK,0BACH,OAAO;EACT,KAAK,uBACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AAEA,MAAM,+BAAe,IAAI,IAAsD;AAG/E,MAAM,sCAAsB,IAAI,IAAI;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;;;AAUD,SAAgB,gBAAgB,YAAwD;CACtF,IAAI,CAAC,YAAY,oBAAoB,CAAC,oBAAoB,IAAI,WAAW,MAAM,GAAG,OAAO,KAAA;CACzF,IAAI,UAAU,aAAa,IAAI,WAAW,MAAM;CAChD,IAAI,CAAC,SAAS,aAAa,IAAI,WAAW,QAAS,0BAAU,IAAI,IAAI,CAAE;CACvE,IAAI,SAAS,QAAQ,IAAI,WAAW,MAAM;CAC1C,IAAI,CAAC,QAAQ,QAAQ,IAAI,WAAW,QAAS,SAAS,OAAO,mBAAmB,CAAE;CAClF,OAAO;EAAE,QAAQ,GAAG,WAAW,OAAO;EAAK;CAAO;AACpD"}

package/build/{TypeInfo.d.cts → serde/TypeInfo.d.cts}

@@ -1,5 +1,5 @@
-import { EntityMetadata } from "./EntityMetadata.cjs";
-//#region src/TypeInfo.d.ts
+import { EntityMetadata } from "../EntityMetadata.cjs";
+//#region src/serde/TypeInfo.d.ts
 /**
  * Runtime proof that values can share scalar conversions.
  *

package/build/serde/TypeInfo.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.d.cts","names":[],"sources":["../../src/serde/TypeInfo.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAqBiB;EACf;EACA;EACA,SAAS;;EAET;;;;;;;;;;;;;;;;;;;iBAoBc,gBAAgB;;;;;;;;;iBA+DhB,gBAAgB,YAAY,uBAAuB"}

package/build/{TypeInfo.d.mts → serde/TypeInfo.d.mts}

@@ -1,5 +1,5 @@
-import { EntityMetadata } from "./EntityMetadata.mjs";
-//#region src/TypeInfo.d.ts
+import { EntityMetadata } from "../EntityMetadata.mjs";
+//#region src/serde/TypeInfo.d.ts
 /**
  * Runtime proof that values can share scalar conversions.
  *

package/build/serde/TypeInfo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.d.mts","names":[],"sources":["../../src/serde/TypeInfo.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAqBiB;EACf;EACA;EACA,SAAS;;EAET;;;;;;;;;;;;;;;;;;;iBAoBc,gBAAgB;;;;;;;;;iBA+DhB,gBAAgB,YAAY,uBAAuB"}