@expo/entity 0.38.0 → 0.40.0

package/src/{EntityMutator.ts → AuthorizationResultBasedEntityMutator.ts}

@@ -21,12 +21,13 @@ import EntityMutationValidator from './EntityMutationValidator';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
 import { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext';
 import ViewerContext from './ViewerContext';
+import { enforceResultsAsync } from './entityUtils';
 import EntityInvalidFieldValueError from './errors/EntityInvalidFieldValueError';
 import { timeAndLogMutationEventAsync } from './metrics/EntityMetricsUtils';
 import IEntityMetricsAdapter, { EntityMetricsMutationType } from './metrics/IEntityMetricsAdapter';
 import { mapMapAsync } from './utils/collections/maps';
 
-abstract class BaseMutator<
+abstract class AuthorizationResultBasedBaseMutator<
   TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
@@ -154,7 +155,7 @@ abstract class BaseMutator<
 /**
  * Mutator for creating a new entity.
  */
-export class CreateMutator<
+export class AuthorizationResultBasedCreateMutator<
   TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
@@ -167,12 +168,19 @@ export class CreateMutator<
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields,
-> extends BaseMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
+> extends AuthorizationResultBasedBaseMutator<
+  TFields,
+  TID,
+  TViewerContext,
+  TEntity,
+  TPrivacyPolicy,
+  TSelectedFields
+> {
   private readonly fieldsForEntity: Partial<TFields> = {};
 
   /**
    * Set the value for entity field.
-   * @param fieldName - entity field being updated
+   * @param fieldName - entity field being set
    * @param value - value for entity field
    */
   setField<K extends keyof Pick<TFields, TSelectedFields>>(fieldName: K, value: TFields[K]): this {
@@ -193,13 +201,6 @@ export class CreateMutator<
     )(this.createInTransactionAsync());
   }
 
-  /**
-   * Convenience method that returns the new entity or throws upon create failure.
-   */
-  async enforceCreateAsync(): Promise<TEntity> {
-    return await enforceAsyncResult(this.createAsync());
-  }
-
   private async createInTransactionAsync(): Promise<Result<TEntity>> {
     return await this.queryContext.runInTransactionIfNotInTransactionAsync((innerQueryContext) =>
       this.createInternalAsync(innerQueryContext),
@@ -216,7 +217,7 @@ export class CreateMutator<
       cascadingDeleteCause: null,
     });
 
-    const temporaryEntityForPrivacyCheck = entityLoader.utils().constructEntity({
+    const temporaryEntityForPrivacyCheck = entityLoader.utils.constructEntity({
       [this.entityConfiguration.idField]: '00000000-0000-0000-0000-000000000000', // zero UUID
       ...this.fieldsForEntity,
     } as unknown as TFields);
@@ -256,13 +257,13 @@ export class CreateMutator<
     const insertResult = await this.databaseAdapter.insertAsync(queryContext, this.fieldsForEntity);
 
     queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.utils().invalidateFieldsAsync.bind(entityLoader, insertResult),
+      entityLoader.utils.invalidateFieldsAsync.bind(entityLoader, insertResult),
     );
 
-    const unauthorizedEntityAfterInsert = entityLoader.utils().constructEntity(insertResult);
-    const newEntity = await entityLoader
-      .enforcing()
-      .loadByIDAsync(unauthorizedEntityAfterInsert.getID());
+    const unauthorizedEntityAfterInsert = entityLoader.utils.constructEntity(insertResult);
+    const newEntity = await enforceAsyncResult(
+      entityLoader.loadByIDAsync(unauthorizedEntityAfterInsert.getID()),
+    );
 
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.afterCreate,
@@ -293,7 +294,7 @@ export class CreateMutator<
 /**
  * Mutator for updating an existing entity.
  */
-export class UpdateMutator<
+export class AuthorizationResultBasedUpdateMutator<
   TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
@@ -306,7 +307,14 @@ export class UpdateMutator<
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields,
-> extends BaseMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
+> extends AuthorizationResultBasedBaseMutator<
+  TFields,
+  TID,
+  TViewerContext,
+  TEntity,
+  TPrivacyPolicy,
+  TSelectedFields
+> {
   private readonly originalEntity: TEntity;
   private readonly fieldsForEntity: TFields;
   private readonly updatedFields: Partial<TFields> = {};
@@ -392,13 +400,6 @@ export class UpdateMutator<
     )(this.updateInTransactionAsync(false, null));
   }
 
-  /**
-   * Convenience method that returns the updated entity or throws upon update failure.
-   */
-  async enforceUpdateAsync(): Promise<TEntity> {
-    return await enforceAsyncResult(this.updateAsync());
-  }
-
   private async updateInTransactionAsync(
     skipDatabaseUpdate: true,
     cascadingDeleteCause: EntityCascadingDeletionInfo,
@@ -429,7 +430,7 @@ export class UpdateMutator<
       cascadingDeleteCause,
     });
 
-    const entityAboutToBeUpdated = entityLoader.utils().constructEntity(this.fieldsForEntity);
+    const entityAboutToBeUpdated = entityLoader.utils.constructEntity(this.fieldsForEntity);
     const authorizeUpdateResult = await asyncResult(
       this.privacyPolicy.authorizeUpdateAsync(
         this.viewerContext,
@@ -473,17 +474,18 @@ export class UpdateMutator<
     }
 
     queryContext.appendPostCommitInvalidationCallback(
-      entityLoader
-        .utils()
-        .invalidateFieldsAsync.bind(entityLoader, this.originalEntity.getAllDatabaseFields()),
+      entityLoader.utils.invalidateFieldsAsync.bind(
+        entityLoader,
+        this.originalEntity.getAllDatabaseFields(),
+      ),
     );
     queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.utils().invalidateFieldsAsync.bind(entityLoader, this.fieldsForEntity),
+      entityLoader.utils.invalidateFieldsAsync.bind(entityLoader, this.fieldsForEntity),
     );
 
-    const updatedEntity = await entityLoader
-      .enforcing()
-      .loadByIDAsync(entityAboutToBeUpdated.getID()); // ID is guaranteed to be stable by ensureStableIDField
+    const updatedEntity = await enforceAsyncResult(
+      entityLoader.loadByIDAsync(entityAboutToBeUpdated.getID()),
+    ); // ID is guaranteed to be stable by ensureStableIDField
 
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.afterUpdate,
@@ -526,7 +528,7 @@ export class UpdateMutator<
 /**
  * Mutator for deleting an existing entity.
  */
-export class DeleteMutator<
+export class AuthorizationResultBasedDeleteMutator<
   TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
@@ -539,7 +541,14 @@ export class DeleteMutator<
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields,
-> extends BaseMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
+> extends AuthorizationResultBasedBaseMutator<
+  TFields,
+  TID,
+  TViewerContext,
+  TEntity,
+  TPrivacyPolicy,
+  TSelectedFields
+> {
   constructor(
     companionProvider: EntityCompanionProvider,
     viewerContext: TViewerContext,
@@ -607,13 +616,6 @@ export class DeleteMutator<
     )(this.deleteInTransactionAsync(new Set(), false, null));
   }
 
-  /**
-   * Convenience method that throws upon delete failure.
-   */
-  async enforceDeleteAsync(): Promise<void> {
-    return await enforceAsyncResult(this.deleteAsync());
-  }
-
   private async deleteInTransactionAsync(
     processedEntityIdentifiersFromTransitiveDeletions: Set<string>,
     skipDatabaseDeletion: boolean,
@@ -681,9 +683,10 @@ export class DeleteMutator<
       cascadingDeleteCause,
     });
     queryContext.appendPostCommitInvalidationCallback(
-      entityLoader
-        .utils()
-        .invalidateFieldsAsync.bind(entityLoader, this.entity.getAllDatabaseFields()),
+      entityLoader.utils.invalidateFieldsAsync.bind(
+        entityLoader,
+        this.entity.getAllDatabaseFields(),
+      ),
     );
 
     await this.executeMutationTriggersAsync(
@@ -782,18 +785,19 @@ export class DeleteMutator<
               return;
             }
 
-            const inboundReferenceEntities = await loaderFactory
-              .forLoad(queryContext, {
-                previousValue: null,
-                cascadingDeleteCause: newCascadingDeleteCause,
-              })
-              .enforcing()
-              .loadManyByFieldEqualingAsync(
-                fieldName,
-                association.associatedEntityLookupByField
-                  ? entity.getField(association.associatedEntityLookupByField as any)
-                  : entity.getID(),
-              );
+            const inboundReferenceEntities = await enforceResultsAsync(
+              loaderFactory
+                .forLoad(queryContext, {
+                  previousValue: null,
+                  cascadingDeleteCause: newCascadingDeleteCause,
+                })
+                .loadManyByFieldEqualingAsync(
+                  fieldName,
+                  association.associatedEntityLookupByField
+                    ? entity.getField(association.associatedEntityLookupByField as any)
+                    : entity.getID(),
+                ),
+            );
 
             switch (association.edgeDeletionBehavior) {
               case EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY: {

package/src/EnforcingEntityAssociationLoader.ts

@@ -0,0 +1,390 @@
+import { enforceAsyncResult } from '@expo/results';
+
+import AuthorizationResultBasedEntityAssociationLoader, {
+  EntityLoadThroughDirective,
+} from './AuthorizationResultBasedEntityAssociationLoader';
+import { IEntityClass } from './Entity';
+import EntityPrivacyPolicy from './EntityPrivacyPolicy';
+import ReadonlyEntity from './ReadonlyEntity';
+import ViewerContext from './ViewerContext';
+import { enforceResultsAsync } from './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.
+ */
+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,
+> {
+  constructor(
+    private readonly 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
+   */
+  async 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
+  > {
+    return await 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<
+    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[]> {
+    return await 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<
+    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> {
+    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<
+    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[]> {
+    return await enforceResultsAsync(
+      this.authorizationResultBasedEntityAssociationLoader.loadManyAssociatedEntitiesByFieldEqualingAsync(
+        fieldIdentifyingAssociatedEntity,
+        associatedEntityClass,
+        associatedEntityLookupByField,
+      ),
+    );
+  }
+
+  /**
+   * 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
+   */
+  async 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
+   */
+  async 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
+   */
+  async 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
+   */
+  async loadAssociatedEntityThroughAsync(
+    loadDirectives: EntityLoadThroughDirective<TViewerContext, any, any, any, any, any, any, any>[],
+  ): Promise<ReadonlyEntity<any, any, any, any> | null>;
+
+  async loadAssociatedEntityThroughAsync(
+    loadDirectives: EntityLoadThroughDirective<TViewerContext, any, any, any, any, any, any, any>[],
+  ): Promise<ReadonlyEntity<any, any, any, any> | null> {
+    const result =
+      await this.authorizationResultBasedEntityAssociationLoader.loadAssociatedEntityThroughAsync(
+        loadDirectives,
+      );
+    return result?.enforceValue() ?? null;
+  }
+}

package/src/EnforcingEntityCreator.ts

@@ -0,0 +1,55 @@
+import { enforceAsyncResult } from '@expo/results';
+
+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,
+> {
+  constructor(
+    private readonly 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 {
+    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(): Promise<TEntity> {
+    return await enforceAsyncResult(this.entityCreator.createAsync());
+  }
+}