@expo/entity 0.40.0 → 0.42.0

package/src/__tests__/EntitySelfReferentialEdges-test.ts

@@ -5,10 +5,11 @@ import { EntityEdgeDeletionBehavior } from '../EntityFieldDefinition';
 import { UUIDField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import { CacheStatus } from '../internal/ReadThroughEntityCache';
+import { SingleFieldHolder, SingleFieldValueHolder } from '../internal/SingleFieldHolder';
 import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
-import TestViewerContext from '../testfixtures/TestViewerContext';
-import { InMemoryFullCacheStubCacheAdapter } from '../utils/testing/StubCacheAdapter';
-import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+import { InMemoryFullCacheStubCacheAdapter } from '../utils/__testfixtures__/StubCacheAdapter';
+import TestViewerContext from '../utils/__testfixtures__/TestViewerContext';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 interface CategoryFields {
   id: string;
@@ -17,31 +18,31 @@ interface CategoryFields {
 
 class CategoryPrivacyPolicy extends EntityPrivacyPolicy<
   CategoryFields,
-  string,
+  'id',
   TestViewerContext,
   any,
   any
 > {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<CategoryFields, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<CategoryFields, 'id', TestViewerContext, any, any>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<CategoryFields, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<CategoryFields, 'id', TestViewerContext, any, any>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<CategoryFields, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<CategoryFields, 'id', TestViewerContext, any, any>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<CategoryFields, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<CategoryFields, 'id', TestViewerContext, any, any>(),
   ];
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 const makeEntityClass = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) => {
-  class CategoryEntity extends Entity<CategoryFields, string, TestViewerContext> {
+  class CategoryEntity extends Entity<CategoryFields, 'id', TestViewerContext> {
     static defineCompanionDefinition(): EntityCompanionDefinition<
       CategoryFields,
-      string,
+      'id',
       TestViewerContext,
       CategoryEntity,
       CategoryPrivacyPolicy
@@ -54,7 +55,7 @@ const makeEntityClass = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) => {
     }
   }
 
-  const categoryEntityConfiguration = new EntityConfiguration<CategoryFields>({
+  const categoryEntityConfiguration = new EntityConfiguration<CategoryFields, 'id'>({
     idField: 'id',
     tableName: 'categories',
     inboundEdges: [CategoryEntity],
@@ -87,44 +88,34 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', parentCategory.getID())
       .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', subCategory.getID())
       .createAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
-    await CategoryEntity.deleter(parentCategory).enforcing().deleteAsync();
+    await CategoryEntity.deleter(parentCategory).deleteAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.toBeNull();
   });
 
@@ -134,23 +125,21 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', categoryA.getID())
       .createAsync();
     await CategoryEntity.updater(categoryA)
-      .enforcing()
       .setField('parent_category_id', categoryB.getID())
       .updateAsync();
 
-    await CategoryEntity.deleter(categoryA).enforcing().deleteAsync();
+    await CategoryEntity.deleter(categoryA).deleteAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(categoryA.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryB.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(categoryB.getID()),
     ).resolves.toBeNull();
   });
 });
@@ -162,46 +151,38 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', parentCategory.getID())
       .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', subCategory.getID())
       .createAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
-    await CategoryEntity.deleter(parentCategory).enforcing().deleteAsync();
+    await CategoryEntity.deleter(parentCategory).deleteAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
 
-    const loadedSubCategory = await CategoryEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(subCategory.getID());
+    const loadedSubCategory = await CategoryEntity.loader(viewerContext).loadByIDAsync(
+      subCategory.getID(),
+    );
     expect(loadedSubCategory.getField('parent_category_id')).toBeNull();
 
-    const loadedSubSubCategory = await CategoryEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(subSubCategory.getID());
+    const loadedSubSubCategory = await CategoryEntity.loader(viewerContext).loadByIDAsync(
+      subSubCategory.getID(),
+    );
     expect(loadedSubSubCategory.getField('parent_category_id')).not.toBeNull();
   });
 
@@ -211,21 +192,19 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', categoryA.getID())
       .createAsync();
     await CategoryEntity.updater(categoryA)
-      .enforcing()
       .setField('parent_category_id', categoryB.getID())
       .updateAsync();
 
-    await CategoryEntity.deleter(categoryA).enforcing().deleteAsync();
+    await CategoryEntity.deleter(categoryA).deleteAsync();
 
-    const loadedCategoryB = await CategoryEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(categoryB.getID());
+    const loadedCategoryB = await CategoryEntity.loader(viewerContext).loadByIDAsync(
+      categoryB.getID(),
+    );
     expect(loadedCategoryB.getField('parent_category_id')).toBeNull();
   });
 });
@@ -239,73 +218,77 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', parentCategory.getID())
       .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', subCategory.getID())
       .createAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
+        'parent_category_id',
+        parentCategory.getID(),
+      ),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
+        'parent_category_id',
+        subCategory.getID(),
+      ),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
       CategoryEntity,
     )['entityCompanion']['tableDataCoordinator'][
       'cacheAdapter'
-    ] as InMemoryFullCacheStubCacheAdapter<CategoryFields>;
-    const subCategoryCachedBefore = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
-      parentCategory.getID(),
-    ]);
-    expect(subCategoryCachedBefore.get(parentCategory.getID())?.status).toEqual(CacheStatus.HIT);
+    ] as InMemoryFullCacheStubCacheAdapter<CategoryFields, 'id'>;
+    const subCategoryCachedBefore = await categoryCacheAdapter.loadManyAsync(
+      new SingleFieldHolder('parent_category_id'),
+      [new SingleFieldValueHolder(parentCategory.getID())],
+    );
+    expect(
+      subCategoryCachedBefore.get(new SingleFieldValueHolder(parentCategory.getID()))?.status,
+    ).toEqual(CacheStatus.HIT);
 
     const subSubCategoryCachedBefore = await categoryCacheAdapter.loadManyAsync(
-      'parent_category_id',
-      [subCategory.getID()],
+      new SingleFieldHolder('parent_category_id'),
+      [new SingleFieldValueHolder(subCategory.getID())],
     );
-    expect(subSubCategoryCachedBefore.get(subCategory.getID())?.status).toEqual(CacheStatus.HIT);
+    expect(
+      subSubCategoryCachedBefore.get(new SingleFieldValueHolder(subCategory.getID()))?.status,
+    ).toEqual(CacheStatus.HIT);
 
-    await CategoryEntity.deleter(parentCategory).enforcing().deleteAsync();
+    await CategoryEntity.deleter(parentCategory).deleteAsync();
 
-    const subCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
-      parentCategory.getID(),
-    ]);
-    expect(subCategoryCachedAfter.get(parentCategory.getID())?.status).toEqual(CacheStatus.MISS);
+    const subCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync(
+      new SingleFieldHolder('parent_category_id'),
+      [new SingleFieldValueHolder(parentCategory.getID())],
+    );
+    expect(
+      subCategoryCachedAfter.get(new SingleFieldValueHolder(parentCategory.getID()))?.status,
+    ).toEqual(CacheStatus.MISS);
 
     const subSubCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync(
-      'parent_category_id',
-      [subCategory.getID()],
+      new SingleFieldHolder('parent_category_id'),
+      [new SingleFieldValueHolder(subCategory.getID())],
     );
-    expect(subSubCategoryCachedAfter.get(subCategory.getID())?.status).toEqual(CacheStatus.MISS);
+    expect(
+      subSubCategoryCachedAfter.get(new SingleFieldValueHolder(subCategory.getID()))?.status,
+    ).toEqual(CacheStatus.MISS);
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
   });
 
@@ -317,46 +300,60 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
-      .enforcing()
       .setField('parent_category_id', categoryA.getID())
       .createAsync();
     await CategoryEntity.updater(categoryA)
-      .enforcing()
       .setField('parent_category_id', categoryB.getID())
       .updateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryA.getID()),
+      CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
+        'parent_category_id',
+        categoryA.getID(),
+      ),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryB.getID()),
+      CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
+        'parent_category_id',
+        categoryB.getID(),
+      ),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
       CategoryEntity,
     )['entityCompanion']['tableDataCoordinator'][
       'cacheAdapter'
-    ] as InMemoryFullCacheStubCacheAdapter<CategoryFields>;
-    const categoriesCachedBefore = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
-      categoryA.getID(),
-      categoryB.getID(),
-    ]);
-    expect(categoriesCachedBefore.get(categoryA.getID())?.status).toEqual(CacheStatus.HIT);
-    expect(categoriesCachedBefore.get(categoryB.getID())?.status).toEqual(CacheStatus.HIT);
-
-    await CategoryEntity.deleter(categoryA).enforcing().deleteAsync();
-
-    const categoriesCachedAfter = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
-      categoryA.getID(),
-      categoryB.getID(),
-    ]);
-    expect(categoriesCachedAfter.get(categoryA.getID())?.status).toEqual(CacheStatus.MISS);
-    expect(categoriesCachedAfter.get(categoryB.getID())?.status).toEqual(CacheStatus.MISS);
+    ] as InMemoryFullCacheStubCacheAdapter<CategoryFields, 'id'>;
+    const categoriesCachedBefore = await categoryCacheAdapter.loadManyAsync(
+      new SingleFieldHolder('parent_category_id'),
+      [
+        new SingleFieldValueHolder(categoryA.getID()),
+        new SingleFieldValueHolder(categoryB.getID()),
+      ],
+    );
+    expect(
+      categoriesCachedBefore.get(new SingleFieldValueHolder(categoryA.getID()))?.status,
+    ).toEqual(CacheStatus.HIT);
+    expect(
+      categoriesCachedBefore.get(new SingleFieldValueHolder(categoryB.getID()))?.status,
+    ).toEqual(CacheStatus.HIT);
+
+    await CategoryEntity.deleter(categoryA).deleteAsync();
+
+    const categoriesCachedAfter = await categoryCacheAdapter.loadManyAsync(
+      new SingleFieldHolder('parent_category_id'),
+      [
+        new SingleFieldValueHolder(categoryA.getID()),
+        new SingleFieldValueHolder(categoryB.getID()),
+      ],
+    );
+    expect(
+      categoriesCachedAfter.get(new SingleFieldValueHolder(categoryA.getID()))?.status,
+    ).toEqual(CacheStatus.MISS);
+    expect(
+      categoriesCachedAfter.get(new SingleFieldValueHolder(categoryB.getID()))?.status,
+    ).toEqual(CacheStatus.MISS);
   });
 });

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -1,8 +1,14 @@
-import { mock, when, instance, anything, verify, anyString, deepEqual } from 'ts-mockito';
+import { mock, when, instance, anything, verify, deepEqual } from 'ts-mockito';
 
 import GenericEntityCacheAdapter from '../GenericEntityCacheAdapter';
 import IEntityGenericCacher from '../IEntityGenericCacher';
 import { CacheStatus } from '../internal/ReadThroughEntityCache';
+import {
+  SingleFieldHolder,
+  SingleFieldValueHolder,
+  SingleFieldValueHolderMap,
+} from '../internal/SingleFieldHolder';
+import { deepEqualEntityAware } from '../utils/__testfixtures__/TSMockitoExtensions';
 
 type BlahFields = {
   id: string;
@@ -11,9 +17,14 @@ type BlahFields = {
 describe(GenericEntityCacheAdapter, () => {
   describe('loadManyAsync', () => {
     it('returns appropriate cache results', async () => {
-      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
-      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
-        return `${fieldName}.${fieldValue}`;
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeyForStorage(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
       when(mockGenericCacher.loadManyAsync(deepEqual(['id.wat', 'id.who', 'id.why']))).thenResolve(
         new Map([
@@ -25,34 +36,56 @@ describe(GenericEntityCacheAdapter, () => {
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
 
-      const results = await cacheAdapter.loadManyAsync('id', ['wat', 'who', 'why']);
-      expect(results.get('wat')).toMatchObject({ status: CacheStatus.HIT, item: { id: 'wat' } });
-      expect(results.get('who')).toMatchObject({ status: CacheStatus.NEGATIVE });
-      expect(results.get('why')).toMatchObject({ status: CacheStatus.MISS });
+      const results = await cacheAdapter.loadManyAsync(new SingleFieldHolder('id'), [
+        new SingleFieldValueHolder('wat'),
+        new SingleFieldValueHolder('who'),
+        new SingleFieldValueHolder('why'),
+      ]);
+      expect(results.get(new SingleFieldValueHolder('wat'))).toMatchObject({
+        status: CacheStatus.HIT,
+        item: { id: 'wat' },
+      });
+      expect(results.get(new SingleFieldValueHolder('who'))).toMatchObject({
+        status: CacheStatus.NEGATIVE,
+      });
+      expect(results.get(new SingleFieldValueHolder('why'))).toMatchObject({
+        status: CacheStatus.MISS,
+      });
       expect(results.size).toBe(3);
 
       verify(mockGenericCacher.loadManyAsync(anything())).once();
     });
 
-    it('returns empty map when passed empty array of fieldValues', async () => {
-      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
+    it('returns empty map when passed empty array of load values', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
       when(mockGenericCacher.loadManyAsync(deepEqual([]))).thenResolve(new Map([]));
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      const results = await cacheAdapter.loadManyAsync('id', []);
-      expect(results).toEqual(new Map());
+      const results = await cacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [] as SingleFieldValueHolder<BlahFields, 'id'>[],
+      );
+      expect(results).toEqual(new SingleFieldValueHolderMap(new Map()));
     });
   });
 
   describe('cacheManyAsync', () => {
     it('correctly caches all objects', async () => {
-      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
-      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
-        return `${fieldName}.${fieldValue}`;
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeyForStorage(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.cacheManyAsync('id', new Map([['wat', { id: 'wat' }]]));
+      await cacheAdapter.cacheManyAsync(
+        new SingleFieldHolder('id'),
+        new Map([[new SingleFieldValueHolder('wat'), { id: 'wat' }]]),
+      );
 
       verify(
         mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]]))),
@@ -62,13 +95,20 @@ describe(GenericEntityCacheAdapter, () => {
 
   describe('cacheDBMissesAsync', () => {
     it('correctly caches misses', async () => {
-      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
-      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
-        return `${fieldName}.${fieldValue}`;
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeyForStorage(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.cacheDBMissesAsync('id', ['wat']);
+      await cacheAdapter.cacheDBMissesAsync(new SingleFieldHolder('id'), [
+        new SingleFieldValueHolder('wat'),
+      ]);
 
       verify(mockGenericCacher.cacheDBMissesAsync(deepEqual(['id.wat']))).once();
     });
@@ -76,25 +116,40 @@ describe(GenericEntityCacheAdapter, () => {
 
   describe('invalidateManyAsync', () => {
     it('invalidates correctly', async () => {
-      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
-      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
-        return `${fieldName}.${fieldValue}`;
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeysForInvalidation(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.invalidateManyAsync('id', ['wat']);
+      await cacheAdapter.invalidateManyAsync(new SingleFieldHolder('id'), [
+        new SingleFieldValueHolder('wat'),
+      ]);
 
       verify(mockGenericCacher.invalidateManyAsync(deepEqual(['id.wat']))).once();
     });
 
     it('returns when passed empty array of fieldValues', async () => {
-      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
-      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
-        return `${fieldName}.${fieldValue}`;
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeysForInvalidation(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.invalidateManyAsync('id', []);
+      await cacheAdapter.invalidateManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [] as SingleFieldValueHolder<BlahFields, 'id'>[],
+      );
 
       verify(mockGenericCacher.invalidateManyAsync(deepEqual([]))).once();
     });