@expo/entity 0.34.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,
@@ -31,6 +32,7 @@ import EntityMutatorFactory from '../EntityMutatorFactory';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityTransactionalQueryContext, EntityQueryContext } from '../EntityQueryContext';
 import IEntityDatabaseAdapterProvider from '../IEntityDatabaseAdapterProvider';
+import ViewerContext from '../ViewerContext';
 import { enforceResultsAsync } from '../entityUtils';
 import EntityDataManager from '../internal/EntityDataManager';
 import ReadThroughEntityCache from '../internal/ReadThroughEntityCache';
@@ -46,7 +48,6 @@ import TestEntity, {
   TestEntityPrivacyPolicy,
   testEntityConfiguration,
 } from '../testfixtures/TestEntity';
-import TestViewerContext from '../testfixtures/TestViewerContext';
 import { NoCacheStubCacheAdapterProvider } from '../utils/testing/StubCacheAdapter';
 import StubDatabaseAdapter from '../utils/testing/StubDatabaseAdapter';
 import StubQueryContextProvider from '../utils/testing/StubQueryContextProvider';
@@ -54,58 +55,52 @@ import StubQueryContextProvider from '../utils/testing/StubQueryContextProvider'
 class TestMutationTrigger extends EntityMutationTrigger<
   TestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   TestEntity,
   keyof TestFields
 > {
   async executeAsync(
-    _viewerContext: TestViewerContext,
+    _viewerContext: ViewerContext,
     _queryContext: EntityQueryContext,
     _entity: TestEntity,
     _mutationInfo: EntityTriggerMutationInfo<
       TestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       TestEntity,
       keyof TestFields
-    >
+    >,
   ): Promise<void> {}
 }
 
 class TestNonTransactionalMutationTrigger extends EntityNonTransactionalMutationTrigger<
   TestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   TestEntity,
   keyof TestFields
 > {
-  async executeAsync(_viewerContext: TestViewerContext, _entity: TestEntity): Promise<void> {}
+  async executeAsync(_viewerContext: ViewerContext, _entity: TestEntity): Promise<void> {}
 }
 
 const setUpMutationValidatorSpies = (
   mutationValidators: EntityMutationValidator<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
-  >[]
-): EntityMutationValidator<
-  TestFields,
-  string,
-  TestViewerContext,
-  TestEntity,
-  keyof TestFields
->[] => {
+  >[],
+): EntityMutationValidator<TestFields, string, ViewerContext, TestEntity, keyof TestFields>[] => {
   return mutationValidators.map((validator) => spy(validator));
 };
 
 const verifyValidatorCounts = (
-  viewerContext: TestViewerContext,
+  viewerContext: ViewerContext,
   mutationValidatorSpies: EntityMutationValidator<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
   >[],
@@ -113,10 +108,10 @@ const verifyValidatorCounts = (
   mutationInfo: EntityValidatorMutationInfo<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
-  >
+  >,
 ): void => {
   for (const validator of mutationValidatorSpies) {
     verify(
@@ -124,8 +119,8 @@ const verifyValidatorCounts = (
         viewerContext,
         anyOfClass(EntityTransactionalQueryContext),
         anyOfClass(TestEntity),
-        deepEqual(mutationInfo)
-      )
+        deepEqual(mutationInfo),
+      ),
     ).times(expectedCalls);
   }
 };
@@ -134,14 +129,14 @@ const setUpMutationTriggerSpies = (
   mutationTriggers: EntityMutationTriggerConfiguration<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
-  >
+  >,
 ): EntityMutationTriggerConfiguration<
   TestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   TestEntity,
   keyof TestFields
 > => {
@@ -159,11 +154,11 @@ const setUpMutationTriggerSpies = (
 };
 
 const verifyTriggerCounts = (
-  viewerContext: TestViewerContext,
+  viewerContext: ViewerContext,
   mutationTriggerSpies: EntityMutationTriggerConfiguration<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
   >,
@@ -172,7 +167,7 @@ const verifyTriggerCounts = (
       EntityMutationTriggerConfiguration<
         TestFields,
         string,
-        TestViewerContext,
+        ViewerContext,
         TestEntity,
         keyof TestFields
       >,
@@ -188,10 +183,10 @@ const verifyTriggerCounts = (
   mutationInfo: EntityTriggerMutationInfo<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
-  >
+  >,
 ): void => {
   Object.keys(executed).forEach((s) => {
     if ((executed as any)[s]) {
@@ -200,8 +195,8 @@ const verifyTriggerCounts = (
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
           anyOfClass(TestEntity),
-          deepEqual(mutationInfo)
-        )
+          deepEqual(mutationInfo),
+        ),
       ).once();
     } else {
       verify(
@@ -209,8 +204,8 @@ const verifyTriggerCounts = (
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
           anyOfClass(TestEntity),
-          deepEqual(mutationInfo)
-        )
+          deepEqual(mutationInfo),
+        ),
       ).never();
     }
   });
@@ -220,8 +215,8 @@ const verifyTriggerCounts = (
       viewerContext,
       anyOfClass(EntityTransactionalQueryContext),
       anyOfClass(TestEntity),
-      deepEqual(mutationInfo)
-    )
+      deepEqual(mutationInfo),
+    ),
   ).once();
 
   verify(
@@ -229,27 +224,27 @@ 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<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     TestEntityPrivacyPolicy,
     keyof TestFields
@@ -257,7 +252,7 @@ const createEntityMutatorFactory = (
   entityMutatorFactory: EntityMutatorFactory<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     TestEntityPrivacyPolicy
   >;
@@ -265,14 +260,14 @@ const createEntityMutatorFactory = (
   mutationValidators: EntityMutationValidator<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
   >[];
   mutationTriggers: EntityMutationTriggerConfiguration<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
   >;
@@ -280,14 +275,14 @@ const createEntityMutatorFactory = (
   const mutationValidators: EntityMutationValidator<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
   >[] = [new TestMutationTrigger()];
   const mutationTriggers: EntityMutationTriggerConfiguration<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     keyof TestFields
   > = {
@@ -301,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>;
     },
@@ -339,7 +333,7 @@ const createEntityMutatorFactory = (
           cacheAdapterProvider,
         },
       ],
-    ])
+    ]),
   );
 
   const dataManager = new EntityDataManager(
@@ -347,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,
@@ -378,8 +372,8 @@ const createEntityMutatorFactory = (
 describe(EntityMutatorFactory, () => {
   describe('forCreate', () => {
     it('creates entities', async () => {
-      const viewerContext = mock<TestViewerContext>();
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const id2 = uuidv4();
@@ -409,8 +403,8 @@ describe(EntityMutatorFactory, () => {
     });
 
     it('checks privacy', async () => {
-      const viewerContext = mock<TestViewerContext>();
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const id2 = uuidv4();
@@ -444,16 +438,16 @@ describe(EntityMutatorFactory, () => {
         spiedPrivacyPolicy.authorizeCreateAsync(
           viewerContext,
           anyOfClass(EntityTransactionalQueryContext),
-          deepEqual({ cascadingDeleteCause: null }),
+          deepEqual({ previousValue: null, cascadingDeleteCause: null }),
           anyOfClass(TestEntity),
-          anything()
-        )
+          anything(),
+        ),
       ).once();
     });
 
     it('executes triggers', async () => {
-      const viewerContext = mock<TestViewerContext>();
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const id2 = uuidv4();
@@ -494,13 +488,13 @@ describe(EntityMutatorFactory, () => {
           beforeDelete: false,
           afterDelete: false,
         },
-        { type: EntityMutationType.CREATE }
+        { type: EntityMutationType.CREATE },
       );
     });
 
     it('executes validators', async () => {
-      const viewerContext = mock<TestViewerContext>();
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const id2 = uuidv4();
@@ -536,9 +530,20 @@ describe(EntityMutatorFactory, () => {
 
   describe('forUpdate', () => {
     it('updates entities', async () => {
-      const viewerContext = mock<TestViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const id2 = uuidv4();
@@ -564,7 +569,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id2)
+          .withAuthorizationResults()
+          .loadByIDAsync(id2),
       );
 
       const updatedEntity = await entityMutatorFactory
@@ -579,15 +585,15 @@ 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<TestViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const id2 = uuidv4();
@@ -615,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
@@ -628,17 +635,38 @@ 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<TestViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const id2 = uuidv4();
@@ -667,7 +695,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id2)
+          .withAuthorizationResults()
+          .loadByIDAsync(id2),
       );
 
       await entityMutatorFactory
@@ -690,13 +719,25 @@ describe(EntityMutatorFactory, () => {
           type: EntityMutationType.UPDATE,
           previousValue: existingEntity,
           cascadingDeleteCause: null,
-        }
+        },
       );
     });
+
     it('executes validators', async () => {
-      const viewerContext = mock<TestViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const id2 = uuidv4();
@@ -725,7 +766,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id2)
+          .withAuthorizationResults()
+          .loadByIDAsync(id2),
       );
 
       await entityMutatorFactory
@@ -739,13 +781,75 @@ 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<TestViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      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([
@@ -762,7 +866,8 @@ describe(EntityMutatorFactory, () => {
       const existingEntity = await enforceAsyncResult(
         entityLoaderFactory
           .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-          .loadByIDAsync(id1)
+          .withAuthorizationResults()
+          .loadByIDAsync(id1),
       );
       expect(existingEntity).toBeTruthy();
 
@@ -772,15 +877,27 @@ describe(EntityMutatorFactory, () => {
         enforceAsyncResult(
           entityLoaderFactory
             .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
-            .loadByIDAsync(id1)
-        )
+            .withAuthorizationResults()
+            .loadByIDAsync(id1),
+        ),
       ).rejects.toBeInstanceOf(Error);
     });
 
     it('checks privacy', async () => {
-      const viewerContext = mock<TestViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const { privacyPolicy, entityMutatorFactory, entityLoaderFactory } =
@@ -800,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();
@@ -811,15 +929,26 @@ describe(EntityMutatorFactory, () => {
           anyOfClass(EntityTransactionalQueryContext),
           anything(),
           anyOfClass(TestEntity),
-          anything()
-        )
+          anything(),
+        ),
       ).once();
     });
 
     it('executes triggers', async () => {
-      const viewerContext = mock<TestViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const { mutationTriggers, entityMutatorFactory, entityLoaderFactory } =
@@ -839,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();
@@ -855,14 +985,25 @@ 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<TestViewerContext>();
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-      const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              string,
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = StubQueryContextProvider.getQueryContext();
 
       const id1 = uuidv4();
       const { mutationValidators, entityMutatorFactory, entityLoaderFactory } =
@@ -882,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();
@@ -894,9 +1036,20 @@ describe(EntityMutatorFactory, () => {
   });
 
   it('invalidates cache for fields upon create', async () => {
-    const viewerContext = mock<TestViewerContext>();
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    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([
@@ -913,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);
 
@@ -921,20 +1075,21 @@ 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);
   });
 
   it('throws error when field not valid', async () => {
-    const viewerContext = mock<TestViewerContext>();
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const viewerContext = mock<ViewerContext>();
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const id1 = uuidv4();
     const { entityMutatorFactory } = createEntityMutatorFactory([
       {
@@ -951,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
@@ -963,14 +1118,14 @@ describe(EntityMutatorFactory, () => {
       entityMutatorFactory
         .forUpdate(createdEntity, queryContext)
         .setField('stringField', 10 as any)
-        .updateAsync()
+        .updateAsync(),
     ).rejects.toThrowError('Entity field not valid: TestEntity (stringField = 10)');
   });
 
   it('returns error result when not authorized to create', async () => {
     const entityCompanionProvider = instance(mock(EntityCompanionProvider));
-    const viewerContext = instance(mock(TestViewerContext));
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const viewerContext = instance(mock(ViewerContext));
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicyMock = mock(SimpleTestEntityPrivacyPolicy);
     const databaseAdapter = instance(mock<EntityDatabaseAdapter<SimpleTestFields>>());
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
@@ -992,13 +1147,25 @@ describe(EntityMutatorFactory, () => {
         EntityLoader<
           SimpleTestFields,
           string,
-          TestViewerContext,
+          ViewerContext,
           SimpleTestEntity,
           SimpleTestEntityPrivacyPolicy,
           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 =
@@ -1006,7 +1173,7 @@ describe(EntityMutatorFactory, () => {
         EntityLoaderFactory<
           SimpleTestFields,
           string,
-          TestViewerContext,
+          ViewerContext,
           SimpleTestEntity,
           SimpleTestEntityPrivacyPolicy,
           keyof SimpleTestFields
@@ -1016,8 +1183,8 @@ describe(EntityMutatorFactory, () => {
       entityLoaderFactoryMock.forLoad(
         viewerContext,
         anyOfClass(EntityTransactionalQueryContext),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReturn(entityLoader);
     const entityLoaderFactory = instance(entityLoaderFactoryMock);
 
@@ -1029,8 +1196,8 @@ describe(EntityMutatorFactory, () => {
         anyOfClass(EntityTransactionalQueryContext),
         anything(),
         anyOfClass(SimpleTestEntity),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
     when(
       privacyPolicyMock.authorizeUpdateAsync(
@@ -1038,8 +1205,8 @@ describe(EntityMutatorFactory, () => {
         anyOfClass(EntityTransactionalQueryContext),
         anything(),
         anyOfClass(SimpleTestEntity),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
     when(
       privacyPolicyMock.authorizeDeleteAsync(
@@ -1047,8 +1214,8 @@ describe(EntityMutatorFactory, () => {
         anyOfClass(EntityTransactionalQueryContext),
         anything(),
         anyOfClass(SimpleTestEntity),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
 
     const entityMutatorFactory = new EntityMutatorFactory(
@@ -1060,7 +1227,7 @@ describe(EntityMutatorFactory, () => {
       {},
       entityLoaderFactory,
       databaseAdapter,
-      metricsAdapter
+      metricsAdapter,
     );
 
     const entityCreateResult = await entityMutatorFactory
@@ -1093,8 +1260,8 @@ describe(EntityMutatorFactory, () => {
 
     const entityCompanionProvider = instance(entityCompanionProviderMock);
 
-    const viewerContext = instance(mock(TestViewerContext));
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const viewerContext = instance(mock(ViewerContext));
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(SimpleTestEntityPrivacyPolicy));
     const databaseAdapterMock = mock<EntityDatabaseAdapter<SimpleTestFields>>();
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
@@ -1116,13 +1283,25 @@ describe(EntityMutatorFactory, () => {
         EntityLoader<
           SimpleTestFields,
           string,
-          TestViewerContext,
+          ViewerContext,
           SimpleTestEntity,
           SimpleTestEntityPrivacyPolicy,
           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 =
@@ -1130,7 +1309,7 @@ describe(EntityMutatorFactory, () => {
         EntityLoaderFactory<
           SimpleTestFields,
           string,
-          TestViewerContext,
+          ViewerContext,
           SimpleTestEntity,
           SimpleTestEntityPrivacyPolicy,
           keyof SimpleTestFields
@@ -1140,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(
@@ -1175,23 +1354,23 @@ 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);
   });
 
   it('records metrics appropriately', async () => {
-    const viewerContext = mock<TestViewerContext>();
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const viewerContext = mock<ViewerContext>();
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const { entityMutatorFactory, metricsAdapter } = createEntityMutatorFactory([]);
     const spiedMetricsAdapter = spy(metricsAdapter);
 
@@ -1199,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());
@@ -1216,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();
   });