@expo/entity 0.38.0 → 0.40.0

package/build/EnforcingEntityAssociationLoader.d.ts

@@ -0,0 +1,79 @@
+import AuthorizationResultBasedEntityAssociationLoader, { EntityLoadThroughDirective } from './AuthorizationResultBasedEntityAssociationLoader';
+import { IEntityClass } from './Entity';
+import EntityPrivacyPolicy from './EntityPrivacyPolicy';
+import ReadonlyEntity from './ReadonlyEntity';
+import ViewerContext from './ViewerContext';
+/**
+ * An association loader is a set of convenience methods for loading entities
+ * associated with an entity. In relational databases, these entities are often referenced
+ * by foreign keys.
+ */
+export default class EnforcingEntityAssociationLoader<TFields extends object, TID extends NonNullable<TFields[TSelectedFields]>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>, TSelectedFields extends keyof TFields> {
+    private readonly authorizationResultBasedEntityAssociationLoader;
+    constructor(authorizationResultBasedEntityAssociationLoader: AuthorizationResultBasedEntityAssociationLoader<TFields, TID, TViewerContext, TEntity, TSelectedFields>);
+    /**
+     * Load an associated entity identified by a field value of this entity. In a relational database,
+     * the field in this entity is a foreign key to the ID of the associated entity.
+     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the ID of the associated entity
+     * @param associatedEntityClass - class of the associated entity
+     */
+    loadAssociatedEntityAsync<TIdentifyingField extends keyof Pick<TFields, TSelectedFields>, TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields>(fieldIdentifyingAssociatedEntity: TIdentifyingField, associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>): Promise<null extends TFields[TIdentifyingField] ? TAssociatedEntity | null : TAssociatedEntity>;
+    /**
+     * Load many entities associated with this entity, often referred to as entites belonging
+     * to this entity. In a relational database, the field in the foreign entity is a
+     * foreign key to the ID of this entity. Also commonly referred to as a has many relationship,
+     * where this entity has many associated entities.
+     * @param associatedEntityClass - class of the associated entities
+     * @param associatedEntityFieldContainingThisID - field of associated entity which contains the ID of this entity
+     */
+    loadManyAssociatedEntitiesAsync<TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields>(associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>, associatedEntityFieldContainingThisID: keyof Pick<TAssociatedFields, TAssociatedSelectedFields>): Promise<readonly TAssociatedEntity[]>;
+    /**
+     * Load an associated entity identified by a field value of this entity. In a relational database,
+     * the field in this entity is a foreign key to a unique field of the associated entity.
+     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the value with which to look up associated entity
+     * @param associatedEntityClass - class of the associated entity
+     * @param associatedEntityLookupByField - field of associated entity with which to look up the associated entity
+     */
+    loadAssociatedEntityByFieldEqualingAsync<TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields>(fieldIdentifyingAssociatedEntity: keyof Pick<TFields, TSelectedFields>, associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>, associatedEntityLookupByField: keyof Pick<TAssociatedFields, TAssociatedSelectedFields>): Promise<TAssociatedEntity | null>;
+    /**
+     * Load many associated entities identified by a field value of this entity. In a relational database,
+     * the field in this entity refers to a field of the associated entity.
+     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the value with which to look up associated entities
+     * @param associatedEntityClass - class of the associated entities
+     * @param associatedEntityLookupByField - field of associated entities with which to look up the associated entities
+     */
+    loadManyAssociatedEntitiesByFieldEqualingAsync<TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields>(fieldIdentifyingAssociatedEntity: keyof Pick<TFields, TSelectedFields>, associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>, associatedEntityLookupByField: keyof Pick<TAssociatedFields, TAssociatedSelectedFields>): Promise<readonly TAssociatedEntity[]>;
+    /**
+     * Load an associated entity by folding a sequence of EntityLoadThroughDirective. At each
+     * fold step, load an associated entity identified by a field value of the current fold value.
+     * @param loadDirectives - associated entity load directives instructing each step of the folds
+     */
+    loadAssociatedEntityThroughAsync<TFields2 extends object, TID2 extends NonNullable<TFields2[TSelectedFields2]>, TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>, TPrivacyPolicy2 extends EntityPrivacyPolicy<TFields2, TID2, TViewerContext, TEntity2, TSelectedFields2>, TSelectedFields2 extends keyof TFields2 = keyof TFields2>(loadDirectives: [
+        EntityLoadThroughDirective<TViewerContext, TFields, TFields2, TID2, TEntity2, TPrivacyPolicy2, TSelectedFields, TSelectedFields2>
+    ]): Promise<TEntity2 | null>;
+    /**
+     * Load an associated entity by folding a sequence of EntityLoadThroughDirective. At each
+     * fold step, load an associated entity identified by a field value of the current fold value.
+     * @param loadDirectives - associated entity load directives instructing each step of the folds
+     */
+    loadAssociatedEntityThroughAsync<TFields2 extends object, TID2 extends NonNullable<TFields2[TSelectedFields2]>, TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>, TPrivacyPolicy2 extends EntityPrivacyPolicy<TFields2, TID2, TViewerContext, TEntity2, TSelectedFields2>, TFields3 extends object, TID3 extends NonNullable<TFields3[TSelectedFields3]>, TEntity3 extends ReadonlyEntity<TFields3, TID3, TViewerContext, TSelectedFields3>, TPrivacyPolicy3 extends EntityPrivacyPolicy<TFields3, TID3, TViewerContext, TEntity3, TSelectedFields3>, TSelectedFields2 extends keyof TFields2 = keyof TFields2, TSelectedFields3 extends keyof TFields3 = keyof TFields3>(loadDirectives: [
+        EntityLoadThroughDirective<TViewerContext, TFields, TFields2, TID2, TEntity2, TPrivacyPolicy2, TSelectedFields, TSelectedFields2>,
+        EntityLoadThroughDirective<TViewerContext, TFields2, TFields3, TID3, TEntity3, TPrivacyPolicy3, TSelectedFields2, TSelectedFields3>
+    ]): Promise<TEntity3 | null>;
+    /**
+     * Load an associated entity by folding a sequence of EntityLoadThroughDirective. At each
+     * fold step, load an associated entity identified by a field value of the current fold value.
+     * @param loadDirectives - associated entity load directives instructing each step of the folds
+     */
+    loadAssociatedEntityThroughAsync<TFields2 extends object, TID2 extends NonNullable<TFields2[TSelectedFields2]>, TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>, TPrivacyPolicy2 extends EntityPrivacyPolicy<TFields2, TID2, TViewerContext, TEntity2, TSelectedFields2>, TFields3 extends object, TID3 extends NonNullable<TFields3[TSelectedFields3]>, TEntity3 extends ReadonlyEntity<TFields3, TID3, TViewerContext, TSelectedFields3>, TPrivacyPolicy3 extends EntityPrivacyPolicy<TFields3, TID3, TViewerContext, TEntity3, TSelectedFields3>, TFields4 extends object, TID4 extends NonNullable<TFields4[TSelectedFields4]>, TEntity4 extends ReadonlyEntity<TFields4, TID4, TViewerContext, TSelectedFields4>, TPrivacyPolicy4 extends EntityPrivacyPolicy<TFields4, TID4, TViewerContext, TEntity4, TSelectedFields4>, TSelectedFields2 extends keyof TFields2 = keyof TFields2, TSelectedFields3 extends keyof TFields3 = keyof TFields3, TSelectedFields4 extends keyof TFields4 = keyof TFields4>(loadDirectives: [
+        EntityLoadThroughDirective<TViewerContext, TFields, TFields2, TID2, TEntity2, TPrivacyPolicy2, TSelectedFields, TSelectedFields2>,
+        EntityLoadThroughDirective<TViewerContext, TFields2, TFields3, TID3, TEntity3, TPrivacyPolicy3, TSelectedFields2, TSelectedFields3>,
+        EntityLoadThroughDirective<TViewerContext, TFields3, TFields4, TID4, TEntity4, TPrivacyPolicy4, TSelectedFields3, TSelectedFields4>
+    ]): Promise<TEntity4 | null>;
+    /**
+     * Load an associated entity by folding a sequence of EntityLoadThroughDirective. At each
+     * fold step, load an associated entity identified by a field value of the current fold value.
+     * @param loadDirectives - associated entity load directives instructing each step of the folds
+     */
+    loadAssociatedEntityThroughAsync(loadDirectives: EntityLoadThroughDirective<TViewerContext, any, any, any, any, any, any, any>[]): Promise<ReadonlyEntity<any, any, any, any> | null>;
+}

package/build/EnforcingEntityAssociationLoader.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const results_1 = require("@expo/results");
+const entityUtils_1 = require("./entityUtils");
+/**
+ * An association loader is a set of convenience methods for loading entities
+ * associated with an entity. In relational databases, these entities are often referenced
+ * by foreign keys.
+ */
+class EnforcingEntityAssociationLoader {
+    authorizationResultBasedEntityAssociationLoader;
+    constructor(authorizationResultBasedEntityAssociationLoader) {
+        this.authorizationResultBasedEntityAssociationLoader = authorizationResultBasedEntityAssociationLoader;
+    }
+    /**
+     * Load an associated entity identified by a field value of this entity. In a relational database,
+     * the field in this entity is a foreign key to the ID of the associated entity.
+     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the ID of the associated entity
+     * @param associatedEntityClass - class of the associated entity
+     */
+    async loadAssociatedEntityAsync(fieldIdentifyingAssociatedEntity, associatedEntityClass) {
+        return await (0, results_1.enforceAsyncResult)(this.authorizationResultBasedEntityAssociationLoader.loadAssociatedEntityAsync(fieldIdentifyingAssociatedEntity, associatedEntityClass));
+    }
+    /**
+     * Load many entities associated with this entity, often referred to as entites belonging
+     * to this entity. In a relational database, the field in the foreign entity is a
+     * foreign key to the ID of this entity. Also commonly referred to as a has many relationship,
+     * where this entity has many associated entities.
+     * @param associatedEntityClass - class of the associated entities
+     * @param associatedEntityFieldContainingThisID - field of associated entity which contains the ID of this entity
+     */
+    async loadManyAssociatedEntitiesAsync(associatedEntityClass, associatedEntityFieldContainingThisID) {
+        return await (0, entityUtils_1.enforceResultsAsync)(this.authorizationResultBasedEntityAssociationLoader.loadManyAssociatedEntitiesAsync(associatedEntityClass, associatedEntityFieldContainingThisID));
+    }
+    /**
+     * Load an associated entity identified by a field value of this entity. In a relational database,
+     * the field in this entity is a foreign key to a unique field of the associated entity.
+     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the value with which to look up associated entity
+     * @param associatedEntityClass - class of the associated entity
+     * @param associatedEntityLookupByField - field of associated entity with which to look up the associated entity
+     */
+    async loadAssociatedEntityByFieldEqualingAsync(fieldIdentifyingAssociatedEntity, associatedEntityClass, associatedEntityLookupByField) {
+        const result = await this.authorizationResultBasedEntityAssociationLoader.loadAssociatedEntityByFieldEqualingAsync(fieldIdentifyingAssociatedEntity, associatedEntityClass, associatedEntityLookupByField);
+        return result?.enforceValue() ?? null;
+    }
+    /**
+     * Load many associated entities identified by a field value of this entity. In a relational database,
+     * the field in this entity refers to a field of the associated entity.
+     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the value with which to look up associated entities
+     * @param associatedEntityClass - class of the associated entities
+     * @param associatedEntityLookupByField - field of associated entities with which to look up the associated entities
+     */
+    async loadManyAssociatedEntitiesByFieldEqualingAsync(fieldIdentifyingAssociatedEntity, associatedEntityClass, associatedEntityLookupByField) {
+        return await (0, entityUtils_1.enforceResultsAsync)(this.authorizationResultBasedEntityAssociationLoader.loadManyAssociatedEntitiesByFieldEqualingAsync(fieldIdentifyingAssociatedEntity, associatedEntityClass, associatedEntityLookupByField));
+    }
+    async loadAssociatedEntityThroughAsync(loadDirectives) {
+        const result = await this.authorizationResultBasedEntityAssociationLoader.loadAssociatedEntityThroughAsync(loadDirectives);
+        return result?.enforceValue() ?? null;
+    }
+}
+exports.default = EnforcingEntityAssociationLoader;
+//# sourceMappingURL=EnforcingEntityAssociationLoader.js.map

package/build/EnforcingEntityAssociationLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnforcingEntityAssociationLoader.js","sourceRoot":"","sources":["../src/EnforcingEntityAssociationLoader.ts"],"names":[],"mappings":";;AAAA,2CAAmD;AASnD,+CAAoD;AAEpD;;;;GAIG;AACH,MAAqB,gCAAgC;IAQhC;IADnB,YACmB,+CAMhB;QANgB,oDAA+C,GAA/C,+CAA+C,CAM/D;IACA,CAAC;IAEJ;;;;;OAKG;IACH,KAAK,CAAC,yBAAyB,CAmB7B,gCAAmD,EACnD,qBAOC;QAID,OAAO,MAAM,IAAA,4BAAkB,EAC7B,IAAI,CAAC,+CAA+C,CAAC,yBAAyB,CAC5E,gCAAgC,EAChC,qBAAqB,CACtB,CACF,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,+BAA+B,CAkBnC,qBAOC,EACD,qCAA+F;QAE/F,OAAO,MAAM,IAAA,iCAAmB,EAC9B,IAAI,CAAC,+CAA+C,CAAC,+BAA+B,CAClF,qBAAqB,EACrB,qCAAqC,CACtC,CACF,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,wCAAwC,CAkB5C,gCAAsE,EACtE,qBAOC,EACD,6BAAuF;QAEvF,MAAM,MAAM,GACV,MAAM,IAAI,CAAC,+CAA+C,CAAC,wCAAwC,CACjG,gCAAgC,EAChC,qBAAqB,EACrB,6BAA6B,CAC9B,CAAC;QACJ,OAAO,MAAM,EAAE,YAAY,EAAE,IAAI,IAAI,CAAC;IACxC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,8CAA8C,CAkBlD,gCAAsE,EACtE,qBAOC,EACD,6BAAuF;QAEvF,OAAO,MAAM,IAAA,iCAAmB,EAC9B,IAAI,CAAC,+CAA+C,CAAC,8CAA8C,CACjG,gCAAgC,EAChC,qBAAqB,EACrB,6BAA6B,CAC9B,CACF,CAAC;IACJ,CAAC;IA0KD,KAAK,CAAC,gCAAgC,CACpC,cAA+F;QAE/F,MAAM,MAAM,GACV,MAAM,IAAI,CAAC,+CAA+C,CAAC,gCAAgC,CACzF,cAAc,CACf,CAAC;QACJ,OAAO,MAAM,EAAE,YAAY,EAAE,IAAI,IAAI,CAAC;IACxC,CAAC;CACF;AArXD,mDAqXC"}

package/build/EnforcingEntityCreator.d.ts

@@ -0,0 +1,24 @@
+import { AuthorizationResultBasedCreateMutator } from './AuthorizationResultBasedEntityMutator';
+import EntityPrivacyPolicy from './EntityPrivacyPolicy';
+import ReadonlyEntity from './ReadonlyEntity';
+import ViewerContext from './ViewerContext';
+/**
+ * Enforcing entity creator. All updates
+ * through this creator will throw if authorization is not successful.
+ */
+export default class EnforcingEntityCreator<TFields extends object, TID extends NonNullable<TFields[TSelectedFields]>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>, TPrivacyPolicy extends EntityPrivacyPolicy<TFields, TID, TViewerContext, TEntity, TSelectedFields>, TSelectedFields extends keyof TFields> {
+    private readonly entityCreator;
+    constructor(entityCreator: AuthorizationResultBasedCreateMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>);
+    /**
+     * Set the value for entity field.
+     * @param fieldName - entity field being updated
+     * @param value - value for entity field
+     */
+    setField<K extends keyof Pick<TFields, TSelectedFields>>(fieldName: K, value: TFields[K]): this;
+    /**
+     * Commit the new entity after authorizing against creation privacy rules. Invalidates all caches for
+     * queries that would return new entity.
+     * @returns authorized, cached, newly-created entity, throwing if unsuccessful
+     */
+    createAsync(): Promise<TEntity>;
+}

package/build/EnforcingEntityCreator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const results_1 = require("@expo/results");
+/**
+ * Enforcing entity creator. All updates
+ * through this creator will throw if authorization is not successful.
+ */
+class EnforcingEntityCreator {
+    entityCreator;
+    constructor(entityCreator) {
+        this.entityCreator = entityCreator;
+    }
+    /**
+     * Set the value for entity field.
+     * @param fieldName - entity field being updated
+     * @param value - value for entity field
+     */
+    setField(fieldName, value) {
+        this.entityCreator.setField(fieldName, value);
+        return this;
+    }
+    /**
+     * Commit the new entity after authorizing against creation privacy rules. Invalidates all caches for
+     * queries that would return new entity.
+     * @returns authorized, cached, newly-created entity, throwing if unsuccessful
+     */
+    async createAsync() {
+        return await (0, results_1.enforceAsyncResult)(this.entityCreator.createAsync());
+    }
+}
+exports.default = EnforcingEntityCreator;
+//# sourceMappingURL=EnforcingEntityCreator.js.map

package/build/EnforcingEntityCreator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnforcingEntityCreator.js","sourceRoot":"","sources":["../src/EnforcingEntityCreator.ts"],"names":[],"mappings":";;AAAA,2CAAmD;AAOnD;;;GAGG;AACH,MAAqB,sBAAsB;IAetB;IADnB,YACmB,aAOhB;QAPgB,kBAAa,GAAb,aAAa,CAO7B;IACA,CAAC;IAEJ;;;;OAIG;IACH,QAAQ,CAAiD,SAAY,EAAE,KAAiB;QACtF,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,WAAW;QACf,OAAO,MAAM,IAAA,4BAAkB,EAAC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC;IACpE,CAAC;CACF;AA3CD,yCA2CC"}

package/build/EnforcingEntityDeleter.d.ts

@@ -0,0 +1,17 @@
+import { AuthorizationResultBasedDeleteMutator } from './AuthorizationResultBasedEntityMutator';
+import EntityPrivacyPolicy from './EntityPrivacyPolicy';
+import ReadonlyEntity from './ReadonlyEntity';
+import ViewerContext from './ViewerContext';
+/**
+ * Enforcing entity deleter. All deletes
+ * through this deleter will throw if authorization is not successful.
+ */
+export default class EnforcingEntityDeleter<TFields extends object, TID extends NonNullable<TFields[TSelectedFields]>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>, TPrivacyPolicy extends EntityPrivacyPolicy<TFields, TID, TViewerContext, TEntity, TSelectedFields>, TSelectedFields extends keyof TFields> {
+    private readonly entityDeleter;
+    constructor(entityDeleter: AuthorizationResultBasedDeleteMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>);
+    /**
+     * Delete the entity after authorizing against delete privacy rules. The entity is invalidated in all caches.
+     * Throws when delete is not successful.
+     */
+    deleteAsync(): Promise<void>;
+}

package/build/EnforcingEntityDeleter.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const results_1 = require("@expo/results");
+/**
+ * Enforcing entity deleter. All deletes
+ * through this deleter will throw if authorization is not successful.
+ */
+class EnforcingEntityDeleter {
+    entityDeleter;
+    constructor(entityDeleter) {
+        this.entityDeleter = entityDeleter;
+    }
+    /**
+     * Delete the entity after authorizing against delete privacy rules. The entity is invalidated in all caches.
+     * Throws when delete is not successful.
+     */
+    async deleteAsync() {
+        await (0, results_1.enforceAsyncResult)(this.entityDeleter.deleteAsync());
+    }
+}
+exports.default = EnforcingEntityDeleter;
+//# sourceMappingURL=EnforcingEntityDeleter.js.map

package/build/EnforcingEntityDeleter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnforcingEntityDeleter.js","sourceRoot":"","sources":["../src/EnforcingEntityDeleter.ts"],"names":[],"mappings":";;AAAA,2CAAmD;AAOnD;;;GAGG;AACH,MAAqB,sBAAsB;IAetB;IADnB,YACmB,aAOhB;QAPgB,kBAAa,GAAb,aAAa,CAO7B;IACA,CAAC;IAEJ;;;OAGG;IACH,KAAK,CAAC,WAAW;QACf,MAAM,IAAA,4BAAkB,EAAC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC;IAC7D,CAAC;CACF;AAhCD,yCAgCC"}

package/build/EnforcingEntityUpdater.d.ts

@@ -0,0 +1,24 @@
+import { AuthorizationResultBasedUpdateMutator } from './AuthorizationResultBasedEntityMutator';
+import EntityPrivacyPolicy from './EntityPrivacyPolicy';
+import ReadonlyEntity from './ReadonlyEntity';
+import ViewerContext from './ViewerContext';
+/**
+ * Enforcing entity updater. All updates
+ * through this updater will throw if authorization is not successful.
+ */
+export default class EnforcingEntityUpdater<TFields extends object, TID extends NonNullable<TFields[TSelectedFields]>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>, TPrivacyPolicy extends EntityPrivacyPolicy<TFields, TID, TViewerContext, TEntity, TSelectedFields>, TSelectedFields extends keyof TFields> {
+    private readonly entityUpdater;
+    constructor(entityUpdater: AuthorizationResultBasedUpdateMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>);
+    /**
+     * Set the value for entity field.
+     * @param fieldName - entity field being updated
+     * @param value - value for entity field
+     */
+    setField<K extends keyof Pick<TFields, TSelectedFields>>(fieldName: K, value: TFields[K]): this;
+    /**
+     * Commit the changes to the entity after authorizing against update privacy rules.
+     * Invalidates all caches for pre-update entity.
+     * @returns authorized updated entity, throws upon update failure
+     */
+    updateAsync(): Promise<TEntity>;
+}

package/build/EnforcingEntityUpdater.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const results_1 = require("@expo/results");
+/**
+ * Enforcing entity updater. All updates
+ * through this updater will throw if authorization is not successful.
+ */
+class EnforcingEntityUpdater {
+    entityUpdater;
+    constructor(entityUpdater) {
+        this.entityUpdater = entityUpdater;
+    }
+    /**
+     * Set the value for entity field.
+     * @param fieldName - entity field being updated
+     * @param value - value for entity field
+     */
+    setField(fieldName, value) {
+        this.entityUpdater.setField(fieldName, value);
+        return this;
+    }
+    /**
+     * Commit the changes to the entity after authorizing against update privacy rules.
+     * Invalidates all caches for pre-update entity.
+     * @returns authorized updated entity, throws upon update failure
+     */
+    async updateAsync() {
+        return await (0, results_1.enforceAsyncResult)(this.entityUpdater.updateAsync());
+    }
+}
+exports.default = EnforcingEntityUpdater;
+//# sourceMappingURL=EnforcingEntityUpdater.js.map

package/build/EnforcingEntityUpdater.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnforcingEntityUpdater.js","sourceRoot":"","sources":["../src/EnforcingEntityUpdater.ts"],"names":[],"mappings":";;AAAA,2CAAmD;AAOnD;;;GAGG;AACH,MAAqB,sBAAsB;IAetB;IADnB,YACmB,aAOhB;QAPgB,kBAAa,GAAb,aAAa,CAO7B;IACA,CAAC;IAEJ;;;;OAIG;IACH,QAAQ,CAAiD,SAAY,EAAE,KAAiB;QACtF,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,WAAW;QACf,OAAO,MAAM,IAAA,4BAAkB,EAAC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC;IACpE,CAAC;CACF;AA3CD,yCA2CC"}

package/build/Entity.d.ts

@@ -1,8 +1,9 @@
-import { Result } from '@expo/results';
 import { EntityCompanionDefinition } from './EntityCompanionProvider';
-import { CreateMutator, UpdateMutator } from './EntityMutator';
+import EntityCreator from './EntityCreator';
+import EntityDeleter from './EntityDeleter';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
+import EntityUpdater from './EntityUpdater';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerContext from './ViewerContext';
 /**
@@ -30,26 +31,21 @@ export default abstract class Entity<TFields extends object, TID extends NonNull
      * @param queryContext - query context in which to perform the create
      * @returns mutator for creating an entity
      */
-    static creator<TMFields extends object, TMID extends NonNullable<TMFields[TMSelectedFields]>, TMViewerContext extends ViewerContext, TMViewerContext2 extends TMViewerContext, TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>, TMPrivacyPolicy extends EntityPrivacyPolicy<TMFields, TMID, TMViewerContext, TMEntity, TMSelectedFields>, TMSelectedFields extends keyof TMFields = keyof TMFields>(this: IEntityClass<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>, viewerContext: TMViewerContext2, queryContext?: EntityQueryContext): CreateMutator<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>;
+    static creator<TMFields extends object, TMID extends NonNullable<TMFields[TMSelectedFields]>, TMViewerContext extends ViewerContext, TMViewerContext2 extends TMViewerContext, TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>, TMPrivacyPolicy extends EntityPrivacyPolicy<TMFields, TMID, TMViewerContext, TMEntity, TMSelectedFields>, TMSelectedFields extends keyof TMFields = keyof TMFields>(this: IEntityClass<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>, viewerContext: TMViewerContext2, queryContext?: EntityQueryContext): EntityCreator<TMFields, TMID, TMViewerContext, TMViewerContext2, TMEntity, TMPrivacyPolicy, TMSelectedFields>;
     /**
      * Vend mutator for updating an existing entity in given query context.
      * @param existingEntity - entity to update
      * @param queryContext - query context in which to perform the update
      * @returns mutator for updating existingEntity
      */
-    static updater<TMFields extends object, TMID extends NonNullable<TMFields[TMSelectedFields]>, TMViewerContext extends ViewerContext, TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>, TMPrivacyPolicy extends EntityPrivacyPolicy<TMFields, TMID, TMViewerContext, TMEntity, TMSelectedFields>, TMSelectedFields extends keyof TMFields = keyof TMFields>(this: IEntityClass<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>, existingEntity: TMEntity, queryContext?: EntityQueryContext): UpdateMutator<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>;
+    static updater<TMFields extends object, TMID extends NonNullable<TMFields[TMSelectedFields]>, TMViewerContext extends ViewerContext, TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>, TMPrivacyPolicy extends EntityPrivacyPolicy<TMFields, TMID, TMViewerContext, TMEntity, TMSelectedFields>, TMSelectedFields extends keyof TMFields = keyof TMFields>(this: IEntityClass<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>, existingEntity: TMEntity, queryContext?: EntityQueryContext): EntityUpdater<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>;
     /**
-     * Delete an existing entity in given query context.
+     * Vend mutator for deleting an existing entity in given query context.
      * @param existingEntity - entity to delete
      * @param queryContext - query context in which to perform the delete
+     * @returns mutator for deleting existingEntity
      */
-    static deleteAsync<TMFields extends object, TMID extends NonNullable<TMFields[TMSelectedFields]>, TMViewerContext extends ViewerContext, TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>, TMPrivacyPolicy extends EntityPrivacyPolicy<TMFields, TMID, TMViewerContext, TMEntity, TMSelectedFields>, TMSelectedFields extends keyof TMFields = keyof TMFields>(this: IEntityClass<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>, existingEntity: TMEntity, queryContext?: EntityQueryContext): Promise<Result<void>>;
-    /**
-     * Delete an existing entity in given query context, throwing if deletion is unsuccessful.
-     * @param existingEntity - entity to delete
-     * @param queryContext - query context in which to perform the delete
-     */
-    static enforceDeleteAsync<TMFields extends object, TMID extends NonNullable<TMFields[TMSelectedFields]>, TMViewerContext extends ViewerContext, TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>, TMPrivacyPolicy extends EntityPrivacyPolicy<TMFields, TMID, TMViewerContext, TMEntity, TMSelectedFields>, TMSelectedFields extends keyof TMFields = keyof TMFields>(this: IEntityClass<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>, existingEntity: TMEntity, queryContext?: EntityQueryContext): Promise<void>;
+    static deleter<TMFields extends object, TMID extends NonNullable<TMFields[TMSelectedFields]>, TMViewerContext extends ViewerContext, TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>, TMPrivacyPolicy extends EntityPrivacyPolicy<TMFields, TMID, TMViewerContext, TMEntity, TMSelectedFields>, TMSelectedFields extends keyof TMFields = keyof TMFields>(this: IEntityClass<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>, existingEntity: TMEntity, queryContext?: EntityQueryContext): EntityDeleter<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields>;
 }
 /**
  * An interface to pass in constructor (class) of an Entity as a function argument.

package/build/Entity.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const EntityCreator_1 = __importDefault(require("./EntityCreator"));
+const EntityDeleter_1 = __importDefault(require("./EntityDeleter"));
+const EntityUpdater_1 = __importDefault(require("./EntityUpdater"));
 const ReadonlyEntity_1 = __importDefault(require("./ReadonlyEntity"));
 /**
  * Entity is a privacy-first data model.
@@ -33,10 +36,7 @@ class Entity extends ReadonlyEntity_1.default {
         .getViewerScopedEntityCompanionForClass(this)
         .getQueryContextProvider()
         .getQueryContext()) {
-        return viewerContext
-            .getViewerScopedEntityCompanionForClass(this)
-            .getMutatorFactory()
-            .forCreate(queryContext);
+        return new EntityCreator_1.default(viewerContext, queryContext, this);
     }
     /**
      * Vend mutator for updating an existing entity in given query context.
@@ -49,45 +49,20 @@ class Entity extends ReadonlyEntity_1.default {
         .getViewerScopedEntityCompanionForClass(this)
         .getQueryContextProvider()
         .getQueryContext()) {
-        return existingEntity
-            .getViewerContext()
-            .getViewerScopedEntityCompanionForClass(this)
-            .getMutatorFactory()
-            .forUpdate(existingEntity, queryContext);
+        return new EntityUpdater_1.default(existingEntity, queryContext, this);
     }
     /**
-     * Delete an existing entity in given query context.
+     * Vend mutator for deleting an existing entity in given query context.
      * @param existingEntity - entity to delete
      * @param queryContext - query context in which to perform the delete
+     * @returns mutator for deleting existingEntity
      */
-    static deleteAsync(existingEntity, queryContext = existingEntity
+    static deleter(existingEntity, queryContext = existingEntity
         .getViewerContext()
         .getViewerScopedEntityCompanionForClass(this)
         .getQueryContextProvider()
         .getQueryContext()) {
-        return existingEntity
-            .getViewerContext()
-            .getViewerScopedEntityCompanionForClass(this)
-            .getMutatorFactory()
-            .forDelete(existingEntity, queryContext)
-            .deleteAsync();
-    }
-    /**
-     * Delete an existing entity in given query context, throwing if deletion is unsuccessful.
-     * @param existingEntity - entity to delete
-     * @param queryContext - query context in which to perform the delete
-     */
-    static enforceDeleteAsync(existingEntity, queryContext = existingEntity
-        .getViewerContext()
-        .getViewerScopedEntityCompanionForClass(this)
-        .getQueryContextProvider()
-        .getQueryContext()) {
-        return existingEntity
-            .getViewerContext()
-            .getViewerScopedEntityCompanionForClass(this)
-            .getMutatorFactory()
-            .forDelete(existingEntity, queryContext)
-            .enforceDeleteAsync();
+        return new EntityDeleter_1.default(existingEntity, queryContext, this);
     }
 }
 exports.default = Entity;

package/build/Entity.js.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.js","sourceRoot":"","sources":["../src/Entity.ts"],"names":[],"mappings":";;;;;AAMA,sEAA8C;AAG9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAA8B,MAK5B,SAAQ,wBAA6D;IACrE;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAuBZ,aAA+B,EAC/B,eAAmC,aAAa;SAC7C,sCAAsC,CAAC,IAAI,CAAC;SAC5C,uBAAuB,EAAE;SACzB,eAAe,EAAE;QAEpB,OAAO,aAAa;aACjB,sCAAsC,CAAC,IAAI,CAAC;aAC5C,iBAAiB,EAAE;aACnB,SAAS,CAAC,YAAY,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAsBZ,cAAwB,EACxB,eAAmC,cAAc;SAC9C,gBAAgB,EAAE;SAClB,sCAAsC,CAAC,IAAI,CAAC;SAC5C,uBAAuB,EAAE;SACzB,eAAe,EAAE;QAEpB,OAAO,cAAc;aAClB,gBAAgB,EAAE;aAClB,sCAAsC,CAAC,IAAI,CAAC;aAC5C,iBAAiB,EAAE;aACnB,SAAS,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAsBhB,cAAwB,EACxB,eAAmC,cAAc;SAC9C,gBAAgB,EAAE;SAClB,sCAAsC,CAAC,IAAI,CAAC;SAC5C,uBAAuB,EAAE;SACzB,eAAe,EAAE;QAEpB,OAAO,cAAc;aAClB,gBAAgB,EAAE;aAClB,sCAAsC,CAAC,IAAI,CAAC;aAC5C,iBAAiB,EAAE;aACnB,SAAS,CAAC,cAAc,EAAE,YAAY,CAAC;aACvC,WAAW,EAAE,CAAC;IACnB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,kBAAkB,CAsBvB,cAAwB,EACxB,eAAmC,cAAc;SAC9C,gBAAgB,EAAE;SAClB,sCAAsC,CAAC,IAAI,CAAC;SAC5C,uBAAuB,EAAE;SACzB,eAAe,EAAE;QAEpB,OAAO,cAAc;aAClB,gBAAgB,EAAE;aAClB,sCAAsC,CAAC,IAAI,CAAC;aAC5C,iBAAiB,EAAE;aACnB,SAAS,CAAC,cAAc,EAAE,YAAY,CAAC;aACvC,kBAAkB,EAAE,CAAC;IAC1B,CAAC;CACF;AA5KD,yBA4KC"}
+{"version":3,"file":"Entity.js","sourceRoot":"","sources":["../src/Entity.ts"],"names":[],"mappings":";;;;;AACA,oEAA4C;AAC5C,oEAA4C;AAG5C,oEAA4C;AAC5C,sEAA8C;AAG9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAA8B,MAK5B,SAAQ,wBAA6D;IACrE;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAuBZ,aAA+B,EAC/B,eAAmC,aAAa;SAC7C,sCAAsC,CAAC,IAAI,CAAC;SAC5C,uBAAuB,EAAE;SACzB,eAAe,EAAE;QAUpB,OAAO,IAAI,uBAAa,CAAC,aAAa,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAsBZ,cAAwB,EACxB,eAAmC,cAAc;SAC9C,gBAAgB,EAAE;SAClB,sCAAsC,CAAC,IAAI,CAAC;SAC5C,uBAAuB,EAAE;SACzB,eAAe,EAAE;QAEpB,OAAO,IAAI,uBAAa,CAAC,cAAc,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CAsBZ,cAAwB,EACxB,eAAmC,cAAc;SAC9C,gBAAgB,EAAE;SAClB,sCAAsC,CAAC,IAAI,CAAC;SAC5C,uBAAuB,EAAE;SACzB,eAAe,EAAE;QAEpB,OAAO,IAAI,uBAAa,CAAC,cAAc,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;IAC/D,CAAC;CACF;AA/HD,yBA+HC"}

package/build/EntityAssociationLoader.d.ts

@@ -1,6 +1,5 @@
-import { Result } from '@expo/results';
-import { IEntityClass } from './Entity';
-import EntityPrivacyPolicy from './EntityPrivacyPolicy';
+import AuthorizationResultBasedEntityAssociationLoader from './AuthorizationResultBasedEntityAssociationLoader';
+import EnforcingEntityAssociationLoader from './EnforcingEntityAssociationLoader';
 import { EntityQueryContext } from './EntityQueryContext';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerContext from './ViewerContext';
@@ -11,96 +10,18 @@ import ViewerContext from './ViewerContext';
  */
 export default class EntityAssociationLoader<TFields extends object, TID extends NonNullable<TFields[TSelectedFields]>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>, TSelectedFields extends keyof TFields> {
     private readonly entity;
-    constructor(entity: TEntity);
+    private readonly queryContext;
+    constructor(entity: TEntity, queryContext?: EntityQueryContext);
     /**
-     * Load an associated entity identified by a field value of this entity. In a relational database,
-     * the field in this entity is a foreign key to the ID of the associated entity.
-     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the ID of the associated entity
-     * @param associatedEntityClass - class of the associated entity
-     * @param queryContext - query context in which to perform the load
+     * Enforcing entity association loader. All loads through this loader are
+     * guaranteed to be the values of successful results (or null for some loader methods),
+     * and will throw otherwise.
      */
-    loadAssociatedEntityAsync<TIdentifyingField extends keyof Pick<TFields, TSelectedFields>, TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields>(fieldIdentifyingAssociatedEntity: TIdentifyingField, associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>, queryContext?: EntityQueryContext): Promise<Result<null extends TFields[TIdentifyingField] ? TAssociatedEntity | null : TAssociatedEntity>>;
+    enforcing(): EnforcingEntityAssociationLoader<TFields, TID, TViewerContext, TEntity, TSelectedFields>;
     /**
-     * Load many entities associated with this entity, often referred to as entites belonging
-     * to this entity. In a relational database, the field in the foreign entity is a
-     * foreign key to the ID of this entity. Also commonly referred to as a has many relationship,
-     * where this entity has many associated entities.
-     * @param associatedEntityClass - class of the associated entities
-     * @param associatedEntityFieldContainingThisID - field of associated entity which contains the ID of this entity
-     * @param queryContext - query context in which to perform the load
+     * Authorization-result-based entity loader. All loads through this
+     * loader are results, where an unsuccessful result
+     * means an authorization error or entity construction error occurred. Other errors are thrown.
      */
-    loadManyAssociatedEntitiesAsync<TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields>(associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>, associatedEntityFieldContainingThisID: keyof Pick<TAssociatedFields, TAssociatedSelectedFields>, queryContext?: EntityQueryContext): Promise<readonly Result<TAssociatedEntity>[]>;
-    /**
-     * Load an associated entity identified by a field value of this entity. In a relational database,
-     * the field in this entity is a foreign key to a unique field of the associated entity.
-     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the value with which to look up associated entity
-     * @param associatedEntityClass - class of the associated entity
-     * @param associatedEntityLookupByField - field of associated entity with which to look up the associated entity
-     * @param queryContext - query context in which to perform the load
-     */
-    loadAssociatedEntityByFieldEqualingAsync<TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields>(fieldIdentifyingAssociatedEntity: keyof Pick<TFields, TSelectedFields>, associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>, associatedEntityLookupByField: keyof Pick<TAssociatedFields, TAssociatedSelectedFields>, queryContext?: EntityQueryContext): Promise<Result<TAssociatedEntity> | null>;
-    /**
-     * Load many associated entities identified by a field value of this entity. In a relational database,
-     * the field in this entity refers to a field of the associated entity.
-     * @param fieldIdentifyingAssociatedEntity - field of this entity containing the value with which to look up associated entities
-     * @param associatedEntityClass - class of the associated entities
-     * @param associatedEntityLookupByField - field of associated entities with which to look up the associated entities
-     * @param queryContext - query context in which to perform the load
-     */
-    loadManyAssociatedEntitiesByFieldEqualingAsync<TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields>(fieldIdentifyingAssociatedEntity: keyof Pick<TFields, TSelectedFields>, associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>, associatedEntityLookupByField: keyof Pick<TAssociatedFields, TAssociatedSelectedFields>, queryContext?: EntityQueryContext): Promise<readonly Result<TAssociatedEntity>[]>;
-    /**
-     * Load an associated entity by folding a sequence of EntityLoadThroughDirective. At each
-     * fold step, load an associated entity identified by a field value of the current fold value.
-     * @param loadDirectives - associated entity load directives instructing each step of the fold
-     * @param queryContext - query context in which to perform the loads
-     */
-    loadAssociatedEntityThroughAsync<TFields2 extends object, TID2 extends NonNullable<TFields2[TSelectedFields2]>, TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>, TPrivacyPolicy2 extends EntityPrivacyPolicy<TFields2, TID2, TViewerContext, TEntity2, TSelectedFields2>, TSelectedFields2 extends keyof TFields2 = keyof TFields2>(loadDirectives: [
-        EntityLoadThroughDirective<TViewerContext, TFields, TFields2, TID2, TEntity2, TPrivacyPolicy2, TSelectedFields, TSelectedFields2>
-    ], queryContext?: EntityQueryContext): Promise<Result<TEntity2> | null>;
-    /**
-     * Load an associated entity by folding a sequence of EntityLoadThroughDirective. At each
-     * fold step, load an associated entity identified by a field value of the current fold value.
-     * @param loadDirectives - associated entity load directives instructing each step of the fold
-     * @param queryContext - query context in which to perform the loads
-     */
-    loadAssociatedEntityThroughAsync<TFields2 extends object, TID2 extends NonNullable<TFields2[TSelectedFields2]>, TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>, TPrivacyPolicy2 extends EntityPrivacyPolicy<TFields2, TID2, TViewerContext, TEntity2, TSelectedFields2>, TFields3 extends object, TID3 extends NonNullable<TFields3[TSelectedFields3]>, TEntity3 extends ReadonlyEntity<TFields3, TID3, TViewerContext, TSelectedFields3>, TPrivacyPolicy3 extends EntityPrivacyPolicy<TFields3, TID3, TViewerContext, TEntity3, TSelectedFields3>, TSelectedFields2 extends keyof TFields2 = keyof TFields2, TSelectedFields3 extends keyof TFields3 = keyof TFields3>(loadDirectives: [
-        EntityLoadThroughDirective<TViewerContext, TFields, TFields2, TID2, TEntity2, TPrivacyPolicy2, TSelectedFields, TSelectedFields2>,
-        EntityLoadThroughDirective<TViewerContext, TFields2, TFields3, TID3, TEntity3, TPrivacyPolicy3, TSelectedFields2, TSelectedFields3>
-    ], queryContext?: EntityQueryContext): Promise<Result<TEntity3> | null>;
-    /**
-     * Load an associated entity by folding a sequence of EntityLoadThroughDirective. At each
-     * fold step, load an associated entity identified by a field value of the current fold value.
-     * @param loadDirectives - associated entity load directives instructing each step of the fold
-     * @param queryContext - query context in which to perform the loads
-     */
-    loadAssociatedEntityThroughAsync<TFields2 extends object, TID2 extends NonNullable<TFields2[TSelectedFields2]>, TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>, TPrivacyPolicy2 extends EntityPrivacyPolicy<TFields2, TID2, TViewerContext, TEntity2, TSelectedFields2>, TFields3 extends object, TID3 extends NonNullable<TFields3[TSelectedFields3]>, TEntity3 extends ReadonlyEntity<TFields3, TID3, TViewerContext, TSelectedFields3>, TPrivacyPolicy3 extends EntityPrivacyPolicy<TFields3, TID3, TViewerContext, TEntity3, TSelectedFields3>, TFields4 extends object, TID4 extends NonNullable<TFields4[TSelectedFields4]>, TEntity4 extends ReadonlyEntity<TFields4, TID4, TViewerContext, TSelectedFields4>, TPrivacyPolicy4 extends EntityPrivacyPolicy<TFields4, TID4, TViewerContext, TEntity4, TSelectedFields4>, TSelectedFields2 extends keyof TFields2 = keyof TFields2, TSelectedFields3 extends keyof TFields3 = keyof TFields3, TSelectedFields4 extends keyof TFields4 = keyof TFields4>(loadDirectives: [
-        EntityLoadThroughDirective<TViewerContext, TFields, TFields2, TID2, TEntity2, TPrivacyPolicy2, TSelectedFields, TSelectedFields2>,
-        EntityLoadThroughDirective<TViewerContext, TFields2, TFields3, TID3, TEntity3, TPrivacyPolicy3, TSelectedFields2, TSelectedFields3>,
-        EntityLoadThroughDirective<TViewerContext, TFields3, TFields4, TID4, TEntity4, TPrivacyPolicy4, TSelectedFields3, TSelectedFields4>
-    ], queryContext?: EntityQueryContext): Promise<Result<TEntity4> | null>;
-    /**
-     * Load an associated entity by folding a sequence of EntityLoadThroughDirective. At each
-     * fold step, load an associated entity identified by a field value of the current fold value.
-     * @param loadDirectives - associated entity load directives instructing each step of the fold
-     * @param queryContext - query context in which to perform the loads
-     */
-    loadAssociatedEntityThroughAsync(loadDirectives: EntityLoadThroughDirective<TViewerContext, any, any, any, any, any, any, any>[], queryContext?: EntityQueryContext): Promise<Result<ReadonlyEntity<any, any, any, any>> | null>;
-}
-/**
- * Instruction for each step of a load-associated-through method.
- */
-export interface EntityLoadThroughDirective<TViewerContext extends ViewerContext, TFields, TAssociatedFields extends object, TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>, TAssociatedEntity extends ReadonlyEntity<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedSelectedFields>, TAssociatedPrivacyPolicy extends EntityPrivacyPolicy<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedSelectedFields>, TSelectedFields extends keyof TFields = keyof TFields, TAssociatedSelectedFields extends keyof TAssociatedFields = keyof TAssociatedFields> {
-    /**
-     * Class of entity to load at this step.
-     */
-    associatedEntityClass: IEntityClass<TAssociatedFields, TAssociatedID, TViewerContext, TAssociatedEntity, TAssociatedPrivacyPolicy, TAssociatedSelectedFields>;
-    /**
-     * Field of the current entity with which to load an instance of associatedEntityClass.
-     */
-    fieldIdentifyingAssociatedEntity: keyof Pick<TFields, TSelectedFields>;
-    /**
-     * Field by which to load the instance of associatedEntityClass. If not provided, the
-     * associatedEntityClass instance is fetched by its ID.
-     */
-    associatedEntityLookupByField?: keyof Pick<TAssociatedFields, TAssociatedSelectedFields>;
+    withAuthorizationResults(): AuthorizationResultBasedEntityAssociationLoader<TFields, TID, TViewerContext, TEntity, TSelectedFields>;
 }