@expo/entity 0.35.0 → 0.36.0

package/src/EntityMutator.ts

@@ -20,7 +20,6 @@ import EntityMutationTriggerConfiguration, {
 import EntityMutationValidator from './EntityMutationValidator';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
 import { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext';
-import ReadonlyEntity from './ReadonlyEntity';
 import ViewerContext from './ViewerContext';
 import EntityInvalidFieldValueError from './errors/EntityInvalidFieldValueError';
 import { timeAndLogMutationEventAsync } from './metrics/EntityMetricsUtils';
@@ -39,7 +38,7 @@ abstract class BaseMutator<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > {
   constructor(
     protected readonly companionProvider: EntityCompanionProvider,
@@ -78,7 +77,7 @@ abstract class BaseMutator<
       TSelectedFields
     >,
     protected readonly databaseAdapter: EntityDatabaseAdapter<TFields>,
-    protected readonly metricsAdapter: IEntityMetricsAdapter
+    protected readonly metricsAdapter: IEntityMetricsAdapter,
   ) {}
 
   protected validateFields(fields: Partial<TFields>): void {
@@ -103,12 +102,12 @@ abstract class BaseMutator<
       TViewerContext,
       TEntity,
       TSelectedFields
-    >
+    >,
   ): Promise<void> {
     await Promise.all(
       validators.map((validator) =>
-        validator.executeAsync(this.viewerContext, queryContext, entity, mutationInfo)
-      )
+        validator.executeAsync(this.viewerContext, queryContext, entity, mutationInfo),
+      ),
     );
   }
 
@@ -118,15 +117,15 @@ abstract class BaseMutator<
       | undefined,
     queryContext: EntityTransactionalQueryContext,
     entity: TEntity,
-    mutationInfo: EntityTriggerMutationInfo<TFields, TID, TViewerContext, TEntity, TSelectedFields>
+    mutationInfo: EntityTriggerMutationInfo<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
   ): Promise<void> {
     if (!triggers) {
       return;
     }
     await Promise.all(
       triggers.map((trigger) =>
-        trigger.executeAsync(this.viewerContext, queryContext, entity, mutationInfo)
-      )
+        trigger.executeAsync(this.viewerContext, queryContext, entity, mutationInfo),
+      ),
     );
   }
 
@@ -141,13 +140,13 @@ abstract class BaseMutator<
         >[]
       | undefined,
     entity: TEntity,
-    mutationInfo: EntityTriggerMutationInfo<TFields, TID, TViewerContext, TEntity, TSelectedFields>
+    mutationInfo: EntityTriggerMutationInfo<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
   ): Promise<void> {
     if (!triggers) {
       return;
     }
     await Promise.all(
-      triggers.map((trigger) => trigger.executeAsync(this.viewerContext, entity, mutationInfo))
+      triggers.map((trigger) => trigger.executeAsync(this.viewerContext, entity, mutationInfo)),
     );
   }
 }
@@ -167,7 +166,7 @@ export class CreateMutator<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > extends BaseMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
   private readonly fieldsForEntity: Partial<TFields> = {};
 
@@ -190,7 +189,7 @@ export class CreateMutator<
     return await timeAndLogMutationEventAsync(
       this.metricsAdapter,
       EntityMetricsMutationType.CREATE,
-      this.entityClass.name
+      this.entityClass.name,
     )(this.createInTransactionAsync());
   }
 
@@ -203,20 +202,21 @@ export class CreateMutator<
 
   private async createInTransactionAsync(): Promise<Result<TEntity>> {
     return await this.queryContext.runInTransactionIfNotInTransactionAsync((innerQueryContext) =>
-      this.createInternalAsync(innerQueryContext)
+      this.createInternalAsync(innerQueryContext),
     );
   }
 
   private async createInternalAsync(
-    queryContext: EntityTransactionalQueryContext
+    queryContext: EntityTransactionalQueryContext,
   ): Promise<Result<TEntity>> {
     this.validateFields(this.fieldsForEntity);
 
     const entityLoader = this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, {
+      previousValue: null,
       cascadingDeleteCause: null,
     });
 
-    const temporaryEntityForPrivacyCheck = entityLoader.constructEntity({
+    const temporaryEntityForPrivacyCheck = entityLoader.utils().constructEntity({
       [this.entityConfiguration.idField]: '00000000-0000-0000-0000-000000000000', // zero UUID
       ...this.fieldsForEntity,
     } as unknown as TFields);
@@ -225,10 +225,10 @@ export class CreateMutator<
       this.privacyPolicy.authorizeCreateAsync(
         this.viewerContext,
         queryContext,
-        { cascadingDeleteCause: null },
+        { previousValue: null, cascadingDeleteCause: null },
         temporaryEntityForPrivacyCheck,
-        this.metricsAdapter
-      )
+        this.metricsAdapter,
+      ),
     );
     if (!authorizeCreateResult.ok) {
       return authorizeCreateResult;
@@ -238,28 +238,28 @@ export class CreateMutator<
       this.mutationValidators,
       queryContext,
       temporaryEntityForPrivacyCheck,
-      { type: EntityMutationType.CREATE }
+      { type: EntityMutationType.CREATE },
     );
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.beforeAll,
       queryContext,
       temporaryEntityForPrivacyCheck,
-      { type: EntityMutationType.CREATE }
+      { type: EntityMutationType.CREATE },
     );
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.beforeCreate,
       queryContext,
       temporaryEntityForPrivacyCheck,
-      { type: EntityMutationType.CREATE }
+      { type: EntityMutationType.CREATE },
     );
 
     const insertResult = await this.databaseAdapter.insertAsync(queryContext, this.fieldsForEntity);
 
     queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.invalidateFieldsAsync.bind(entityLoader, insertResult)
+      entityLoader.utils().invalidateFieldsAsync.bind(entityLoader, insertResult),
     );
 
-    const unauthorizedEntityAfterInsert = entityLoader.constructEntity(insertResult);
+    const unauthorizedEntityAfterInsert = entityLoader.utils().constructEntity(insertResult);
     const newEntity = await entityLoader
       .enforcing()
       .loadByIDAsync(unauthorizedEntityAfterInsert.getID());
@@ -268,13 +268,13 @@ export class CreateMutator<
       this.mutationTriggers.afterCreate,
       queryContext,
       newEntity,
-      { type: EntityMutationType.CREATE }
+      { type: EntityMutationType.CREATE },
     );
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.afterAll,
       queryContext,
       newEntity,
-      { type: EntityMutationType.CREATE }
+      { type: EntityMutationType.CREATE },
     );
 
     queryContext.appendPostCommitCallback(
@@ -282,8 +282,8 @@ export class CreateMutator<
         this,
         this.mutationTriggers.afterCommit,
         newEntity,
-        { type: EntityMutationType.CREATE }
-      )
+        { type: EntityMutationType.CREATE },
+      ),
     );
 
     return result(newEntity);
@@ -305,7 +305,7 @@ export class UpdateMutator<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > extends BaseMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
   private readonly originalEntity: TEntity;
   private readonly fieldsForEntity: TFields;
@@ -349,7 +349,7 @@ export class UpdateMutator<
     >,
     databaseAdapter: EntityDatabaseAdapter<TFields>,
     metricsAdapter: IEntityMetricsAdapter,
-    originalEntity: TEntity
+    originalEntity: TEntity,
   ) {
     super(
       companionProvider,
@@ -362,7 +362,7 @@ export class UpdateMutator<
       mutationTriggers,
       entityLoaderFactory,
       databaseAdapter,
-      metricsAdapter
+      metricsAdapter,
     );
     this.originalEntity = originalEntity;
     this.fieldsForEntity = { ...originalEntity.getAllDatabaseFields() };
@@ -388,7 +388,7 @@ export class UpdateMutator<
     return await timeAndLogMutationEventAsync(
       this.metricsAdapter,
       EntityMetricsMutationType.UPDATE,
-      this.entityClass.name
+      this.entityClass.name,
     )(this.updateInTransactionAsync(false, null));
   }
 
@@ -401,41 +401,43 @@ export class UpdateMutator<
 
   private async updateInTransactionAsync(
     skipDatabaseUpdate: true,
-    cascadingDeleteCause: EntityCascadingDeletionInfo
+    cascadingDeleteCause: EntityCascadingDeletionInfo,
   ): Promise<Result<TEntity>>;
   private async updateInTransactionAsync(
     skipDatabaseUpdate: false,
-    cascadingDeleteCause: EntityCascadingDeletionInfo | null
+    cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   ): Promise<Result<TEntity>>;
   private async updateInTransactionAsync(
     skipDatabaseUpdate: boolean,
-    cascadingDeleteCause: EntityCascadingDeletionInfo | null
+    cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   ): Promise<Result<TEntity>> {
     return await this.queryContext.runInTransactionIfNotInTransactionAsync((innerQueryContext) =>
-      this.updateInternalAsync(innerQueryContext, skipDatabaseUpdate, cascadingDeleteCause)
+      this.updateInternalAsync(innerQueryContext, skipDatabaseUpdate, cascadingDeleteCause),
     );
   }
 
   private async updateInternalAsync(
     queryContext: EntityTransactionalQueryContext,
     skipDatabaseUpdate: boolean,
-    cascadingDeleteCause: EntityCascadingDeletionInfo | null
+    cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   ): Promise<Result<TEntity>> {
     this.validateFields(this.updatedFields);
+    this.ensureStableIDField(this.updatedFields);
 
     const entityLoader = this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, {
+      previousValue: this.originalEntity,
       cascadingDeleteCause,
     });
 
-    const entityAboutToBeUpdated = entityLoader.constructEntity(this.fieldsForEntity);
+    const entityAboutToBeUpdated = entityLoader.utils().constructEntity(this.fieldsForEntity);
     const authorizeUpdateResult = await asyncResult(
       this.privacyPolicy.authorizeUpdateAsync(
         this.viewerContext,
         queryContext,
-        { cascadingDeleteCause },
+        { previousValue: this.originalEntity, cascadingDeleteCause },
         entityAboutToBeUpdated,
-        this.metricsAdapter
-      )
+        this.metricsAdapter,
+      ),
     );
     if (!authorizeUpdateResult.ok) {
       return authorizeUpdateResult;
@@ -445,60 +447,55 @@ export class UpdateMutator<
       this.mutationValidators,
       queryContext,
       entityAboutToBeUpdated,
-      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause }
+      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause },
     );
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.beforeAll,
       queryContext,
       entityAboutToBeUpdated,
-      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause }
+      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause },
     );
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.beforeUpdate,
       queryContext,
       entityAboutToBeUpdated,
-      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause }
+      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause },
     );
 
     // skip the database update when specified
-    const updateResult = skipDatabaseUpdate
-      ? null
-      : await this.databaseAdapter.updateAsync(
-          queryContext,
-          this.entityConfiguration.idField,
-          entityAboutToBeUpdated.getID(),
-          this.updatedFields
-        );
+    if (!skipDatabaseUpdate) {
+      await this.databaseAdapter.updateAsync(
+        queryContext,
+        this.entityConfiguration.idField,
+        entityAboutToBeUpdated.getID(),
+        this.updatedFields,
+      );
+    }
 
     queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.invalidateFieldsAsync.bind(
-        entityLoader,
-        this.originalEntity.getAllDatabaseFields()
-      )
+      entityLoader
+        .utils()
+        .invalidateFieldsAsync.bind(entityLoader, this.originalEntity.getAllDatabaseFields()),
     );
     queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.invalidateFieldsAsync.bind(entityLoader, this.fieldsForEntity)
+      entityLoader.utils().invalidateFieldsAsync.bind(entityLoader, this.fieldsForEntity),
     );
 
-    // when the database update was skipped, assume it succeeded and use the optimistic
-    // entity to execute triggers
-    const updatedEntity = updateResult
-      ? await entityLoader
-          .enforcing()
-          .loadByIDAsync(entityLoader.constructEntity(updateResult).getID())
-      : entityAboutToBeUpdated;
+    const updatedEntity = await entityLoader
+      .enforcing()
+      .loadByIDAsync(entityAboutToBeUpdated.getID()); // ID is guaranteed to be stable by ensureStableIDField
 
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.afterUpdate,
       queryContext,
       updatedEntity,
-      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause }
+      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause },
     );
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.afterAll,
       queryContext,
       updatedEntity,
-      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause }
+      { type: EntityMutationType.UPDATE, previousValue: this.originalEntity, cascadingDeleteCause },
     );
 
     queryContext.appendPostCommitCallback(
@@ -510,12 +507,20 @@ export class UpdateMutator<
           type: EntityMutationType.UPDATE,
           previousValue: this.originalEntity,
           cascadingDeleteCause,
-        }
-      )
+        },
+      ),
     );
 
     return result(updatedEntity);
   }
+
+  private ensureStableIDField(updatedFields: Partial<TFields>): void {
+    const originalId = this.originalEntity.getID();
+    const idField = this.entityConfiguration.idField;
+    if (updatedFields.hasOwnProperty(idField) && originalId !== updatedFields[idField]) {
+      throw new Error(`id field updates not supported: (entityClass = ${this.entityClass.name})`);
+    }
+  }
 }
 
 /**
@@ -533,7 +538,7 @@ export class DeleteMutator<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > extends BaseMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
   constructor(
     companionProvider: EntityCompanionProvider,
@@ -573,7 +578,7 @@ export class DeleteMutator<
     >,
     databaseAdapter: EntityDatabaseAdapter<TFields>,
     metricsAdapter: IEntityMetricsAdapter,
-    private readonly entity: TEntity
+    private readonly entity: TEntity,
   ) {
     super(
       companionProvider,
@@ -586,7 +591,7 @@ export class DeleteMutator<
       mutationTriggers,
       entityLoaderFactory,
       databaseAdapter,
-      metricsAdapter
+      metricsAdapter,
     );
   }
 
@@ -598,7 +603,7 @@ export class DeleteMutator<
     return await timeAndLogMutationEventAsync(
       this.metricsAdapter,
       EntityMetricsMutationType.DELETE,
-      this.entityClass.name
+      this.entityClass.name,
     )(this.deleteInTransactionAsync(new Set(), false, null));
   }
 
@@ -612,15 +617,15 @@ export class DeleteMutator<
   private async deleteInTransactionAsync(
     processedEntityIdentifiersFromTransitiveDeletions: Set<string>,
     skipDatabaseDeletion: boolean,
-    cascadingDeleteCause: EntityCascadingDeletionInfo | null
+    cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   ): Promise<Result<void>> {
     return await this.queryContext.runInTransactionIfNotInTransactionAsync((innerQueryContext) =>
       this.deleteInternalAsync(
         innerQueryContext,
         processedEntityIdentifiersFromTransitiveDeletions,
         skipDatabaseDeletion,
-        cascadingDeleteCause
-      )
+        cascadingDeleteCause,
+      ),
     );
   }
 
@@ -628,16 +633,16 @@ export class DeleteMutator<
     queryContext: EntityTransactionalQueryContext,
     processedEntityIdentifiersFromTransitiveDeletions: Set<string>,
     skipDatabaseDeletion: boolean,
-    cascadingDeleteCause: EntityCascadingDeletionInfo | null
+    cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   ): Promise<Result<void>> {
     const authorizeDeleteResult = await asyncResult(
       this.privacyPolicy.authorizeDeleteAsync(
         this.viewerContext,
         queryContext,
-        { cascadingDeleteCause },
+        { previousValue: null, cascadingDeleteCause },
         this.entity,
-        this.metricsAdapter
-      )
+        this.metricsAdapter,
+      ),
     );
     if (!authorizeDeleteResult.ok) {
       return authorizeDeleteResult;
@@ -647,48 +652,51 @@ export class DeleteMutator<
       this.entity,
       queryContext,
       processedEntityIdentifiersFromTransitiveDeletions,
-      cascadingDeleteCause
+      cascadingDeleteCause,
     );
 
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.beforeAll,
       queryContext,
       this.entity,
-      { type: EntityMutationType.DELETE, cascadingDeleteCause }
+      { type: EntityMutationType.DELETE, cascadingDeleteCause },
     );
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.beforeDelete,
       queryContext,
       this.entity,
-      { type: EntityMutationType.DELETE, cascadingDeleteCause }
+      { type: EntityMutationType.DELETE, cascadingDeleteCause },
     );
 
     if (!skipDatabaseDeletion) {
       await this.databaseAdapter.deleteAsync(
         queryContext,
         this.entityConfiguration.idField,
-        this.entity.getID()
+        this.entity.getID(),
       );
     }
 
     const entityLoader = this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, {
+      previousValue: null,
       cascadingDeleteCause,
     });
     queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.invalidateFieldsAsync.bind(entityLoader, this.entity.getAllDatabaseFields())
+      entityLoader
+        .utils()
+        .invalidateFieldsAsync.bind(entityLoader, this.entity.getAllDatabaseFields()),
     );
 
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.afterDelete,
       queryContext,
       this.entity,
-      { type: EntityMutationType.DELETE, cascadingDeleteCause }
+      { type: EntityMutationType.DELETE, cascadingDeleteCause },
     );
     await this.executeMutationTriggersAsync(
       this.mutationTriggers.afterAll,
       queryContext,
       this.entity,
-      { type: EntityMutationType.DELETE, cascadingDeleteCause }
+      { type: EntityMutationType.DELETE, cascadingDeleteCause },
     );
 
     queryContext.appendPostCommitCallback(
@@ -696,8 +704,8 @@ export class DeleteMutator<
         this,
         this.mutationTriggers.afterCommit,
         this.entity,
-        { type: EntityMutationType.DELETE, cascadingDeleteCause }
-      )
+        { type: EntityMutationType.DELETE, cascadingDeleteCause },
+      ),
     );
 
     return result();
@@ -721,7 +729,7 @@ export class DeleteMutator<
     entity: TEntity,
     queryContext: EntityTransactionalQueryContext,
     processedEntityIdentifiers: Set<string>,
-    cascadingDeleteCause: EntityCascadingDeletionInfo | null
+    cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   ): Promise<void> {
     // prevent infinite reference cycles by keeping track of entities already processed
     if (processedEntityIdentifiers.has(entity.getUniqueIdentifier())) {
@@ -737,12 +745,27 @@ export class DeleteMutator<
         TEntity,
         TPrivacyPolicy,
         TSelectedFields
-      >
+      >,
     ).entityCompanionDefinition;
     const entityConfiguration = companionDefinition.entityConfiguration;
     const inboundEdges = entityConfiguration.inboundEdges;
+
+    const newCascadingDeleteCause = {
+      entity,
+      cascadingDeleteCause,
+    };
+
     await Promise.all(
       inboundEdges.map(async (entityClass) => {
+        const loaderFactory = entity
+          .getViewerContext()
+          .getViewerScopedEntityCompanionForClass(entityClass)
+          .getLoaderFactory();
+        const mutatorFactory = entity
+          .getViewerContext()
+          .getViewerScopedEntityCompanionForClass(entityClass)
+          .getMutatorFactory();
+
         return await mapMapAsync(
           this.companionProvider.getCompanionForEntity(entityClass).entityCompanionDefinition
             .entityConfiguration.schema,
@@ -753,43 +776,24 @@ export class DeleteMutator<
             }
 
             const associatedConfiguration = this.companionProvider.getCompanionForEntity(
-              association.associatedEntityClass
+              association.associatedEntityClass,
             ).entityCompanionDefinition.entityConfiguration;
             if (associatedConfiguration !== entityConfiguration) {
               return;
             }
 
-            const associatedEntityLookupByField = association.associatedEntityLookupByField;
-
-            const loaderFactory = entity
-              .getViewerContext()
-              .getViewerScopedEntityCompanionForClass(entityClass)
-              .getLoaderFactory();
-            const mutatorFactory = entity
-              .getViewerContext()
-              .getViewerScopedEntityCompanionForClass(entityClass)
-              .getMutatorFactory();
-
-            const newCascadingDeleteCause = {
-              entity,
-              cascadingDeleteCause,
-            };
-
-            let inboundReferenceEntities: readonly ReadonlyEntity<any, any, any, any>[];
-            if (associatedEntityLookupByField) {
-              inboundReferenceEntities = await loaderFactory
-                .forLoad(queryContext, { cascadingDeleteCause: newCascadingDeleteCause })
-                .enforcing()
-                .loadManyByFieldEqualingAsync(
-                  fieldName,
-                  entity.getField(associatedEntityLookupByField as any)
-                );
-            } else {
-              inboundReferenceEntities = await loaderFactory
-                .forLoad(queryContext, { cascadingDeleteCause: newCascadingDeleteCause })
-                .enforcing()
-                .loadManyByFieldEqualingAsync(fieldName, entity.getID());
-            }
+            const inboundReferenceEntities = await loaderFactory
+              .forLoad(queryContext, {
+                previousValue: null,
+                cascadingDeleteCause: newCascadingDeleteCause,
+              })
+              .enforcing()
+              .loadManyByFieldEqualingAsync(
+                fieldName,
+                association.associatedEntityLookupByField
+                  ? entity.getField(association.associatedEntityLookupByField as any)
+                  : entity.getID(),
+              );
 
             switch (association.edgeDeletionBehavior) {
               case EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY: {
@@ -801,10 +805,10 @@ export class DeleteMutator<
                         .deleteInTransactionAsync(
                           processedEntityIdentifiers,
                           /* skipDatabaseDeletion */ true, // deletion is handled by DB
-                          newCascadingDeleteCause
-                        )
-                    )
-                  )
+                          newCascadingDeleteCause,
+                        ),
+                    ),
+                  ),
                 );
                 break;
               }
@@ -815,12 +819,11 @@ export class DeleteMutator<
                       mutatorFactory
                         .forUpdate(inboundReferenceEntity, queryContext)
                         .setField(fieldName, null)
-                        ['updateInTransactionAsync'](
-                          /* skipDatabaseUpdate */ true,
-                          newCascadingDeleteCause
-                        )
-                    )
-                  )
+                        [
+                          'updateInTransactionAsync'
+                        ](/* skipDatabaseUpdate */ true, newCascadingDeleteCause),
+                    ),
+                  ),
                 );
                 break;
               }
@@ -831,12 +834,11 @@ export class DeleteMutator<
                       mutatorFactory
                         .forUpdate(inboundReferenceEntity, queryContext)
                         .setField(fieldName, null)
-                        ['updateInTransactionAsync'](
-                          /* skipDatabaseUpdate */ false,
-                          newCascadingDeleteCause
-                        )
-                    )
-                  )
+                        [
+                          'updateInTransactionAsync'
+                        ](/* skipDatabaseUpdate */ false, newCascadingDeleteCause),
+                    ),
+                  ),
                 );
                 break;
               }
@@ -849,16 +851,16 @@ export class DeleteMutator<
                         .deleteInTransactionAsync(
                           processedEntityIdentifiers,
                           /* skipDatabaseDeletion */ false,
-                          newCascadingDeleteCause
-                        )
-                    )
-                  )
+                          newCascadingDeleteCause,
+                        ),
+                    ),
+                  ),
                 );
               }
             }
-          }
+          },
         );
-      })
+      }),
     );
   }
 }