joist-orm 0.1.536 → 1.0.0

package/build/src/relations/Reference.d.ts

@@ -0,0 +1,29 @@
+import { Entity, IdOf } from "../EntityManager";
+import { Relation } from "./Relation";
+export declare const ReferenceN: unique symbol;
+/**
+ * A many-to-one / foreign key from `T` to `U`, i.e. book to author.
+ *
+ * The `N` generic is for whether the field is optional (i.e. the foreign key column is
+ * nullable). If it is optional, `N` will be `undefined`, which makes the return types
+ * `U | undefined`. If it is not optional, `N` will be `never`, making the return types
+ * `U | never` which becomes just `U`.
+ */
+export interface Reference<T extends Entity, U extends Entity, N extends never | undefined> extends Relation<T, U> {
+    readonly isLoaded: boolean;
+    load(opts?: {
+        withDeleted: boolean;
+    }): Promise<U | N>;
+    set(other: U | N): void;
+    [ReferenceN]: N;
+}
+/** Adds a known-safe `get` accessor. */
+export interface LoadedReference<T extends Entity, U extends Entity, N extends never | undefined> extends Reference<T, U, N> {
+    id: IdOf<U> | N;
+    get: U | N;
+    getWithDeleted: U | N;
+}
+/** Type guard utility for determining if an entity field is a Reference. */
+export declare function isReference(maybeReference: any): maybeReference is Reference<any, any, any>;
+/** Type guard utility for determining if an entity field is a loaded Reference. */
+export declare function isLoadedReference(maybeReference: any): maybeReference is Reference<any, any, any> & LoadedReference<any, any, any>;

package/build/src/relations/Reference.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoadedReference = exports.isReference = exports.ReferenceN = void 0;
+const CustomReference_1 = require("./CustomReference");
+const ManyToOneReference_1 = require("./ManyToOneReference");
+const OneToOneReference_1 = require("./OneToOneReference");
+const PolymorphicReference_1 = require("./PolymorphicReference");
+// Exported and used in sub-interfaces/types per https://stackoverflow.com/a/70437874/355031
+exports.ReferenceN = Symbol();
+/** Type guard utility for determining if an entity field is a Reference. */
+function isReference(maybeReference) {
+    return (maybeReference instanceof OneToOneReference_1.OneToOneReferenceImpl ||
+        maybeReference instanceof ManyToOneReference_1.ManyToOneReferenceImpl ||
+        maybeReference instanceof CustomReference_1.CustomReference ||
+        maybeReference instanceof PolymorphicReference_1.PolymorphicReferenceImpl);
+}
+exports.isReference = isReference;
+/** Type guard utility for determining if an entity field is a loaded Reference. */
+function isLoadedReference(maybeReference) {
+    return isReference(maybeReference) && maybeReference.isLoaded;
+}
+exports.isLoadedReference = isLoadedReference;
+//# sourceMappingURL=Reference.js.map

package/build/src/relations/Reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Reference.js","sourceRoot":"","sources":["../../../src/relations/Reference.ts"],"names":[],"mappings":";;;AACA,uDAAoD;AACpD,6DAA8D;AAC9D,2DAA4D;AAC5D,iEAAkE;AAGlE,4FAA4F;AAC/E,QAAA,UAAU,GAAG,MAAM,EAAE,CAAC;AAqCnC,4EAA4E;AAC5E,SAAgB,WAAW,CAAC,cAAmB;IAC7C,OAAO,CACL,cAAc,YAAY,yCAAqB;QAC/C,cAAc,YAAY,2CAAsB;QAChD,cAAc,YAAY,iCAAe;QACzC,cAAc,YAAY,+CAAwB,CACnD,CAAC;AACJ,CAAC;AAPD,kCAOC;AAED,mFAAmF;AACnF,SAAgB,iBAAiB,CAC/B,cAAmB;IAEnB,OAAO,WAAW,CAAC,cAAc,CAAC,IAAI,cAAc,CAAC,QAAQ,CAAC;AAChE,CAAC;AAJD,8CAIC"}

package/build/src/relations/Relation.d.ts

@@ -0,0 +1,10 @@
+import { Entity } from "../EntityManager";
+export declare const RelationT: unique symbol;
+export declare const RelationU: unique symbol;
+/** A relationship from `T` to `U`, could be any of many-to-one, one-to-many, or many-to-many. */
+export interface Relation<T extends Entity, U extends Entity> {
+    [RelationT]: T;
+    [RelationU]: U;
+}
+/** Type guard utility for determining if an entity field is a Relation. */
+export declare function isRelation(maybeRelation: any): maybeRelation is Relation<any, any>;

package/build/src/relations/Relation.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelation = exports.RelationU = exports.RelationT = void 0;
+const Collection_1 = require("./Collection");
+const Reference_1 = require("./Reference");
+exports.RelationT = Symbol();
+exports.RelationU = Symbol();
+/** Type guard utility for determining if an entity field is a Relation. */
+function isRelation(maybeRelation) {
+    return (0, Reference_1.isReference)(maybeRelation) || (0, Collection_1.isCollection)(maybeRelation);
+}
+exports.isRelation = isRelation;
+//# sourceMappingURL=Relation.js.map

package/build/src/relations/Relation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Relation.js","sourceRoot":"","sources":["../../../src/relations/Relation.ts"],"names":[],"mappings":";;;AACA,6CAA4C;AAC5C,2CAA0C;AAE7B,QAAA,SAAS,GAAG,MAAM,EAAE,CAAC;AACrB,QAAA,SAAS,GAAG,MAAM,EAAE,CAAC;AAclC,2EAA2E;AAC3E,SAAgB,UAAU,CAAC,aAAkB;IAC3C,OAAO,IAAA,uBAAW,EAAC,aAAa,CAAC,IAAI,IAAA,yBAAY,EAAC,aAAa,CAAC,CAAC;AACnE,CAAC;AAFD,gCAEC"}

package/build/src/relations/hasAsyncProperty.d.ts

@@ -0,0 +1,36 @@
+import { Entity } from "../EntityManager";
+import { Loaded, LoadHint } from "../loaded";
+declare const I: unique symbol;
+export interface AsyncProperty<T extends Entity, V> {
+    isLoaded: boolean;
+    load(): Promise<V>;
+    [I]?: T;
+}
+export interface LoadedProperty<T extends Entity, V> {
+    get: V;
+}
+/**
+ * Creates a calculated derived value from a load hint + lambda.
+ *
+ * The property can be accessed by default as a promise, with `someProperty.load()`.
+ *
+ * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
+ * with `someProperty.get`.
+ */
+export declare function hasAsyncProperty<T extends Entity, H extends LoadHint<T>, V>(loadHint: H, fn: (entity: Loaded<T, H>) => V): AsyncProperty<T, V>;
+export declare class AsyncPropertyImpl<T extends Entity, H extends LoadHint<T>, V> implements AsyncProperty<T, V> {
+    private entity;
+    private loadHint;
+    private fn;
+    private loaded;
+    private loadPromise;
+    constructor(entity: T, loadHint: H, fn: (entity: Loaded<T, H>) => V);
+    load(): Promise<V>;
+    get get(): V;
+    get isLoaded(): boolean;
+}
+/** Type guard utility for determining if an entity field is an AsyncProperty. */
+export declare function isAsyncProperty(maybeAsyncProperty: any): maybeAsyncProperty is AsyncProperty<any, any>;
+/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
+export declare function isLoadedAsyncProperty(maybeAsyncProperty: any): maybeAsyncProperty is AsyncProperty<any, any> & LoadedProperty<any, any>;
+export {};

package/build/src/relations/hasAsyncProperty.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoadedAsyncProperty = exports.isAsyncProperty = exports.AsyncPropertyImpl = exports.hasAsyncProperty = void 0;
+const EntityManager_1 = require("../EntityManager");
+const I = Symbol();
+/**
+ * Creates a calculated derived value from a load hint + lambda.
+ *
+ * The property can be accessed by default as a promise, with `someProperty.load()`.
+ *
+ * But if `someProperty` is used as a populate hint, then it can be accessed synchronously,
+ * with `someProperty.get`.
+ */
+function hasAsyncProperty(loadHint, fn) {
+    const entity = EntityManager_1.currentlyInstantiatingEntity;
+    return new AsyncPropertyImpl(entity, loadHint, fn);
+}
+exports.hasAsyncProperty = hasAsyncProperty;
+class AsyncPropertyImpl {
+    constructor(entity, loadHint, fn) {
+        this.entity = entity;
+        this.loadHint = loadHint;
+        this.fn = fn;
+        this.loaded = false;
+    }
+    load() {
+        const { entity, loadHint, fn } = this;
+        if (!this.loaded) {
+            return (this.loadPromise ?? (this.loadPromise = entity.em.populate(entity, loadHint).then((loaded) => {
+                this.loaded = true;
+                return fn(loaded);
+            })));
+        }
+        return Promise.resolve(this.get);
+    }
+    get get() {
+        const { entity, fn } = this;
+        return fn(entity);
+    }
+    get isLoaded() {
+        return this.loaded;
+    }
+}
+exports.AsyncPropertyImpl = AsyncPropertyImpl;
+/** Type guard utility for determining if an entity field is an AsyncProperty. */
+function isAsyncProperty(maybeAsyncProperty) {
+    return maybeAsyncProperty instanceof AsyncPropertyImpl;
+}
+exports.isAsyncProperty = isAsyncProperty;
+/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
+function isLoadedAsyncProperty(maybeAsyncProperty) {
+    return isAsyncProperty(maybeAsyncProperty) && maybeAsyncProperty.isLoaded;
+}
+exports.isLoadedAsyncProperty = isLoadedAsyncProperty;
+//# sourceMappingURL=hasAsyncProperty.js.map

package/build/src/relations/hasAsyncProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasAsyncProperty.js","sourceRoot":"","sources":["../../../src/relations/hasAsyncProperty.ts"],"names":[],"mappings":";;;AAAA,oDAAwE;AAGxE,MAAM,CAAC,GAAG,MAAM,EAAE,CAAC;AAYnB;;;;;;;GAOG;AACH,SAAgB,gBAAgB,CAC9B,QAAW,EACX,EAA+B;IAE/B,MAAM,MAAM,GAAG,4CAAiC,CAAC;IACjD,OAAO,IAAI,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;AACrD,CAAC;AAND,4CAMC;AAED,MAAa,iBAAiB;IAG5B,YAAoB,MAAS,EAAU,QAAW,EAAU,EAA+B;QAAvE,WAAM,GAAN,MAAM,CAAG;QAAU,aAAQ,GAAR,QAAQ,CAAG;QAAU,OAAE,GAAF,EAAE,CAA6B;QAFnF,WAAM,GAAG,KAAK,CAAC;IAEuE,CAAC;IAE/F,IAAI;QACF,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC;QACtC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,OAAO,CAAC,IAAI,CAAC,WAAW,KAAhB,IAAI,CAAC,WAAW,GAAK,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;gBAChF,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;gBACnB,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;YACpB,CAAC,CAAC,EAAC,CAAC;SACL;QACD,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,GAAG;QACL,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC;QAC5B,OAAO,EAAE,CAAC,MAAsB,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;CACF;AAxBD,8CAwBC;AAED,iFAAiF;AACjF,SAAgB,eAAe,CAAC,kBAAuB;IACrD,OAAO,kBAAkB,YAAY,iBAAiB,CAAC;AACzD,CAAC;AAFD,0CAEC;AAED,uFAAuF;AACvF,SAAgB,qBAAqB,CACnC,kBAAuB;IAEvB,OAAO,eAAe,CAAC,kBAAkB,CAAC,IAAI,kBAAkB,CAAC,QAAQ,CAAC;AAC5E,CAAC;AAJD,sDAIC"}

package/build/{collections → src/relations}/hasManyDerived.d.ts

@@ -1,5 +1,6 @@
 import { Collection } from "../";
-import { Entity, Loaded, LoadHint } from "../EntityManager";
+import { Entity } from "../EntityManager";
+import { Loaded, LoadHint } from "../loaded";
 declare type HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T>> = {
     load?: (entity: T) => Promise<any>;
     get: (entity: Loaded<T, H>) => readonly U[];

package/build/{collections → src/relations}/hasManyDerived.js

@@ -14,7 +14,7 @@ function hasManyDerived(loadHint, opts) {
     const entity = __1.currentlyInstantiatingEntity;
     const { load, ...rest } = opts;
     return new CustomCollection_1.CustomCollection(entity, {
-        load: load !== null && load !== void 0 ? load : ((entity) => __1.getEm(entity).populate(entity, loadHint)),
+        load: load ?? ((entity) => entity.em.populate(entity, loadHint)),
         ...rest,
     });
 }

package/build/src/relations/hasManyDerived.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasManyDerived.js","sourceRoot":"","sources":["../../../src/relations/hasManyDerived.ts"],"names":[],"mappings":";;;AAAA,2BAA+D;AAG/D,yDAAsD;AAUtD;;;;;;GAMG;AACH,SAAgB,cAAc,CAC5B,QAAW,EACX,IAAiC;IAEjC,MAAM,MAAM,GAAM,gCAAiC,CAAC;IACpD,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;IAC/B,OAAO,IAAI,mCAAgB,CAAO,MAAM,EAAE;QACxC,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAChE,GAAI,IAAY;KACjB,CAAC,CAAC;AACL,CAAC;AAVD,wCAUC"}

package/build/{collections → src/relations}/hasManyThrough.js

@@ -13,9 +13,9 @@ function hasManyThrough(lens) {
     const entity = index_1.currentlyInstantiatingEntity;
     return new index_1.CustomCollection(entity, {
         load: async (entity) => {
-            await index_1.loadLens(entity, lens);
+            await (0, index_1.loadLens)(entity, lens);
         },
-        get: () => index_1.getLens(entity, lens),
+        get: () => (0, index_1.getLens)(entity, lens),
     });
 }
 exports.hasManyThrough = hasManyThrough;

package/build/src/relations/hasManyThrough.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasManyThrough.js","sourceRoot":"","sources":["../../../src/relations/hasManyThrough.ts"],"names":[],"mappings":";;;AAAA,oCAAuH;AAEvH;;;;;;GAMG;AACH,SAAgB,cAAc,CAC5B,IAAqC;IAErC,MAAM,MAAM,GAAM,oCAAiC,CAAC;IACpD,OAAO,IAAI,wBAAgB,CAAO,MAAM,EAAE;QACxC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YACrB,MAAM,IAAA,gBAAQ,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC/B,CAAC;QACD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAA,eAAO,EAAC,MAAM,EAAE,IAAI,CAAC;KACjC,CAAC,CAAC;AACL,CAAC;AAVD,wCAUC"}

package/build/{collections → src/relations}/hasOneDerived.d.ts

@@ -1,5 +1,6 @@
-import { Reference } from "../";
-import { Entity, Loaded, LoadHint } from "../EntityManager";
+import { Entity } from "../EntityManager";
+import { Loaded, LoadHint } from "../loaded";
+import { Reference } from "./Reference";
 /**
  * Creates a CustomReference that can conditionally walk across references in the object graph.
  *

package/build/{collections → src/relations}/hasOneDerived.js

@@ -14,7 +14,7 @@ function hasOneDerived(loadHint, get) {
     const entity = __1.currentlyInstantiatingEntity;
     return new CustomReference_1.CustomReference(entity, {
         load: async (entity) => {
-            await __1.getEm(entity).populate(entity, loadHint);
+            await entity.em.populate(entity, loadHint);
         },
         get: () => get(entity),
     });

package/build/src/relations/hasOneDerived.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasOneDerived.js","sourceRoot":"","sources":["../../../src/relations/hasOneDerived.ts"],"names":[],"mappings":";;;AAAA,2BAAmD;AAGnD,uDAAoD;AAGpD;;;;;;GAMG;AACH,SAAgB,aAAa,CAM3B,QAAW,EAAE,GAAgC;IAC7C,MAAM,MAAM,GAAM,gCAAiC,CAAC;IACpD,OAAO,IAAI,iCAAe,CAAU,MAAM,EAAE;QAC1C,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YACrB,MAAM,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAC7C,CAAC;QACD,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,MAAsB,CAAC;KACvC,CAAC,CAAC;AACL,CAAC;AAdD,sCAcC"}

package/build/{collections → src/relations}/hasOneThrough.js

@@ -13,9 +13,9 @@ function hasOneThrough(lens) {
     const entity = index_1.currentlyInstantiatingEntity;
     return new index_1.CustomReference(entity, {
         load: async (entity) => {
-            await index_1.loadLens(entity, lens);
+            await (0, index_1.loadLens)(entity, lens);
         },
-        get: () => index_1.getLens(entity, lens),
+        get: () => (0, index_1.getLens)(entity, lens),
     });
 }
 exports.hasOneThrough = hasOneThrough;

package/build/src/relations/hasOneThrough.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasOneThrough.js","sourceRoot":"","sources":["../../../src/relations/hasOneThrough.ts"],"names":[],"mappings":";;;AAAA,oCAAqH;AAErH;;;;;;GAMG;AACH,SAAgB,aAAa,CAC3B,IAAgC;IAEhC,MAAM,MAAM,GAAM,oCAAiC,CAAC;IACpD,OAAO,IAAI,uBAAe,CAAU,MAAM,EAAE;QAC1C,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YACrB,MAAM,IAAA,gBAAQ,EAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC/B,CAAC;QACD,GAAG,EAAE,GAAG,EAAE,CAAC,IAAA,eAAO,EAAC,MAAM,EAAE,IAAI,CAAC;KACjC,CAAC,CAAC;AACL,CAAC;AAVD,sCAUC"}

package/build/src/relations/index.d.ts

@@ -0,0 +1,18 @@
+export { Collection, isCollection, isLoadedCollection, LoadedCollection } from "./Collection";
+export { CustomCollection } from "./CustomCollection";
+export { CustomReference } from "./CustomReference";
+export { AsyncProperty, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty, LoadedProperty, } from "./hasAsyncProperty";
+export { hasManyDerived } from "./hasManyDerived";
+export { hasManyThrough } from "./hasManyThrough";
+export { hasOneDerived } from "./hasOneDerived";
+export { hasOneThrough } from "./hasOneThrough";
+export { LargeCollection } from "./LargeCollection";
+export { hasManyToMany, ManyToManyCollection } from "./ManyToManyCollection";
+export { hasLargeManyToMany, ManyToManyLargeCollection } from "./ManyToManyLargeCollection";
+export { hasOne, isManyToOneReference, ManyToOneReference, ManyToOneReferenceImpl } from "./ManyToOneReference";
+export { hasMany, OneToManyCollection } from "./OneToManyCollection";
+export { hasLargeMany, OneToManyLargeCollection } from "./OneToManyLargeCollection";
+export { hasOneToOne, isLoadedOneToOneReference, isOneToOneReference, OneToOneReference, OneToOneReferenceImpl, } from "./OneToOneReference";
+export { hasOnePolymorphic, isPolymorphicReference, PolymorphicReference, PolymorphicReferenceImpl, } from "./PolymorphicReference";
+export { isLoadedReference, isReference, LoadedReference, Reference } from "./Reference";
+export { isRelation, Relation } from "./Relation";

package/build/src/relations/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelation = exports.isReference = exports.isLoadedReference = exports.PolymorphicReferenceImpl = exports.isPolymorphicReference = exports.hasOnePolymorphic = exports.OneToOneReferenceImpl = exports.isOneToOneReference = exports.isLoadedOneToOneReference = exports.hasOneToOne = exports.OneToManyLargeCollection = exports.hasLargeMany = exports.OneToManyCollection = exports.hasMany = exports.ManyToOneReferenceImpl = exports.isManyToOneReference = exports.hasOne = exports.ManyToManyLargeCollection = exports.hasLargeManyToMany = exports.ManyToManyCollection = exports.hasManyToMany = exports.hasOneThrough = exports.hasOneDerived = exports.hasManyThrough = exports.hasManyDerived = exports.isLoadedAsyncProperty = exports.isAsyncProperty = exports.hasAsyncProperty = exports.CustomReference = exports.CustomCollection = exports.isLoadedCollection = exports.isCollection = void 0;
+var Collection_1 = require("./Collection");
+Object.defineProperty(exports, "isCollection", { enumerable: true, get: function () { return Collection_1.isCollection; } });
+Object.defineProperty(exports, "isLoadedCollection", { enumerable: true, get: function () { return Collection_1.isLoadedCollection; } });
+var CustomCollection_1 = require("./CustomCollection");
+Object.defineProperty(exports, "CustomCollection", { enumerable: true, get: function () { return CustomCollection_1.CustomCollection; } });
+var CustomReference_1 = require("./CustomReference");
+Object.defineProperty(exports, "CustomReference", { enumerable: true, get: function () { return CustomReference_1.CustomReference; } });
+var hasAsyncProperty_1 = require("./hasAsyncProperty");
+Object.defineProperty(exports, "hasAsyncProperty", { enumerable: true, get: function () { return hasAsyncProperty_1.hasAsyncProperty; } });
+Object.defineProperty(exports, "isAsyncProperty", { enumerable: true, get: function () { return hasAsyncProperty_1.isAsyncProperty; } });
+Object.defineProperty(exports, "isLoadedAsyncProperty", { enumerable: true, get: function () { return hasAsyncProperty_1.isLoadedAsyncProperty; } });
+var hasManyDerived_1 = require("./hasManyDerived");
+Object.defineProperty(exports, "hasManyDerived", { enumerable: true, get: function () { return hasManyDerived_1.hasManyDerived; } });
+var hasManyThrough_1 = require("./hasManyThrough");
+Object.defineProperty(exports, "hasManyThrough", { enumerable: true, get: function () { return hasManyThrough_1.hasManyThrough; } });
+var hasOneDerived_1 = require("./hasOneDerived");
+Object.defineProperty(exports, "hasOneDerived", { enumerable: true, get: function () { return hasOneDerived_1.hasOneDerived; } });
+var hasOneThrough_1 = require("./hasOneThrough");
+Object.defineProperty(exports, "hasOneThrough", { enumerable: true, get: function () { return hasOneThrough_1.hasOneThrough; } });
+var ManyToManyCollection_1 = require("./ManyToManyCollection");
+Object.defineProperty(exports, "hasManyToMany", { enumerable: true, get: function () { return ManyToManyCollection_1.hasManyToMany; } });
+Object.defineProperty(exports, "ManyToManyCollection", { enumerable: true, get: function () { return ManyToManyCollection_1.ManyToManyCollection; } });
+var ManyToManyLargeCollection_1 = require("./ManyToManyLargeCollection");
+Object.defineProperty(exports, "hasLargeManyToMany", { enumerable: true, get: function () { return ManyToManyLargeCollection_1.hasLargeManyToMany; } });
+Object.defineProperty(exports, "ManyToManyLargeCollection", { enumerable: true, get: function () { return ManyToManyLargeCollection_1.ManyToManyLargeCollection; } });
+var ManyToOneReference_1 = require("./ManyToOneReference");
+Object.defineProperty(exports, "hasOne", { enumerable: true, get: function () { return ManyToOneReference_1.hasOne; } });
+Object.defineProperty(exports, "isManyToOneReference", { enumerable: true, get: function () { return ManyToOneReference_1.isManyToOneReference; } });
+Object.defineProperty(exports, "ManyToOneReferenceImpl", { enumerable: true, get: function () { return ManyToOneReference_1.ManyToOneReferenceImpl; } });
+var OneToManyCollection_1 = require("./OneToManyCollection");
+Object.defineProperty(exports, "hasMany", { enumerable: true, get: function () { return OneToManyCollection_1.hasMany; } });
+Object.defineProperty(exports, "OneToManyCollection", { enumerable: true, get: function () { return OneToManyCollection_1.OneToManyCollection; } });
+var OneToManyLargeCollection_1 = require("./OneToManyLargeCollection");
+Object.defineProperty(exports, "hasLargeMany", { enumerable: true, get: function () { return OneToManyLargeCollection_1.hasLargeMany; } });
+Object.defineProperty(exports, "OneToManyLargeCollection", { enumerable: true, get: function () { return OneToManyLargeCollection_1.OneToManyLargeCollection; } });
+var OneToOneReference_1 = require("./OneToOneReference");
+Object.defineProperty(exports, "hasOneToOne", { enumerable: true, get: function () { return OneToOneReference_1.hasOneToOne; } });
+Object.defineProperty(exports, "isLoadedOneToOneReference", { enumerable: true, get: function () { return OneToOneReference_1.isLoadedOneToOneReference; } });
+Object.defineProperty(exports, "isOneToOneReference", { enumerable: true, get: function () { return OneToOneReference_1.isOneToOneReference; } });
+Object.defineProperty(exports, "OneToOneReferenceImpl", { enumerable: true, get: function () { return OneToOneReference_1.OneToOneReferenceImpl; } });
+var PolymorphicReference_1 = require("./PolymorphicReference");
+Object.defineProperty(exports, "hasOnePolymorphic", { enumerable: true, get: function () { return PolymorphicReference_1.hasOnePolymorphic; } });
+Object.defineProperty(exports, "isPolymorphicReference", { enumerable: true, get: function () { return PolymorphicReference_1.isPolymorphicReference; } });
+Object.defineProperty(exports, "PolymorphicReferenceImpl", { enumerable: true, get: function () { return PolymorphicReference_1.PolymorphicReferenceImpl; } });
+var Reference_1 = require("./Reference");
+Object.defineProperty(exports, "isLoadedReference", { enumerable: true, get: function () { return Reference_1.isLoadedReference; } });
+Object.defineProperty(exports, "isReference", { enumerable: true, get: function () { return Reference_1.isReference; } });
+var Relation_1 = require("./Relation");
+Object.defineProperty(exports, "isRelation", { enumerable: true, get: function () { return Relation_1.isRelation; } });
+//# sourceMappingURL=index.js.map

package/build/src/relations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/relations/index.ts"],"names":[],"mappings":";;;AAAA,2CAA8F;AAAzE,0GAAA,YAAY,OAAA;AAAE,gHAAA,kBAAkB,OAAA;AACrD,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,qDAAoD;AAA3C,kHAAA,eAAe,OAAA;AACxB,uDAM4B;AAJ1B,oHAAA,gBAAgB,OAAA;AAChB,mHAAA,eAAe,OAAA;AACf,yHAAA,qBAAqB,OAAA;AAGvB,mDAAkD;AAAzC,gHAAA,cAAc,OAAA;AACvB,mDAAkD;AAAzC,gHAAA,cAAc,OAAA;AACvB,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AAEtB,+DAA6E;AAApE,qHAAA,aAAa,OAAA;AAAE,4HAAA,oBAAoB,OAAA;AAC5C,yEAA4F;AAAnF,+HAAA,kBAAkB,OAAA;AAAE,sIAAA,yBAAyB,OAAA;AACtD,2DAAgH;AAAvG,4GAAA,MAAM,OAAA;AAAE,0HAAA,oBAAoB,OAAA;AAAsB,4HAAA,sBAAsB,OAAA;AACjF,6DAAqE;AAA5D,8GAAA,OAAO,OAAA;AAAE,0HAAA,mBAAmB,OAAA;AACrC,uEAAoF;AAA3E,wHAAA,YAAY,OAAA;AAAE,oIAAA,wBAAwB,OAAA;AAC/C,yDAM6B;AAL3B,gHAAA,WAAW,OAAA;AACX,8HAAA,yBAAyB,OAAA;AACzB,wHAAA,mBAAmB,OAAA;AAEnB,0HAAA,qBAAqB,OAAA;AAEvB,+DAKgC;AAJ9B,yHAAA,iBAAiB,OAAA;AACjB,8HAAA,sBAAsB,OAAA;AAEtB,gIAAA,wBAAwB,OAAA;AAE1B,yCAAyF;AAAhF,8GAAA,iBAAiB,OAAA;AAAE,wGAAA,WAAW,OAAA;AACvC,uCAAkD;AAAzC,sGAAA,UAAU,OAAA"}

package/build/{reverseHint.d.ts → src/reverseHint.d.ts}

@@ -1,4 +1,5 @@
-import { Entity, EntityConstructor, LoadHint } from "./EntityManager";
+import { Entity, EntityConstructor } from "./EntityManager";
+import { LoadHint } from "./loaded";
 /**
  * Given a load hint of "given an entity, load these N things", return an array
  * of what those N things are, and reversed load hints to "come back" to the

package/build/{reverseHint.js → src/reverseHint.js}

@@ -12,9 +12,9 @@ function reverseHint(entityType, hint) {
     if (typeof hint === "string") {
         // For a simple string hint, i.e. Book "author", find the Book.author field,
         // and use the metdata to find the otherFieldName, i.e. Author "books"
-        const meta = EntityManager_1.getMetadata(entityType);
-        const field = meta.fields.find((f) => f.fieldName === hint) || utils_1.fail(`Invalid hint ${JSON.stringify(hint)}`);
-        if (field.kind !== "m2m" && field.kind !== "m2o" && field.kind !== "o2m") {
+        const meta = (0, EntityManager_1.getMetadata)(entityType);
+        const field = meta.fields[hint] || (0, utils_1.fail)(`Invalid hint ${entityType.name} ${JSON.stringify(hint)}`);
+        if (field.kind !== "m2m" && field.kind !== "m2o" && field.kind !== "o2m" && field.kind !== "o2o") {
             throw new Error("Invalid hint");
         }
         const otherMeta = field.otherMetadata();
@@ -30,15 +30,19 @@ function reverseHint(entityType, hint) {
         // For a hash of hints, i.e. Author { books: reviews }, recurse for each
         // key in the hash, and then combine
         return Object.entries(hint).flatMap(([key, hint]) => {
-            const meta = EntityManager_1.getMetadata(entityType);
-            const field = meta.fields.find((f) => f.fieldName === key) || utils_1.fail(`Invalid hint ${JSON.stringify(hint)}`);
-            if (field.kind !== "m2m" && field.kind !== "m2o" && field.kind !== "o2m") {
+            const meta = (0, EntityManager_1.getMetadata)(entityType);
+            const field = meta.fields[key] || (0, utils_1.fail)(`Invalid hint ${entityType.name} ${JSON.stringify(hint)}`);
+            if (field.kind !== "m2m" && field.kind !== "m2o" && field.kind !== "o2m" && field.kind !== "o2o") {
                 throw new Error("Invalid hint");
             }
             const otherMeta = field.otherMetadata();
-            return reverseHint(otherMeta.cstr, hint).map(([e, hint]) => {
-                return [e, [...hint, field.otherFieldName]];
-            });
+            const me = [otherMeta.cstr, [field.otherFieldName]];
+            return [
+                me,
+                ...reverseHint(otherMeta.cstr, hint).map(([e, hint]) => {
+                    return [e, [...hint, field.otherFieldName]];
+                }),
+            ];
         });
     }
 }

package/build/src/reverseHint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverseHint.js","sourceRoot":"","sources":["../../src/reverseHint.ts"],"names":[],"mappings":";;;AAAA,mDAAyE;AAEzE,mCAA+B;AAE/B;;;;GAIG;AACH,SAAgB,WAAW,CACzB,UAAgC,EAChC,IAAiB;IAEjB,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,4EAA4E;QAC5E,sEAAsE;QACtE,MAAM,IAAI,GAAG,IAAA,2BAAW,EAAC,UAAU,CAAC,CAAC;QACrC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,IAAA,YAAI,EAAC,gBAAgB,UAAU,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACnG,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE;YAChG,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;SACjC;QACD,MAAM,SAAS,GAAG,KAAK,CAAC,aAAa,EAAE,CAAC;QACxC,OAAO,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;KACnD;SAAM,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;QAC9B,uEAAuE;QACvE,uEAAuE;QACvE,wBAAwB;QACxB,OAAQ,IAAiB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,UAAU,EAAE,IAAW,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;KACtF;SAAM;QACL,wEAAwE;QACxE,oCAAoC;QACpC,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE;YAClD,MAAM,IAAI,GAAG,IAAA,2BAAW,EAAC,UAAU,CAAC,CAAC;YACrC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,IAAA,YAAI,EAAC,gBAAgB,UAAU,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAClG,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE;gBAChG,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;aACjC;YACD,MAAM,SAAS,GAAG,KAAK,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAuC,CAAC;YAC1F,OAAO;gBACL,EAAE;gBACF,GAAG,WAAW,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE;oBACrD,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,CAAuC,CAAC;gBACpF,CAAC,CAAC;aACH,CAAC;QACJ,CAAC,CAAC,CAAC;KACJ;AACH,CAAC;AAtCD,kCAsCC"}

package/build/src/rules.d.ts

@@ -0,0 +1,23 @@
+import { Entity } from "./EntityManager";
+/**
+ * Return type of a `ValidationRule`.
+ *
+ * Consumers can extend `GenericError` to add fields relevant for their application.
+ */
+export declare type ValidationRuleResult<E extends GenericError> = string | E | E[] | undefined;
+/** Entity validation errors; if `entity` is invalid, throw a `ValidationError`. */
+export declare type ValidationRule<T extends Entity> = (entity: T) => MaybePromise<ValidationRuleResult<any>>;
+export declare type MaybePromise<T> = T | PromiseLike<T>;
+/** A generic error which contains only a message field */
+export declare type GenericError = {
+    message: string;
+};
+/** An extension to GenericError which associates the error to a specific entity */
+export declare type ValidationError = {
+    entity: Entity;
+} & GenericError;
+export declare class ValidationErrors extends Error {
+    errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}
+export declare function newRequiredRule<T extends Entity>(key: keyof T): ValidationRule<T>;

package/build/src/rules.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newRequiredRule = exports.ValidationErrors = void 0;
+class ValidationErrors extends Error {
+    constructor(errors) {
+        super(errorMessage(errors));
+        this.errors = errors;
+    }
+}
+exports.ValidationErrors = ValidationErrors;
+function newRequiredRule(key) {
+    return (entity) => (entity.__orm.data[key] === undefined ? `${key} is required` : undefined);
+}
+exports.newRequiredRule = newRequiredRule;
+function errorMessage(errors) {
+    if (errors.length === 1) {
+        return `Validation error: ${errors[0].message}`;
+    }
+    else {
+        return `Validation errors (${errors.length}): ${errors.map((e) => e.message).join(", ")}`;
+    }
+}
+//# sourceMappingURL=rules.js.map

package/build/src/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../src/rules.ts"],"names":[],"mappings":";;;AAoBA,MAAa,gBAAiB,SAAQ,KAAK;IACzC,YAAmB,MAAyB;QAC1C,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;QADX,WAAM,GAAN,MAAM,CAAmB;IAE5C,CAAC;CACF;AAJD,4CAIC;AAED,SAAgB,eAAe,CAAmB,GAAY;IAC5D,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;AAC/F,CAAC;AAFD,0CAEC;AAED,SAAS,YAAY,CAAC,MAAyB;IAC7C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;QACvB,OAAO,qBAAqB,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;KACjD;SAAM;QACL,OAAO,sBAAsB,MAAM,CAAC,MAAM,MAAM,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;KAC3F;AACH,CAAC"}

package/build/src/serde.d.ts

@@ -0,0 +1,121 @@
+import { Field, SerdeField } from "./EntityManager";
+import { EntityMetadata } from "./index";
+export declare function hasSerde(field: Field): field is SerdeField;
+/**
+ * The database/column serialization / deserialization details of a given field.
+ *
+ * Most implementations will have just a single column in `columns`, but some logical
+ * domain fields can be mapped to multiple physical database columns, i.e. polymorphic
+ * references.
+ */
+export interface FieldSerde {
+    /** A single field might persist to multiple columns, i.e. polymorphic references. */
+    columns: Column[];
+    /**
+     * Accepts a database `row` and sets the field's value(s) into the `__orm.data`.
+     *
+     * Used in EntityManager.hydrate to set row value on the entity
+     */
+    setOnEntity(data: any, row: any): void;
+}
+/** A specific physical column of a logical field. */
+export interface Column {
+    columnName: string;
+    dbType: string;
+    dbValue(data: any): any;
+    mapToDb(value: any): any;
+    isArray: boolean;
+}
+export declare class PrimitiveSerde implements FieldSerde {
+    private fieldName;
+    columnName: string;
+    dbType: string;
+    isArray: boolean;
+    columns: this[];
+    constructor(fieldName: string, columnName: string, dbType: string);
+    setOnEntity(data: any, row: any): void;
+    dbValue(data: any): any;
+    mapToDb(value: any): any;
+}
+/**
+ * Maps `decimal(...)` database types to the JS `number`.
+ *
+ * Note that we assume the db values are within the range of the JS `number`;
+ * we should eventually sanity check that.
+ *
+ * Also note that knex/pg accept `number`s as input, so we only need
+ * to handle from-database -> to JS translation.
+ */
+export declare class DecimalToNumberSerde implements FieldSerde {
+    private fieldName;
+    columnName: string;
+    dbType: string;
+    isArray: boolean;
+    columns: this[];
+    constructor(fieldName: string, columnName: string);
+    setOnEntity(data: any, row: any): void;
+    dbValue(data: any): any;
+    mapToDb(value: any): any;
+}
+/** Maps physical integer keys to logical string IDs "because GraphQL". */
+export declare class KeySerde implements FieldSerde {
+    private fieldName;
+    columnName: string;
+    dbType: "int" | "uuid";
+    isArray: boolean;
+    columns: this[];
+    private meta;
+    constructor(tagName: string, fieldName: string, columnName: string, dbType: "int" | "uuid");
+    setOnEntity(data: any, row: any): void;
+    dbValue(data: any): number | undefined;
+    mapToDb(value: any): number | undefined;
+}
+export declare class PolymorphicKeySerde implements FieldSerde {
+    private meta;
+    private fieldName;
+    constructor(meta: () => EntityMetadata<any>, fieldName: string);
+    setOnEntity(data: any, row: any): void;
+    get columns(): Array<Column & {
+        otherMetadata: () => EntityMetadata<any>;
+    }>;
+    get columnName(): string;
+    private get field();
+}
+export declare class EnumFieldSerde implements FieldSerde {
+    private fieldName;
+    columnName: string;
+    private enumObject;
+    dbType: string;
+    isArray: boolean;
+    columns: this[];
+    constructor(fieldName: string, columnName: string, enumObject: any);
+    setOnEntity(data: any, row: any): void;
+    dbValue(data: any): any;
+    mapToDb(value: any): any;
+}
+export declare class EnumArrayFieldSerde implements FieldSerde {
+    private fieldName;
+    columnName: string;
+    private enumObject;
+    dbType: string;
+    isArray: boolean;
+    columns: this[];
+    constructor(fieldName: string, columnName: string, enumObject: any);
+    setOnEntity(data: any, row: any): void;
+    dbValue(data: any): any;
+    mapToDb(value: any): any;
+}
+/** Similar to SimpleSerde, but applies the superstruct `assert` function when reading values from the db. */
+export declare class SuperstructSerde implements FieldSerde {
+    private fieldName;
+    columnName: string;
+    private superstruct;
+    dbType: string;
+    isArray: boolean;
+    columns: this[];
+    private assert;
+    constructor(fieldName: string, columnName: string, superstruct: any);
+    setOnEntity(data: any, row: any): void;
+    dbValue(data: any): any;
+    mapToDb(value: any): any;
+}