@expo/entity 0.41.0 → 0.42.0

package/src/__tests__/ComposedCacheAdapter-test.ts

@@ -1,16 +1,16 @@
-import invariant from 'invariant';
-
 import ComposedEntityCacheAdapter from '../ComposedEntityCacheAdapter';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
 import IEntityCacheAdapter from '../IEntityCacheAdapter';
+import { IEntityLoadKey, IEntityLoadValue } from '../internal/EntityLoadInterfaces';
 import { CacheLoadResult, CacheStatus } from '../internal/ReadThroughEntityCache';
+import { SingleFieldHolder, SingleFieldValueHolder } from '../internal/SingleFieldHolder';
 
 type BlahFields = {
   id: string;
 };
 
-const entityConfiguration = new EntityConfiguration<BlahFields>({
+const entityConfiguration = new EntityConfiguration<BlahFields, 'id'>({
   idField: 'id',
   tableName: 'blah',
   schema: {
@@ -21,37 +21,43 @@ const entityConfiguration = new EntityConfiguration<BlahFields>({
 });
 
 export const DOES_NOT_EXIST_LOCAL_MEMORY_CACHE = Symbol('doesNotExist');
-type LocalMemoryCacheValue<TFields> = Readonly<TFields> | typeof DOES_NOT_EXIST_LOCAL_MEMORY_CACHE;
+type LocalMemoryCacheValue<TFields extends Record<string, any>> =
+  | Readonly<TFields>
+  | typeof DOES_NOT_EXIST_LOCAL_MEMORY_CACHE;
 
-class TestLocalCacheAdapter<TFields extends Record<string, any>>
-  implements IEntityCacheAdapter<TFields>
+class TestLocalCacheAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>
+  implements IEntityCacheAdapter<TFields, TIDField>
 {
   constructor(
-    private readonly entityConfiguration: EntityConfiguration<TFields>,
+    private readonly entityConfiguration: EntityConfiguration<TFields, TIDField>,
     private readonly cache: Map<string, LocalMemoryCacheValue<TFields>>,
   ) {}
 
-  public async loadManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
+  public async loadManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, CacheLoadResult<TFields>>> {
     const localMemoryCacheKeyToFieldValueMapping = new Map(
-      fieldValues.map((fieldValue) => [this.makeCacheKey(fieldName, fieldValue), fieldValue]),
+      values.map((value) => [this.makeCacheKey(key, value), value]),
     );
-    const cacheResults = new Map<NonNullable<TFields[N]>, CacheLoadResult<TFields>>();
-    for (const [cacheKey, fieldValue] of localMemoryCacheKeyToFieldValueMapping) {
+    const cacheResults = key.vendNewLoadValueMap<CacheLoadResult<TFields>>();
+    for (const [cacheKey, value] of localMemoryCacheKeyToFieldValueMapping) {
       const cacheResult = this.cache.get(cacheKey);
       if (cacheResult === DOES_NOT_EXIST_LOCAL_MEMORY_CACHE) {
-        cacheResults.set(fieldValue, {
+        cacheResults.set(value, {
           status: CacheStatus.NEGATIVE,
         });
       } else if (cacheResult) {
-        cacheResults.set(fieldValue, {
+        cacheResults.set(value, {
           status: CacheStatus.HIT,
           item: cacheResult,
         });
       } else {
-        cacheResults.set(fieldValue, {
+        cacheResults.set(value, {
           status: CacheStatus.MISS,
         });
       }
@@ -60,62 +66,63 @@ class TestLocalCacheAdapter<TFields extends Record<string, any>>
     return cacheResults;
   }
 
-  public async cacheManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
-  ): Promise<void> {
-    for (const [fieldValue, item] of objectMap) {
-      const cacheKey = this.makeCacheKey(fieldName, fieldValue);
+  public async cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>): Promise<void> {
+    for (const [value, item] of objectMap) {
+      const cacheKey = this.makeCacheKey(key, value);
       this.cache.set(cacheKey, item);
     }
   }
 
-  public async cacheDBMissesAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<void> {
-    for (const fieldValue of fieldValues) {
-      const cacheKey = this.makeCacheKey(fieldName, fieldValue);
+  public async cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
+    for (const value of values) {
+      const cacheKey = this.makeCacheKey(key, value);
       this.cache.set(cacheKey, DOES_NOT_EXIST_LOCAL_MEMORY_CACHE);
     }
   }
 
-  public async invalidateManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<void> {
-    for (const fieldValue of fieldValues) {
-      const cacheKey = this.makeCacheKey(fieldName, fieldValue);
+  public async invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
+    for (const value of values) {
+      const cacheKey = this.makeCacheKey(key, value);
       this.cache.delete(cacheKey);
     }
   }
 
-  private makeCacheKey<N extends keyof TFields>(
-    fieldName: N,
-    fieldValue: NonNullable<TFields[N]>,
-  ): string {
-    const columnName = this.entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
-    invariant(columnName, `database field mapping missing for ${String(fieldName)}`);
-    const parts = [
+  private makeCacheKey<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, value: TLoadValue): string {
+    const cacheKeyType = key.getLoadMethodType();
+    const parts = key.createCacheKeyPartsForLoadValue(this.entityConfiguration, value);
+    const delimiter = ':';
+    const escapedParts = [
       this.entityConfiguration.tableName,
+      cacheKeyType,
       `${this.entityConfiguration.cacheKeyVersion}`,
-      columnName,
-      String(fieldValue),
-    ];
-    const delimiter = ':';
-    const escapedParts = parts.map((part) =>
-      part.replace('\\', '\\\\').replace(delimiter, `\\${delimiter}`),
-    );
+      ...parts,
+    ].map((part) => part.replace('\\', '\\\\').replace(delimiter, `\\${delimiter}`));
     return escapedParts.join(delimiter);
   }
 }
 
 function makeTestCacheAdapters(): {
   primaryCache: Map<string, LocalMemoryCacheValue<BlahFields>>;
-  primaryCacheAdapter: TestLocalCacheAdapter<BlahFields>;
+  primaryCacheAdapter: TestLocalCacheAdapter<BlahFields, 'id'>;
   fallbackCache: Map<string, LocalMemoryCacheValue<BlahFields>>;
-  fallbackCacheAdapter: TestLocalCacheAdapter<BlahFields>;
-  cacheAdapter: ComposedEntityCacheAdapter<BlahFields>;
+  fallbackCacheAdapter: TestLocalCacheAdapter<BlahFields, 'id'>;
+  cacheAdapter: ComposedEntityCacheAdapter<BlahFields, 'id'>;
 } {
   const primaryCache = new Map();
   const primaryCacheAdapter = new TestLocalCacheAdapter(entityConfiguration, primaryCache);
@@ -139,96 +146,158 @@ describe(ComposedEntityCacheAdapter, () => {
     it('returns primary results when populated', async () => {
       const { primaryCacheAdapter, cacheAdapter } = makeTestCacheAdapters();
 
-      const cacheHits = new Map<string, Readonly<BlahFields>>([['test-id-1', { id: 'test-id-1' }]]);
-      await primaryCacheAdapter.cacheManyAsync('id', cacheHits);
-      await primaryCacheAdapter.cacheDBMissesAsync('id', ['test-id-2']);
-
-      const results = await cacheAdapter.loadManyAsync('id', [
-        'test-id-1',
-        'test-id-2',
-        'test-id-3',
+      const cacheHits = new Map<SingleFieldValueHolder<BlahFields, 'id'>, Readonly<BlahFields>>([
+        [new SingleFieldValueHolder('test-id-1'), { id: 'test-id-1' }],
       ]);
+      await primaryCacheAdapter.cacheManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        cacheHits,
+      );
+      await primaryCacheAdapter.cacheDBMissesAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [new SingleFieldValueHolder('test-id-2')],
+      );
 
-      expect(results.get('test-id-1')).toMatchObject({
+      const results = await cacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder('test-id-1'),
+          new SingleFieldValueHolder('test-id-2'),
+          new SingleFieldValueHolder('test-id-3'),
+        ],
+      );
+
+      expect(results.get(new SingleFieldValueHolder('test-id-1'))).toMatchObject({
         status: CacheStatus.HIT,
         item: { id: 'test-id-1' },
       });
-      expect(results.get('test-id-2')).toMatchObject({ status: CacheStatus.NEGATIVE });
-      expect(results.get('test-id-3')).toMatchObject({ status: CacheStatus.MISS });
+      expect(results.get(new SingleFieldValueHolder('test-id-2'))).toMatchObject({
+        status: CacheStatus.NEGATIVE,
+      });
+      expect(results.get(new SingleFieldValueHolder('test-id-3'))).toMatchObject({
+        status: CacheStatus.MISS,
+      });
       expect(results.size).toBe(3);
     });
 
     it('returns fallback adapter results primary is empty', async () => {
       const { fallbackCacheAdapter, cacheAdapter } = makeTestCacheAdapters();
 
-      const cacheHits = new Map<string, Readonly<BlahFields>>([['test-id-1', { id: 'test-id-1' }]]);
-      await fallbackCacheAdapter.cacheManyAsync('id', cacheHits);
-      await fallbackCacheAdapter.cacheDBMissesAsync('id', ['test-id-2']);
-
-      const results = await cacheAdapter.loadManyAsync('id', [
-        'test-id-1',
-        'test-id-2',
-        'test-id-3',
+      const cacheHits = new Map<SingleFieldValueHolder<BlahFields, 'id'>, Readonly<BlahFields>>([
+        [new SingleFieldValueHolder('test-id-1'), { id: 'test-id-1' }],
       ]);
+      await fallbackCacheAdapter.cacheManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        cacheHits,
+      );
+      await fallbackCacheAdapter.cacheDBMissesAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [new SingleFieldValueHolder('test-id-2')],
+      );
+
+      const results = await cacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder('test-id-1'),
+          new SingleFieldValueHolder('test-id-2'),
+          new SingleFieldValueHolder('test-id-3'),
+        ],
+      );
 
-      expect(results.get('test-id-1')).toMatchObject({
+      expect(results.get(new SingleFieldValueHolder('test-id-1'))).toMatchObject({
         status: CacheStatus.HIT,
         item: { id: 'test-id-1' },
       });
-      expect(results.get('test-id-2')).toMatchObject({ status: CacheStatus.NEGATIVE });
-      expect(results.get('test-id-3')).toMatchObject({ status: CacheStatus.MISS });
+      expect(results.get(new SingleFieldValueHolder('test-id-2'))).toMatchObject({
+        status: CacheStatus.NEGATIVE,
+      });
+      expect(results.get(new SingleFieldValueHolder('test-id-3'))).toMatchObject({
+        status: CacheStatus.MISS,
+      });
       expect(results.size).toBe(3);
     });
 
     it('populates primary adapter with fallback adapter results', async () => {
       const { primaryCacheAdapter, fallbackCacheAdapter, cacheAdapter } = makeTestCacheAdapters();
 
-      const cacheHits = new Map<string, Readonly<BlahFields>>([['test-id-1', { id: 'test-id-1' }]]);
-      await fallbackCacheAdapter.cacheManyAsync('id', cacheHits);
-      await fallbackCacheAdapter.cacheDBMissesAsync('id', ['test-id-2']);
+      const cacheHits = new Map<SingleFieldValueHolder<BlahFields, 'id'>, Readonly<BlahFields>>([
+        [new SingleFieldValueHolder('test-id-1'), { id: 'test-id-1' }],
+      ]);
+      await fallbackCacheAdapter.cacheManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        cacheHits,
+      );
+      await fallbackCacheAdapter.cacheDBMissesAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [new SingleFieldValueHolder('test-id-2')],
+      );
 
       // should populate primary cache with fallback cache results
-      await cacheAdapter.loadManyAsync('id', ['test-id-1', 'test-id-2', 'test-id-3']);
-
-      const primaryResults = await primaryCacheAdapter.loadManyAsync('id', [
-        'test-id-1',
-        'test-id-2',
-        'test-id-3',
+      await cacheAdapter.loadManyAsync(new SingleFieldHolder<BlahFields, 'id', 'id'>('id'), [
+        new SingleFieldValueHolder('test-id-1'),
+        new SingleFieldValueHolder('test-id-2'),
+        new SingleFieldValueHolder('test-id-3'),
       ]);
 
-      expect(primaryResults.get('test-id-1')).toMatchObject({
+      const primaryResults = await primaryCacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder('test-id-1'),
+          new SingleFieldValueHolder('test-id-2'),
+          new SingleFieldValueHolder('test-id-3'),
+        ],
+      );
+
+      expect(primaryResults.get(new SingleFieldValueHolder('test-id-1'))).toMatchObject({
         status: CacheStatus.HIT,
         item: { id: 'test-id-1' },
       });
-      expect(primaryResults.get('test-id-2')).toMatchObject({ status: CacheStatus.NEGATIVE });
-      expect(primaryResults.get('test-id-3')).toMatchObject({ status: CacheStatus.MISS });
+      expect(primaryResults.get(new SingleFieldValueHolder('test-id-2'))).toMatchObject({
+        status: CacheStatus.NEGATIVE,
+      });
+      expect(primaryResults.get(new SingleFieldValueHolder('test-id-3'))).toMatchObject({
+        status: CacheStatus.MISS,
+      });
       expect(primaryResults.size).toBe(3);
 
       // ensure that populating the primary cache doesn't change the output
-      const composedResults = await cacheAdapter.loadManyAsync('id', [
-        'test-id-1',
-        'test-id-2',
-        'test-id-3',
-      ]);
-      expect(composedResults.get('test-id-1')).toMatchObject({
+      const composedResults = await cacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder('test-id-1'),
+          new SingleFieldValueHolder('test-id-2'),
+          new SingleFieldValueHolder('test-id-3'),
+        ],
+      );
+      expect(composedResults.get(new SingleFieldValueHolder('test-id-1'))).toMatchObject({
         status: CacheStatus.HIT,
         item: { id: 'test-id-1' },
       });
-      expect(composedResults.get('test-id-2')).toMatchObject({ status: CacheStatus.NEGATIVE });
-      expect(composedResults.get('test-id-3')).toMatchObject({ status: CacheStatus.MISS });
+      expect(composedResults.get(new SingleFieldValueHolder('test-id-2'))).toMatchObject({
+        status: CacheStatus.NEGATIVE,
+      });
+      expect(composedResults.get(new SingleFieldValueHolder('test-id-3'))).toMatchObject({
+        status: CacheStatus.MISS,
+      });
       expect(composedResults.size).toBe(3);
     });
 
-    it('returns empty map when passed empty array of fieldValues', async () => {
+    it('returns empty map when passed empty array of values', async () => {
       const { cacheAdapter } = makeTestCacheAdapters();
-      const results = await cacheAdapter.loadManyAsync('id', []);
-      expect(results).toEqual(new Map());
+      const results = await cacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [] as any,
+      );
+      expect(results.size).toBe(0);
     });
 
     it('handles 0 cache adapter compose case', async () => {
-      const cacheAdapter = new ComposedEntityCacheAdapter<any>([]);
-      const results = await cacheAdapter.loadManyAsync('id', []);
-      expect(results).toEqual(new Map());
+      const cacheAdapter = new ComposedEntityCacheAdapter<BlahFields, 'id'>([]);
+      const results = await cacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [] as any,
+      );
+      expect(results.size).toBe(0);
     });
   });
 
@@ -242,14 +311,23 @@ describe(ComposedEntityCacheAdapter, () => {
         cacheAdapter,
       } = makeTestCacheAdapters();
 
-      await cacheAdapter.cacheManyAsync('id', new Map([['test-id-1', { id: 'test-id-1' }]]));
+      await cacheAdapter.cacheManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new Map([[new SingleFieldValueHolder('test-id-1'), { id: 'test-id-1' }]]),
+      );
 
-      const primaryLocalMemoryCacheKey = primaryCacheAdapter['makeCacheKey']('id', 'test-id-1');
+      const primaryLocalMemoryCacheKey = primaryCacheAdapter['makeCacheKey'](
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new SingleFieldValueHolder('test-id-1'),
+      );
       expect(primaryCache.get(primaryLocalMemoryCacheKey)).toMatchObject({
         id: 'test-id-1',
       });
 
-      const fallbackLocalMemoryCacheKey = fallbackCacheAdapter['makeCacheKey']('id', 'test-id-1');
+      const fallbackLocalMemoryCacheKey = fallbackCacheAdapter['makeCacheKey'](
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new SingleFieldValueHolder('test-id-1'),
+      );
       expect(fallbackCache.get(fallbackLocalMemoryCacheKey)).toMatchObject({
         id: 'test-id-1',
       });
@@ -266,12 +344,20 @@ describe(ComposedEntityCacheAdapter, () => {
         cacheAdapter,
       } = makeTestCacheAdapters();
 
-      await cacheAdapter.cacheDBMissesAsync('id', ['test-id-1']);
+      await cacheAdapter.cacheDBMissesAsync(new SingleFieldHolder<BlahFields, 'id', 'id'>('id'), [
+        new SingleFieldValueHolder('test-id-1'),
+      ]);
 
-      const primaryLocalMemoryCacheKey = primaryCacheAdapter['makeCacheKey']('id', 'test-id-1');
+      const primaryLocalMemoryCacheKey = primaryCacheAdapter['makeCacheKey'](
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new SingleFieldValueHolder('test-id-1'),
+      );
       expect(primaryCache.get(primaryLocalMemoryCacheKey)).toBe(DOES_NOT_EXIST_LOCAL_MEMORY_CACHE);
 
-      const fallbackLocalMemoryCacheKey = fallbackCacheAdapter['makeCacheKey']('id', 'test-id-1');
+      const fallbackLocalMemoryCacheKey = fallbackCacheAdapter['makeCacheKey'](
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new SingleFieldValueHolder('test-id-1'),
+      );
       expect(fallbackCache.get(fallbackLocalMemoryCacheKey)).toBe(
         DOES_NOT_EXIST_LOCAL_MEMORY_CACHE,
       );
@@ -288,29 +374,61 @@ describe(ComposedEntityCacheAdapter, () => {
         cacheAdapter,
       } = makeTestCacheAdapters();
 
-      const cacheHits = new Map<string, Readonly<BlahFields>>([['test-id-1', { id: 'test-id-1' }]]);
-      await primaryCacheAdapter.cacheManyAsync('id', cacheHits);
-      await primaryCacheAdapter.cacheDBMissesAsync('id', ['test-id-2']);
-      await fallbackCacheAdapter.cacheManyAsync('id', cacheHits);
-      await fallbackCacheAdapter.cacheDBMissesAsync('id', ['test-id-2']);
+      const cacheHits = new Map<SingleFieldValueHolder<BlahFields, 'id'>, Readonly<BlahFields>>([
+        [new SingleFieldValueHolder('test-id-1'), { id: 'test-id-1' }],
+      ]);
+      await primaryCacheAdapter.cacheManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        cacheHits,
+      );
+      await primaryCacheAdapter.cacheDBMissesAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [new SingleFieldValueHolder('test-id-2')],
+      );
+      await fallbackCacheAdapter.cacheManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        cacheHits,
+      );
+      await fallbackCacheAdapter.cacheDBMissesAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [new SingleFieldValueHolder('test-id-2')],
+      );
 
-      await cacheAdapter.invalidateManyAsync('id', ['test-id-1', 'test-id-2']);
+      await cacheAdapter.invalidateManyAsync(new SingleFieldHolder<BlahFields, 'id', 'id'>('id'), [
+        new SingleFieldValueHolder('test-id-1'),
+        new SingleFieldValueHolder('test-id-2'),
+      ]);
 
-      const primaryLocalMemoryCacheKey1 = primaryCacheAdapter['makeCacheKey']('id', 'test-id-1');
+      const primaryLocalMemoryCacheKey1 = primaryCacheAdapter['makeCacheKey'](
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new SingleFieldValueHolder('test-id-1'),
+      );
       expect(primaryCache.get(primaryLocalMemoryCacheKey1)).toBe(undefined);
-      const primaryLocalMemoryCacheKey2 = primaryCacheAdapter['makeCacheKey']('id', 'test-id-1');
+      const primaryLocalMemoryCacheKey2 = primaryCacheAdapter['makeCacheKey'](
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new SingleFieldValueHolder('test-id-1'),
+      );
       expect(primaryCache.get(primaryLocalMemoryCacheKey2)).toBe(undefined);
 
-      const fallbackLocalMemoryCacheKey1 = fallbackCacheAdapter['makeCacheKey']('id', 'test-id-1');
+      const fallbackLocalMemoryCacheKey1 = fallbackCacheAdapter['makeCacheKey'](
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new SingleFieldValueHolder('test-id-1'),
+      );
       expect(fallbackCache.get(fallbackLocalMemoryCacheKey1)).toBe(undefined);
-      const fallbackLocalMemoryCacheKey2 = fallbackCacheAdapter['makeCacheKey']('id', 'test-id-1');
+      const fallbackLocalMemoryCacheKey2 = fallbackCacheAdapter['makeCacheKey'](
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        new SingleFieldValueHolder('test-id-1'),
+      );
       expect(fallbackCache.get(fallbackLocalMemoryCacheKey2)).toBe(undefined);
     });
 
     it('returns when passed empty array of fieldValues', async () => {
       const { cacheAdapter } = makeTestCacheAdapters();
 
-      await cacheAdapter.invalidateManyAsync('id', []);
+      await cacheAdapter.invalidateManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [] as any,
+      );
     });
   });
 });

package/src/__tests__/EnforcingEntityLoader-test.ts

@@ -3,6 +3,8 @@ import { mock, instance, when, anything } from 'ts-mockito';
 
 import AuthorizationResultBasedEntityLoader from '../AuthorizationResultBasedEntityLoader';
 import EnforcingEntityLoader from '../EnforcingEntityLoader';
+import { CompositeFieldValueHolder } from '../internal/CompositeFieldHolder';
+import { CompositeFieldValueMap } from '../internal/CompositeFieldValueMap';
 
 describe(EnforcingEntityLoader, () => {
   describe('loadManyByFieldEqualingManyAsync', () => {
@@ -55,6 +57,133 @@ describe(EnforcingEntityLoader, () => {
     });
   });
 
+  describe('loadManyByCompositeFieldEqualingManyAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityLoaderMock = mock<
+        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
+      >(AuthorizationResultBasedEntityLoader);
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityLoaderMock.loadManyByCompositeFieldEqualingManyAsync(
+          anything(),
+          anything(),
+        ),
+      ).thenResolve(
+        new CompositeFieldValueMap([
+          [new CompositeFieldValueHolder({ wat: 'hello' }), [result(rejection)]],
+        ]),
+      );
+      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
+      await expect(
+        enforcingEntityLoader.loadManyByCompositeFieldEqualingManyAsync(anything(), anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityLoaderMock = mock<
+        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
+      >(AuthorizationResultBasedEntityLoader);
+
+      const resolved = {};
+      when(
+        nonEnforcingEntityLoaderMock.loadManyByCompositeFieldEqualingManyAsync(
+          anything(),
+          anything(),
+        ),
+      ).thenResolve(
+        new CompositeFieldValueMap([
+          [new CompositeFieldValueHolder({ wat: 'hello' }), [result(resolved)]],
+        ]),
+      );
+
+      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
+
+      await expect(
+        enforcingEntityLoader.loadManyByCompositeFieldEqualingManyAsync(anything(), anything()),
+      ).resolves.toEqual(
+        new CompositeFieldValueMap([[new CompositeFieldValueHolder({ wat: 'hello' }), [resolved]]]),
+      );
+    });
+  });
+
+  describe('loadManyByCompositeFieldEqualingAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityLoaderMock = mock<
+        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
+      >(AuthorizationResultBasedEntityLoader);
+
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityLoaderMock.loadManyByCompositeFieldEqualingAsync(anything(), anything()),
+      ).thenResolve([result(rejection)]);
+
+      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
+
+      await expect(
+        enforcingEntityLoader.loadManyByCompositeFieldEqualingAsync(anything(), anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityLoaderMock = mock<
+        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
+      >(AuthorizationResultBasedEntityLoader);
+
+      const resolved = {};
+      when(
+        nonEnforcingEntityLoaderMock.loadManyByCompositeFieldEqualingAsync(anything(), anything()),
+      ).thenResolve([result(resolved)]);
+
+      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
+
+      await expect(
+        enforcingEntityLoader.loadManyByCompositeFieldEqualingAsync(anything(), anything()),
+      ).resolves.toEqual([resolved]);
+    });
+  });
+
+  describe('loadByCompositeFieldEqualingAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityLoaderMock = mock<
+        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
+      >(AuthorizationResultBasedEntityLoader);
+
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityLoaderMock.loadByCompositeFieldEqualingAsync(anything(), anything()),
+      ).thenResolve(result(rejection));
+
+      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
+
+      await expect(
+        enforcingEntityLoader.loadByCompositeFieldEqualingAsync(anything(), anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityLoaderMock = mock<
+        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
+      >(AuthorizationResultBasedEntityLoader);
+
+      const resolved = {};
+      when(
+        nonEnforcingEntityLoaderMock.loadByCompositeFieldEqualingAsync(anything(), anything()),
+      ).thenResolve(result(resolved));
+
+      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
+
+      await expect(
+        enforcingEntityLoader.loadByCompositeFieldEqualingAsync(anything(), anything()),
+      ).resolves.toEqual(resolved);
+    });
+  });
+
   describe('loadManyByFieldEqualingAsync', () => {
     it('throws when result is unsuccessful', async () => {
       const nonEnforcingEntityLoaderMock = mock<
@@ -449,7 +578,12 @@ describe(EnforcingEntityLoader, () => {
     );
 
     // ensure known differences still exist for sanity check
-    const knownLoaderOnlyDifferences = ['validateFieldValues'];
+    const knownLoaderOnlyDifferences = [
+      'validateFieldAndValues',
+      'validateFieldAndValuesAndConvertToHolders',
+      'validateCompositeFieldAndValuesAndConvertToHolders',
+      'constructAndAuthorizeEntitiesFromCompositeFieldValueHolderMapAsync',
+    ];
     expect(nonEnforcingLoaderProperties).toEqual(
       expect.arrayContaining(knownLoaderOnlyDifferences),
     );