@expo/entity 0.35.0 → 0.36.0

package/src/__tests__/EntityMutator-test.ts

@@ -17,6 +17,7 @@ import EntityConfiguration from '../EntityConfiguration';
 import EntityDatabaseAdapter from '../EntityDatabaseAdapter';
 import EntityLoader from '../EntityLoader';
 import EntityLoaderFactory from '../EntityLoaderFactory';
+import EntityLoaderUtils from '../EntityLoaderUtils';
 import {
   EntityMutationType,
   EntityTriggerMutationInfo,
@@ -68,7 +69,7 @@ class TestMutationTrigger extends EntityMutationTrigger<
       ViewerContext,
       TestEntity,
       keyof TestFields
-    >
+    >,
   ): Promise<void> {}
 }
 
@@ -89,7 +90,7 @@ const setUpMutationValidatorSpies = (
     ViewerContext,
     TestEntity,
     keyof TestFields
-  >[]
+  >[],
 ): EntityMutationValidator<TestFields, string, ViewerContext, TestEntity, keyof TestFields>[] => {
   return mutationValidators.map((validator) => spy(validator));
 };
@@ -110,7 +111,7 @@ const verifyValidatorCounts = (
     ViewerContext,
     TestEntity,
     keyof TestFields
-  >
+  >,
 ): void => {
   for (const validator of mutationValidatorSpies) {
     verify(
@@ -118,8 +119,8 @@ const verifyValidatorCounts = (
         viewerContext,
         anyOfClass(EntityTransactionalQueryContext),
         anyOfClass(TestEntity),
-        deepEqual(mutationInfo)
-      )
+        deepEqual(mutationInfo),
+      ),
     ).times(expectedCalls);
   }
 };
@@ -131,7 +132,7 @@ const setUpMutationTriggerSpies = (
     ViewerContext,
     TestEntity,
     keyof TestFields
-  >
+  >,
 ): EntityMutationTriggerConfiguration<
   TestFields,
   string,
@@ -185,7 +186,7 @@ const verifyTriggerCounts = (
     ViewerContext,
     TestEntity,
     keyof TestFields
-  >
+  >,
 ): void => {
   Object.keys(executed).forEach((s) => {
     if ((executed as any)[s]) {
@@ -194,8 +195,8 @@ const verifyTriggerCounts = (
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
           anyOfClass(TestEntity),
-          deepEqual(mutationInfo)
-        )
+          deepEqual(mutationInfo),
+        ),
       ).once();
     } else {
       verify(
@@ -203,8 +204,8 @@ const verifyTriggerCounts = (
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
           anyOfClass(TestEntity),
-          deepEqual(mutationInfo)
-        )
+          deepEqual(mutationInfo),
+        ),
       ).never();
     }
   });
@@ -214,8 +215,8 @@ const verifyTriggerCounts = (
       viewerContext,
       anyOfClass(EntityTransactionalQueryContext),
       anyOfClass(TestEntity),
-      deepEqual(mutationInfo)
-    )
+      deepEqual(mutationInfo),
+    ),
   ).once();
 
   verify(
@@ -223,21 +224,21 @@ const verifyTriggerCounts = (
       viewerContext,
       anyOfClass(EntityTransactionalQueryContext),
       anyOfClass(TestEntity),
-      deepEqual(mutationInfo)
-    )
+      deepEqual(mutationInfo),
+    ),
   ).once();
 
   verify(
     mutationTriggerSpies.afterCommit![0]!.executeAsync(
       viewerContext,
       anyOfClass(TestEntity),
-      deepEqual(mutationInfo)
-    )
+      deepEqual(mutationInfo),
+    ),
   ).once();
 };
 
 const createEntityMutatorFactory = (
-  existingObjects: TestFields[]
+  existingObjects: TestFields[],
 ): {
   privacyPolicy: TestEntityPrivacyPolicy;
   entityLoaderFactory: EntityLoaderFactory<
@@ -295,17 +296,16 @@ const createEntityMutatorFactory = (
     afterAll: [new TestMutationTrigger()],
     afterCommit: [new TestNonTransactionalMutationTrigger()],
   };
-  const privacyPolicy = new TestEntityPrivacyPolicy();
   const databaseAdapter = new StubDatabaseAdapter<TestFields>(
     testEntityConfiguration,
     StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      new Map([[testEntityConfiguration.tableName, existingObjects]])
-    )
+      new Map([[testEntityConfiguration.tableName, existingObjects]]),
+    ),
   );
   const customStubDatabaseAdapterProvider: IEntityDatabaseAdapterProvider = {
-    getDatabaseAdapter<TFields>(
-      _entityConfiguration: EntityConfiguration<TFields>
+    getDatabaseAdapter<TFields extends Record<string, any>>(
+      _entityConfiguration: EntityConfiguration<TFields>,
     ): EntityDatabaseAdapter<TFields> {
       return databaseAdapter as any as EntityDatabaseAdapter<TFields>;
     },
@@ -333,7 +333,7 @@ const createEntityMutatorFactory = (
           cacheAdapterProvider,
         },
       ],
-    ])
+    ]),
   );
 
   const dataManager = new EntityDataManager(
@@ -341,26 +341,26 @@ const createEntityMutatorFactory = (
     entityCache,
     StubQueryContextProvider,
     metricsAdapter,
-    TestEntity.name
+    TestEntity.name,
   );
   const entityLoaderFactory = new EntityLoaderFactory(
     companionProvider.getCompanionForEntity(TestEntity),
     dataManager,
-    metricsAdapter
+    metricsAdapter,
   );
   const entityMutatorFactory = new EntityMutatorFactory(
     companionProvider,
     testEntityConfiguration,
     TestEntity,
-    privacyPolicy,
+    companionProvider.getCompanionForEntity(TestEntity).privacyPolicy,
     mutationValidators,
     mutationTriggers,
     entityLoaderFactory,
     databaseAdapter,
-    metricsAdapter
+    metricsAdapter,
   );
   return {
-    privacyPolicy,
+    privacyPolicy: companionProvider.getCompanionForEntity(TestEntity).privacyPolicy,
     entityLoaderFactory,
     entityMutatorFactory,
     metricsAdapter,
@@ -438,10 +438,10 @@ describe(EntityMutatorFactory, () => {
         spiedPrivacyPolicy.authorizeCreateAsync(
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
-          deepEqual({ cascadingDeleteCause: null }),
+          deepEqual({ previousValue: null, cascadingDeleteCause: null }),
           anyOfClass(TestEntity),
-          anything()
-        )
+          anything(),
+        ),
       ).once();
     });
 
@@ -488,7 +488,7 @@ describe(EntityMutatorFactory, () => {
           beforeDelete: false,
           afterDelete: false,
         },
-        { type: EntityMutationType.CREATE }
+        { type: EntityMutationType.CREATE },
       );
     });
 
@@ -531,7 +531,18 @@ describe(EntityMutatorFactory, () => {
   describe('forUpdate', () => {
     it('updates entities', async () => {
       const viewerContext = mock<ViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
       const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
@@ -558,7 +569,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id2)
+          .withAuthorizationResults()
+          .loadByIDAsync(id2),
       );
 
       const updatedEntity = await entityMutatorFactory
@@ -573,14 +585,14 @@ describe(EntityMutatorFactory, () => {
       const reloadedEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id2)
+          .withAuthorizationResults()
+          .loadByIDAsync(id2),
       );
       expect(reloadedEntity.getAllFields()).toMatchObject(updatedEntity.getAllFields());
     });
 
     it('checks privacy', async () => {
       const viewerContext = mock<ViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
       const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
@@ -609,8 +621,9 @@ describe(EntityMutatorFactory, () => {
 
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
-          .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id2)
+          .forLoad(viewerContext, queryContext, { previousValue: null, cascadingDeleteCause: null })
+          .withAuthorizationResults()
+          .loadByIDAsync(id2),
       );
 
       await entityMutatorFactory
@@ -622,16 +635,37 @@ describe(EntityMutatorFactory, () => {
         spiedPrivacyPolicy.authorizeUpdateAsync(
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
-          deepEqual({ cascadingDeleteCause: null }),
+          deepEqual({ previousValue: existingEntity, cascadingDeleteCause: null }),
           anyOfClass(TestEntity),
-          anything()
-        )
+          anything(),
+        ),
+      ).once();
+
+      verify(
+        spiedPrivacyPolicy.authorizeReadAsync(
+          viewerContext,
+          anyOfClass(EntityTransactionalQueryContext),
+          deepEqual({ previousValue: existingEntity, cascadingDeleteCause: null }),
+          anyOfClass(TestEntity),
+          anything(),
+        ),
       ).once();
     });
 
     it('executes triggers', async () => {
       const viewerContext = mock<ViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
       const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
@@ -661,7 +695,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id2)
+          .withAuthorizationResults()
+          .loadByIDAsync(id2),
       );
 
       await entityMutatorFactory
@@ -684,12 +719,24 @@ describe(EntityMutatorFactory, () => {
           type: EntityMutationType.UPDATE,
           previousValue: existingEntity,
           cascadingDeleteCause: null,
-        }
+        },
       );
     });
+
     it('executes validators', async () => {
       const viewerContext = mock<ViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
       const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
@@ -719,7 +766,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id2)
+          .withAuthorizationResults()
+          .loadByIDAsync(id2),
       );
 
       await entityMutatorFactory
@@ -733,12 +781,74 @@ describe(EntityMutatorFactory, () => {
         cascadingDeleteCause: null,
       });
     });
+
+    it('throws when id field is updated', async () => {
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = StubQueryContextProvider.getQueryContext();
+
+      const id1 = uuidv4();
+      const { entityMutatorFactory, entityLoaderFactory } = createEntityMutatorFactory([
+        {
+          customIdField: id1,
+          stringField: 'huh',
+          testIndexedField: '4',
+          intField: 3,
+          dateField: new Date(),
+          nullableField: null,
+        },
+      ]);
+
+      const existingEntity = await enforceAsyncResult(
+        entityLoaderFactory
+          .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+          .withAuthorizationResults()
+          .loadByIDAsync(id1),
+      );
+
+      await expect(
+        entityMutatorFactory
+          .forUpdate(existingEntity, queryContext)
+          .setField('customIdField', uuidv4())
+          .enforceUpdateAsync(),
+      ).rejects.toThrow('id field updates not supported: (entityClass = TestEntity)');
+
+      const reloadedEntity = await enforceAsyncResult(
+        entityLoaderFactory
+          .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+          .withAuthorizationResults()
+          .loadByIDAsync(id1),
+      );
+      expect(reloadedEntity.getAllFields()).toMatchObject(existingEntity.getAllFields());
+    });
   });
 
   describe('forDelete', () => {
     it('deletes entities', async () => {
       const viewerContext = mock<ViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
       const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
@@ -756,7 +866,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id1)
+          .withAuthorizationResults()
+          .loadByIDAsync(id1),
       );
       expect(existingEntity).toBeTruthy();
 
@@ -766,14 +877,26 @@ describe(EntityMutatorFactory, () => {
         enforceAsyncResult(
           entityLoaderFactory
             .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-            .loadByIDAsync(id1)
-        )
+            .withAuthorizationResults()
+            .loadByIDAsync(id1),
+        ),
       ).rejects.toBeInstanceOf(Error);
     });
 
     it('checks privacy', async () => {
       const viewerContext = mock<ViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
       const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
@@ -794,7 +917,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id1)
+          .withAuthorizationResults()
+          .loadByIDAsync(id1),
       );
 
       await entityMutatorFactory.forDelete(existingEntity, queryContext).enforceDeleteAsync();
@@ -805,14 +929,25 @@ describe(EntityMutatorFactory, () => {
           anyOfClass(EntityTransactionalQueryContext),
           anything(),
           anyOfClass(TestEntity),
-          anything()
-        )
+          anything(),
+        ),
       ).once();
     });
 
     it('executes triggers', async () => {
       const viewerContext = mock<ViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
       const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
@@ -833,7 +968,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id1)
+          .withAuthorizationResults()
+          .loadByIDAsync(id1),
       );
 
       await entityMutatorFactory.forDelete(existingEntity, queryContext).enforceDeleteAsync();
@@ -849,13 +985,24 @@ describe(EntityMutatorFactory, () => {
           beforeDelete: true,
           afterDelete: true,
         },
-        { type: EntityMutationType.DELETE, cascadingDeleteCause: null }
+        { type: EntityMutationType.DELETE, cascadingDeleteCause: null },
       );
     });
 
     it('does not execute validators', async () => {
       const viewerContext = mock<ViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
       const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
@@ -876,7 +1023,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id1)
+          .withAuthorizationResults()
+          .loadByIDAsync(id1),
       );
 
       await entityMutatorFactory.forDelete(existingEntity, queryContext).enforceDeleteAsync();
@@ -889,7 +1037,18 @@ describe(EntityMutatorFactory, () => {
 
   it('invalidates cache for fields upon create', async () => {
     const viewerContext = mock<ViewerContext>();
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            string,
+            ViewerContext,
+            TestEntity,
+            keyof TestFields
+          >
+        >(),
+      );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
     const id1 = uuidv4();
@@ -907,7 +1066,8 @@ describe(EntityMutatorFactory, () => {
     const entites1 = await enforceResultsAsync(
       entityLoaderFactory
         .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-        .loadManyByFieldEqualingAsync('stringField', 'huh')
+        .withAuthorizationResults()
+        .loadManyByFieldEqualingAsync('stringField', 'huh'),
     );
     expect(entites1).toHaveLength(1);
 
@@ -915,13 +1075,14 @@ describe(EntityMutatorFactory, () => {
       entityMutatorFactory
         .forCreate(viewerContext, queryContext)
         .setField('stringField', 'huh')
-        .createAsync()
+        .createAsync(),
     );
 
     const entities2 = await enforceResultsAsync(
       entityLoaderFactory
         .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-        .loadManyByFieldEqualingAsync('stringField', 'huh')
+        .withAuthorizationResults()
+        .loadManyByFieldEqualingAsync('stringField', 'huh'),
     );
     expect(entities2).toHaveLength(2);
   });
@@ -945,7 +1106,7 @@ describe(EntityMutatorFactory, () => {
       entityMutatorFactory
         .forCreate(viewerContext, queryContext)
         .setField('stringField', 10 as any)
-        .createAsync()
+        .createAsync(),
     ).rejects.toThrowError('Entity field not valid: TestEntity (stringField = 10)');
 
     const createdEntity = await entityMutatorFactory
@@ -957,7 +1118,7 @@ describe(EntityMutatorFactory, () => {
       entityMutatorFactory
         .forUpdate(createdEntity, queryContext)
         .setField('stringField', 10 as any)
-        .updateAsync()
+        .updateAsync(),
     ).rejects.toThrowError('Entity field not valid: TestEntity (stringField = 10)');
   });
 
@@ -992,7 +1153,19 @@ describe(EntityMutatorFactory, () => {
           keyof SimpleTestFields
         >
       >(EntityLoader);
-    when(entityLoaderMock.constructEntity(anything())).thenReturn(fakeEntity);
+    const entityLoaderUtilsMock =
+      mock<
+        EntityLoaderUtils<
+          SimpleTestFields,
+          string,
+          ViewerContext,
+          SimpleTestEntity,
+          SimpleTestEntityPrivacyPolicy,
+          keyof SimpleTestFields
+        >
+      >(EntityLoaderUtils);
+    when(entityLoaderUtilsMock.constructEntity(anything())).thenReturn(fakeEntity);
+    when(entityLoaderMock.utils()).thenReturn(instance(entityLoaderUtilsMock));
     const entityLoader = instance(entityLoaderMock);
 
     const entityLoaderFactoryMock =
@@ -1010,8 +1183,8 @@ describe(EntityMutatorFactory, () => {
       entityLoaderFactoryMock.forLoad(
         viewerContext,
         anyOfClass(EntityTransactionalQueryContext),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReturn(entityLoader);
     const entityLoaderFactory = instance(entityLoaderFactoryMock);
 
@@ -1023,8 +1196,8 @@ describe(EntityMutatorFactory, () => {
         anyOfClass(EntityTransactionalQueryContext),
         anything(),
         anyOfClass(SimpleTestEntity),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
     when(
       privacyPolicyMock.authorizeUpdateAsync(
@@ -1032,8 +1205,8 @@ describe(EntityMutatorFactory, () => {
         anyOfClass(EntityTransactionalQueryContext),
         anything(),
         anyOfClass(SimpleTestEntity),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
     when(
       privacyPolicyMock.authorizeDeleteAsync(
@@ -1041,8 +1214,8 @@ describe(EntityMutatorFactory, () => {
         anyOfClass(EntityTransactionalQueryContext),
         anything(),
         anyOfClass(SimpleTestEntity),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
 
     const entityMutatorFactory = new EntityMutatorFactory(
@@ -1054,7 +1227,7 @@ describe(EntityMutatorFactory, () => {
       {},
       entityLoaderFactory,
       databaseAdapter,
-      metricsAdapter
+      metricsAdapter,
     );
 
     const entityCreateResult = await entityMutatorFactory
@@ -1116,7 +1289,19 @@ describe(EntityMutatorFactory, () => {
           keyof SimpleTestFields
         >
       >(EntityLoader);
-    when(entityLoaderMock.constructEntity(anything())).thenReturn(fakeEntity);
+    const entityLoaderUtilsMock =
+      mock<
+        EntityLoaderUtils<
+          SimpleTestFields,
+          string,
+          ViewerContext,
+          SimpleTestEntity,
+          SimpleTestEntityPrivacyPolicy,
+          keyof SimpleTestFields
+        >
+      >(EntityLoaderUtils);
+    when(entityLoaderUtilsMock.constructEntity(anything())).thenReturn(fakeEntity);
+    when(entityLoaderMock.utils()).thenReturn(instance(entityLoaderUtilsMock));
     const entityLoader = instance(entityLoaderMock);
 
     const entityLoaderFactoryMock =
@@ -1134,30 +1319,30 @@ describe(EntityMutatorFactory, () => {
       entityLoaderFactoryMock.forLoad(
         viewerContext,
         anyOfClass(EntityTransactionalQueryContext),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReturn(entityLoader);
     const entityLoaderFactory = instance(entityLoaderFactoryMock);
 
     const rejectionError = new Error();
 
     when(
-      databaseAdapterMock.insertAsync(anyOfClass(EntityTransactionalQueryContext), anything())
+      databaseAdapterMock.insertAsync(anyOfClass(EntityTransactionalQueryContext), anything()),
     ).thenReject(rejectionError);
     when(
       databaseAdapterMock.updateAsync(
         anyOfClass(EntityTransactionalQueryContext),
         anything(),
         anything(),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
     when(
       databaseAdapterMock.deleteAsync(
         anyOfClass(EntityTransactionalQueryContext),
         anything(),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
 
     const entityMutatorFactory = new EntityMutatorFactory(
@@ -1169,17 +1354,17 @@ describe(EntityMutatorFactory, () => {
       {},
       entityLoaderFactory,
       instance(databaseAdapterMock),
-      metricsAdapter
+      metricsAdapter,
     );
 
     await expect(
-      entityMutatorFactory.forCreate(viewerContext, queryContext).createAsync()
+      entityMutatorFactory.forCreate(viewerContext, queryContext).createAsync(),
     ).rejects.toEqual(rejectionError);
     await expect(
-      entityMutatorFactory.forUpdate(fakeEntity, queryContext).updateAsync()
+      entityMutatorFactory.forUpdate(fakeEntity, queryContext).updateAsync(),
     ).rejects.toEqual(rejectionError);
     await expect(
-      entityMutatorFactory.forDelete(fakeEntity, queryContext).deleteAsync()
+      entityMutatorFactory.forDelete(fakeEntity, queryContext).deleteAsync(),
     ).rejects.toEqual(rejectionError);
   });
 
@@ -1193,14 +1378,14 @@ describe(EntityMutatorFactory, () => {
       entityMutatorFactory
         .forCreate(viewerContext, queryContext)
         .setField('stringField', 'huh')
-        .createAsync()
+        .createAsync(),
     );
 
     await enforceAsyncResult(
       entityMutatorFactory
         .forUpdate(newEntity, queryContext)
         .setField('stringField', 'wat')
-        .updateAsync()
+        .updateAsync(),
     );
 
     await enforceAsyncResult(entityMutatorFactory.forDelete(newEntity, queryContext).deleteAsync());
@@ -1210,24 +1395,24 @@ describe(EntityMutatorFactory, () => {
         objectContaining({
           type: EntityMetricsMutationType.CREATE,
           entityClassName: TestEntity.name,
-        })
-      )
+        }),
+      ),
     ).once();
     verify(
       spiedMetricsAdapter.logMutatorMutationEvent(
         objectContaining({
           type: EntityMetricsMutationType.UPDATE,
           entityClassName: TestEntity.name,
-        })
-      )
+        }),
+      ),
     ).once();
     verify(
       spiedMetricsAdapter.logMutatorMutationEvent(
         objectContaining({
           type: EntityMetricsMutationType.DELETE,
           entityClassName: TestEntity.name,
-        })
-      )
+        }),
+      ),
     ).once();
     verify(spiedMetricsAdapter.logMutatorMutationEvent(anything())).thrice();
   });