@expo/entity 0.34.0 → 0.36.0

package/src/__tests__/EntitySecondaryCacheLoader-test.ts

@@ -2,11 +2,11 @@ import { anyOfClass, anything, deepEqual, instance, mock, spy, verify, when } fr
 
 import { EntityNonTransactionalQueryContext } from '../EntityQueryContext';
 import EntitySecondaryCacheLoader, { ISecondaryEntityCache } from '../EntitySecondaryCacheLoader';
+import ViewerContext from '../ViewerContext';
 import SimpleTestEntity, {
   SimpleTestEntityPrivacyPolicy,
   SimpleTestFields,
 } from '../testfixtures/SimpleTestEntity';
-import TestViewerContext from '../testfixtures/TestViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 type TestLoadParams = { id: string };
@@ -15,12 +15,12 @@ class TestSecondaryRedisCacheLoader extends EntitySecondaryCacheLoader<
   TestLoadParams,
   SimpleTestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   SimpleTestEntity,
   SimpleTestEntityPrivacyPolicy
 > {
   protected async fetchObjectsFromDatabaseAsync(
-    _loadParamsArray: readonly Readonly<TestLoadParams>[]
+    _loadParamsArray: readonly Readonly<TestLoadParams>[],
   ): Promise<ReadonlyMap<Readonly<TestLoadParams>, Readonly<SimpleTestFields>>> {
     // unused
     return new Map();
@@ -30,50 +30,44 @@ class TestSecondaryRedisCacheLoader extends EntitySecondaryCacheLoader<
 describe(EntitySecondaryCacheLoader, () => {
   describe('loadManyAsync', () => {
     it('calls into secondary cache with correct params', async () => {
-      const vc1 = new TestViewerContext(createUnitTestEntityCompanionProvider());
+      const vc1 = new ViewerContext(createUnitTestEntityCompanionProvider());
 
-      const createdEntity = await SimpleTestEntity.creator(
-        vc1,
-        vc1.getQueryContext()
-      ).enforceCreateAsync();
+      const createdEntity = await SimpleTestEntity.creator(vc1).enforceCreateAsync();
       const loadParams = { id: createdEntity.getID() };
 
       const secondaryEntityCacheMock =
         mock<ISecondaryEntityCache<SimpleTestFields, TestLoadParams>>();
       when(
-        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything())
+        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything()),
       ).thenResolve(new Map());
       const secondaryEntityCache = instance(secondaryEntityCacheMock);
 
       const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(
         secondaryEntityCache,
-        SimpleTestEntity.loader(vc1, vc1.getQueryContext())
+        SimpleTestEntity.loader(vc1),
       );
 
       await secondaryCacheLoader.loadManyAsync([loadParams]);
 
       verify(
-        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything())
+        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything()),
       ).once();
     });
 
     it('constructs and authorizes entities', async () => {
-      const vc1 = new TestViewerContext(createUnitTestEntityCompanionProvider());
+      const vc1 = new ViewerContext(createUnitTestEntityCompanionProvider());
 
-      const createdEntity = await SimpleTestEntity.creator(
-        vc1,
-        vc1.getQueryContext()
-      ).enforceCreateAsync();
+      const createdEntity = await SimpleTestEntity.creator(vc1).enforceCreateAsync();
       const loadParams = { id: createdEntity.getID() };
 
       const secondaryEntityCacheMock =
         mock<ISecondaryEntityCache<SimpleTestFields, TestLoadParams>>();
       when(
-        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything())
+        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything()),
       ).thenResolve(new Map([[loadParams, createdEntity.getAllFields()]]));
       const secondaryEntityCache = instance(secondaryEntityCacheMock);
 
-      const loader = SimpleTestEntity.loader(vc1, vc1.getQueryContext());
+      const loader = SimpleTestEntity.loader(vc1);
       const spiedPrivacyPolicy = spy(loader['privacyPolicy']);
       const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(secondaryEntityCache, loader);
 
@@ -86,26 +80,23 @@ describe(EntitySecondaryCacheLoader, () => {
           anyOfClass(EntityNonTransactionalQueryContext),
           anything(),
           anything(),
-          anything()
-        )
+          anything(),
+        ),
       ).once();
     });
   });
 
   describe('invalidateManyAsync', () => {
     it('calls invalidate on the secondary cache', async () => {
-      const vc1 = new TestViewerContext(createUnitTestEntityCompanionProvider());
+      const vc1 = new ViewerContext(createUnitTestEntityCompanionProvider());
 
-      const createdEntity = await SimpleTestEntity.creator(
-        vc1,
-        vc1.getQueryContext()
-      ).enforceCreateAsync();
+      const createdEntity = await SimpleTestEntity.creator(vc1).enforceCreateAsync();
       const loadParams = { id: createdEntity.getID() };
 
       const secondaryEntityCacheMock =
         mock<ISecondaryEntityCache<SimpleTestFields, TestLoadParams>>();
       const secondaryEntityCache = instance(secondaryEntityCacheMock);
-      const loader = SimpleTestEntity.loader(vc1, vc1.getQueryContext());
+      const loader = SimpleTestEntity.loader(vc1);
       const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(secondaryEntityCache, loader);
       await secondaryCacheLoader.invalidateManyAsync([loadParams]);
 

package/src/__tests__/EntitySelfReferentialEdges-test.ts

@@ -87,52 +87,42 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    ).enforceCreateAsync();
-    const subCategory = await CategoryEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const subCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', parentCategory.getID())
       .enforceCreateAsync();
-    const subSubCategory = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    )
+    const subSubCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', subCategory.getID())
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID())
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
-        .enforcing()
-        .loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID())
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory, viewerContext.getQueryContext());
+    await CategoryEntity.enforceDeleteAsync(parentCategory);
 
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID())
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
-        .enforcing()
-        .loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID())
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.toBeNull();
   });
 
@@ -142,28 +132,21 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    ).enforceCreateAsync();
-    const categoryB = await CategoryEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryB = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', categoryA.getID())
       .enforceCreateAsync();
-    await CategoryEntity.updater(categoryA, viewerContext.getQueryContext())
+    await CategoryEntity.updater(categoryA)
       .setField('parent_category_id', categoryB.getID())
       .enforceUpdateAsync();
 
-    await CategoryEntity.enforceDeleteAsync(categoryA, viewerContext.getQueryContext());
+    await CategoryEntity.enforceDeleteAsync(categoryA);
 
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
-        .enforcing()
-        .loadByIDNullableAsync(categoryA.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
-        .enforcing()
-        .loadByIDNullableAsync(categoryB.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryB.getID()),
     ).resolves.toBeNull();
   });
 });
@@ -175,56 +158,42 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    ).enforceCreateAsync();
-    const subCategory = await CategoryEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const subCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', parentCategory.getID())
       .enforceCreateAsync();
-    const subSubCategory = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    )
+    const subSubCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', subCategory.getID())
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID())
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
-        .enforcing()
-        .loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID())
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory, viewerContext.getQueryContext());
+    await CategoryEntity.enforceDeleteAsync(parentCategory);
 
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID())
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
 
-    const loadedSubCategory = await CategoryEntity.loader(
-      viewerContext,
-      viewerContext.getQueryContext()
-    )
+    const loadedSubCategory = await CategoryEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(subCategory.getID());
     expect(loadedSubCategory.getField('parent_category_id')).toBeNull();
 
-    const loadedSubSubCategory = await CategoryEntity.loader(
-      viewerContext,
-      viewerContext.getQueryContext()
-    )
+    const loadedSubSubCategory = await CategoryEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(subSubCategory.getID());
     expect(loadedSubSubCategory.getField('parent_category_id')).not.toBeNull();
@@ -236,23 +205,17 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    ).enforceCreateAsync();
-    const categoryB = await CategoryEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryB = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', categoryA.getID())
       .enforceCreateAsync();
-    await CategoryEntity.updater(categoryA, viewerContext.getQueryContext())
+    await CategoryEntity.updater(categoryA)
       .setField('parent_category_id', categoryB.getID())
       .enforceUpdateAsync();
 
-    await CategoryEntity.enforceDeleteAsync(categoryA, viewerContext.getQueryContext());
+    await CategoryEntity.enforceDeleteAsync(categoryA);
 
-    const loadedCategoryB = await CategoryEntity.loader(
-      viewerContext,
-      viewerContext.getQueryContext()
-    )
+    const loadedCategoryB = await CategoryEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(categoryB.getID());
     expect(loadedCategoryB.getField('parent_category_id')).toBeNull();
@@ -262,44 +225,38 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
 describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
   it('invalidates the cache', async () => {
     const { CategoryEntity } = makeEntityClass(
-      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY
+      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY,
     );
 
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    ).enforceCreateAsync();
-    const subCategory = await CategoryEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const subCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', parentCategory.getID())
       .enforceCreateAsync();
-    const subSubCategory = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    )
+    const subSubCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', subCategory.getID())
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID())
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', parentCategory.getID())
+        .loadByFieldEqualingAsync('parent_category_id', parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', subCategory.getID())
+        .loadByFieldEqualingAsync('parent_category_id', subCategory.getID()),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
-      CategoryEntity
+      CategoryEntity,
     )['entityCompanion']['tableDataCoordinator'][
       'cacheAdapter'
     ] as InMemoryFullCacheStubCacheAdapter<CategoryFields>;
@@ -310,11 +267,11 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
 
     const subSubCategoryCachedBefore = await categoryCacheAdapter.loadManyAsync(
       'parent_category_id',
-      [subCategory.getID()]
+      [subCategory.getID()],
     );
     expect(subSubCategoryCachedBefore.get(subCategory.getID())?.status).toEqual(CacheStatus.HIT);
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory, viewerContext.getQueryContext());
+    await CategoryEntity.enforceDeleteAsync(parentCategory);
 
     const subCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
       parentCategory.getID(),
@@ -323,59 +280,54 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
 
     const subSubCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync(
       'parent_category_id',
-      [subCategory.getID()]
+      [subCategory.getID()],
     );
     expect(subSubCategoryCachedAfter.get(subCategory.getID())?.status).toEqual(CacheStatus.MISS);
 
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID())
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
-        .enforcing()
-        .loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID())
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
   });
 
   it('handles cycles', async () => {
     const { CategoryEntity } = makeEntityClass(
-      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY
+      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY,
     );
 
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(
-      viewerContext,
-      viewerContext.getQueryContext()
-    ).enforceCreateAsync();
-    const categoryB = await CategoryEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryB = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', categoryA.getID())
       .enforceCreateAsync();
-    await CategoryEntity.updater(categoryA, viewerContext.getQueryContext())
+    await CategoryEntity.updater(categoryA)
       .setField('parent_category_id', categoryB.getID())
       .enforceUpdateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryA.getID())
+        .loadByFieldEqualingAsync('parent_category_id', categoryA.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext, viewerContext.getQueryContext())
+      CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryB.getID())
+        .loadByFieldEqualingAsync('parent_category_id', categoryB.getID()),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
-      CategoryEntity
+      CategoryEntity,
     )['entityCompanion']['tableDataCoordinator'][
       'cacheAdapter'
     ] as InMemoryFullCacheStubCacheAdapter<CategoryFields>;
@@ -386,7 +338,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     expect(categoriesCachedBefore.get(categoryA.getID())?.status).toEqual(CacheStatus.HIT);
     expect(categoriesCachedBefore.get(categoryB.getID())?.status).toEqual(CacheStatus.HIT);
 
-    await CategoryEntity.enforceDeleteAsync(categoryA, viewerContext.getQueryContext());
+    await CategoryEntity.enforceDeleteAsync(categoryA);
 
     const categoriesCachedAfter = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
       categoryA.getID(),

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -20,7 +20,7 @@ describe(GenericEntityCacheAdapter, () => {
           ['id.wat', { status: CacheStatus.HIT, item: { id: 'wat' } }],
           ['id.who', { status: CacheStatus.NEGATIVE }],
           ['id.why', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
@@ -55,7 +55,7 @@ describe(GenericEntityCacheAdapter, () => {
       await cacheAdapter.cacheManyAsync('id', new Map([['wat', { id: 'wat' }]]));
 
       verify(
-        mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]])))
+        mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]]))),
       ).once();
     });
   });

package/src/__tests__/ReadonlyEntity-test.ts

@@ -3,15 +3,15 @@ import { instance, mock } from 'ts-mockito';
 import EntityAssociationLoader from '../EntityAssociationLoader';
 import EntityLoader from '../EntityLoader';
 import ReadonlyEntity from '../ReadonlyEntity';
+import ViewerContext from '../ViewerContext';
 import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
 import TestEntity from '../testfixtures/TestEntity';
-import TestViewerContext from '../testfixtures/TestViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe(ReadonlyEntity, () => {
   describe('getID', () => {
     it('returns correct value', () => {
-      const viewerContext = instance(mock(TestViewerContext));
+      const viewerContext = instance(mock(ViewerContext));
       const data = {
         id: 'what',
       };
@@ -27,7 +27,7 @@ describe(ReadonlyEntity, () => {
 
   describe('toString', () => {
     it('returns correct value', () => {
-      const viewerContext = instance(mock(TestViewerContext));
+      const viewerContext = instance(mock(ViewerContext));
       const data = {
         id: 'what',
       };
@@ -43,7 +43,7 @@ describe(ReadonlyEntity, () => {
 
   describe('getUniqueIdentifier', () => {
     it('returns a different value for two different entities of the same type', () => {
-      const viewerContext = instance(mock(TestViewerContext));
+      const viewerContext = instance(mock(ViewerContext));
       const testEntity = new SimpleTestEntity({
         viewerContext,
         id: '1',
@@ -68,8 +68,8 @@ describe(ReadonlyEntity, () => {
     });
 
     it('returns the same value even if different viewer context', () => {
-      const viewerContext = instance(mock(TestViewerContext));
-      const viewerContext2 = instance(mock(TestViewerContext));
+      const viewerContext = instance(mock(ViewerContext));
+      const viewerContext2 = instance(mock(ViewerContext));
       const data = { id: '1' };
       const testEntity = new SimpleTestEntity({
         viewerContext,
@@ -87,7 +87,7 @@ describe(ReadonlyEntity, () => {
     });
 
     it('returns a different value for different entities even if same ID', () => {
-      const viewerContext = instance(mock(TestViewerContext));
+      const viewerContext = instance(mock(ViewerContext));
       const data = { id: '1' };
       const testEntity = new SimpleTestEntity({
         viewerContext,
@@ -114,7 +114,7 @@ describe(ReadonlyEntity, () => {
   });
 
   it('cannot be created without an ID', () => {
-    const viewerContext = instance(mock(TestViewerContext));
+    const viewerContext = instance(mock(ViewerContext));
     const dataWithoutID = {};
     expect(() => {
       // eslint-disable-next-line no-new
@@ -128,7 +128,7 @@ describe(ReadonlyEntity, () => {
   });
 
   it('returns correct viewerCo}ntext from instantiation', () => {
-    const viewerContext = instance(mock(TestViewerContext));
+    const viewerContext = instance(mock(ViewerContext));
     const data = {
       id: 'what',
     };
@@ -142,7 +142,7 @@ describe(ReadonlyEntity, () => {
   });
 
   it('returns correct data for field getters', () => {
-    const viewerContext = instance(mock(TestViewerContext));
+    const viewerContext = instance(mock(ViewerContext));
     const data = {
       id: 'what',
     };
@@ -159,7 +159,7 @@ describe(ReadonlyEntity, () => {
   describe('associationLoader', () => {
     it('returns a new association loader', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
+      const viewerContext = new ViewerContext(companionProvider);
       const data = {
         id: 'what',
       };
@@ -176,10 +176,8 @@ describe(ReadonlyEntity, () => {
   describe('loader', () => {
     it('creates a new EntityLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      expect(
-        SimpleTestEntity.loader(viewerContext, viewerContext.getQueryContext())
-      ).toBeInstanceOf(EntityLoader);
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(SimpleTestEntity.loader(viewerContext)).toBeInstanceOf(EntityLoader);
     });
   });
 });

package/src/__tests__/ViewerContext-test.ts

@@ -3,12 +3,11 @@ import ViewerContext from '../ViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe(ViewerContext, () => {
-  describe('getNonTransactionalQueryContextForDatabaseAdaptorFlavor', () => {
+  describe('getQueryContextForDatabaseAdaptorFlavor', () => {
     it('creates a new regular query context', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      const queryContext =
-        viewerContext.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres');
+      const queryContext = viewerContext.getQueryContextForDatabaseAdaptorFlavor('postgres');
       expect(queryContext).toBeInstanceOf(EntityQueryContext);
       expect(queryContext.isInTransaction()).toBe(false);
     });
@@ -23,7 +22,7 @@ describe(ViewerContext, () => {
           'postgres',
           async (queryContext) => {
             return queryContext.isInTransaction();
-          }
+          },
         );
       expect(didCreateTransaction).toBe(true);
     });

package/src/__tests__/ViewerScopedEntityCompanion-test.ts

@@ -23,10 +23,10 @@ describe(ViewerScopedEntityCompanion, () => {
       >();
     const viewerScopedEntityCompanion = new ViewerScopedEntityCompanion(entityCompanion, vc);
     expect(viewerScopedEntityCompanion.getLoaderFactory()).toBeInstanceOf(
-      ViewerScopedEntityLoaderFactory
+      ViewerScopedEntityLoaderFactory,
     );
     expect(viewerScopedEntityCompanion.getMutatorFactory()).toBeInstanceOf(
-      ViewerScopedEntityMutatorFactory
+      ViewerScopedEntityMutatorFactory,
     );
   });
 });

package/src/__tests__/ViewerScopedEntityCompanionProvider-test.ts

@@ -12,10 +12,10 @@ describe(ViewerScopedEntityCompanionProvider, () => {
     const entityCompanionProvider = instance(mock(EntityCompanionProvider));
     const viewerScopedEntityCompanionProvider = new ViewerScopedEntityCompanionProvider(
       entityCompanionProvider,
-      vc
+      vc,
     );
     expect(
-      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(TestEntity)
+      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(TestEntity),
     ).toBeInstanceOf(ViewerScopedEntityCompanion);
   });
 });

package/src/__tests__/ViewerScopedEntityLoaderFactory-test.ts

@@ -9,7 +9,8 @@ import ViewerScopedEntityLoaderFactory from '../ViewerScopedEntityLoaderFactory'
 describe(ViewerScopedEntityLoaderFactory, () => {
   it('correctly scopes viewer to entity loads', async () => {
     const viewerContext = instance(mock(ViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const privacyPolicyEvaluationContext =
+      instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>());
     const queryContext = instance(mock(EntityQueryContext));
     const baseLoader = mock<EntityLoaderFactory<any, any, any, any, any, any>>(EntityLoaderFactory);
     const baseLoaderInstance = instance(baseLoader);