@expo/entity 0.41.0 → 0.42.0

package/src/internal/__tests__/ReadThroughEntityCache-test.ts

@@ -1,16 +1,25 @@
-import { verify, deepEqual, mock, instance, when, anything } from 'ts-mockito';
+import { verify, mock, instance, when, anything } from 'ts-mockito';
 
 import EntityConfiguration from '../../EntityConfiguration';
 import { UUIDField } from '../../EntityFields';
 import IEntityCacheAdapter from '../../IEntityCacheAdapter';
+import {
+  deepEqualEntityAware,
+  isEqualWithEntityAware,
+} from '../../utils/__testfixtures__/TSMockitoExtensions';
 import ReadThroughEntityCache, { CacheStatus } from '../ReadThroughEntityCache';
+import {
+  SingleFieldHolder,
+  SingleFieldValueHolder,
+  SingleFieldValueHolderMap,
+} from '../SingleFieldHolder';
 
 type BlahFields = {
   id: string;
 };
 
-const makeEntityConfiguration = (cacheIdField: boolean): EntityConfiguration<BlahFields> =>
-  new EntityConfiguration<BlahFields>({
+const makeEntityConfiguration = (cacheIdField: boolean): EntityConfiguration<BlahFields, 'id'> =>
+  new EntityConfiguration<BlahFields, 'id'>({
     idField: 'id',
     tableName: 'blah',
     schema: {
@@ -23,12 +32,14 @@ const makeEntityConfiguration = (cacheIdField: boolean): EntityConfiguration<Bla
 const createIdFetcher =
   (ids: string[]) =>
   async <N extends keyof BlahFields>(
-    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[],
-  ): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
-    const results = new Map();
+    fetcherFieldValues: readonly SingleFieldValueHolder<BlahFields, N>[],
+  ): Promise<
+    ReadonlyMap<SingleFieldValueHolder<BlahFields, N>, readonly Readonly<BlahFields>[]>
+  > => {
+    const results = new SingleFieldValueHolderMap<BlahFields, N, readonly Readonly<BlahFields>[]>();
     fetcherFieldValues.forEach((v) => {
-      if (ids.includes(v)) {
-        results.set(v, [{ id: v }]);
+      if (ids.includes(v.fieldValue)) {
+        results.set(v, [{ id: v.fieldValue }]);
       } else {
         results.set(v, []);
       }
@@ -39,12 +50,14 @@ const createIdFetcher =
 const createFetcherNonUnique =
   (ids: string[]) =>
   async <N extends keyof BlahFields>(
-    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[],
-  ): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
-    const results = new Map();
+    fetcherFieldValues: readonly SingleFieldValueHolder<BlahFields, N>[],
+  ): Promise<
+    ReadonlyMap<SingleFieldValueHolder<BlahFields, N>, readonly Readonly<BlahFields>[]>
+  > => {
+    const results = new SingleFieldValueHolderMap<BlahFields, N, readonly Readonly<BlahFields>[]>();
     fetcherFieldValues.forEach((v) => {
-      if (ids.includes(v)) {
-        results.set(v, [{ id: v }, { id: v + '2' }]);
+      if (ids.includes(v.fieldValue)) {
+        results.set(v, [{ id: v.fieldValue }, { id: v.fieldValue + '2' }]);
       } else {
         results.set(v, []);
       }
@@ -55,207 +68,402 @@ const createFetcherNonUnique =
 describe(ReadThroughEntityCache, () => {
   describe('readManyThroughAsync', () => {
     it('fetches from DB upon cache miss and caches the result', async () => {
-      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createIdFetcher(['wat', 'who']);
 
-      when(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).thenResolve(
-        new Map([
-          ['wat', { status: CacheStatus.MISS }],
-          ['who', { status: CacheStatus.MISS }],
-        ]),
+      when(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([
+            new SingleFieldValueHolder('wat'),
+            new SingleFieldValueHolder('who'),
+          ]),
+        ),
+      ).thenResolve(
+        new SingleFieldValueHolderMap(
+          new Map([
+            [new SingleFieldValueHolder('wat'), { status: CacheStatus.MISS }],
+            [new SingleFieldValueHolder('who'), { status: CacheStatus.MISS }],
+          ]),
+        ),
       );
 
-      const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
+      const result = await entityCache.readManyThroughAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder<BlahFields, 'id'>('wat'),
+          new SingleFieldValueHolder<BlahFields, 'id'>('who'),
+        ],
+        fetcher,
+      );
 
-      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).once();
+      verify(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([
+            new SingleFieldValueHolder('wat'),
+            new SingleFieldValueHolder('who'),
+          ]),
+        ),
+      ).once();
       verify(
         cacheAdapterMock.cacheManyAsync(
-          'id',
-          deepEqual(
-            new Map([
-              ['wat', { id: 'wat' }],
-              ['who', { id: 'who' }],
-            ]),
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(
+            new SingleFieldValueHolderMap(
+              new Map([
+                [new SingleFieldValueHolder('wat'), { id: 'wat' }],
+                [new SingleFieldValueHolder('who'), { id: 'who' }],
+              ]),
+            ),
           ),
         ),
       ).once();
-      verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).once();
+      verify(
+        cacheAdapterMock.cacheDBMissesAsync(
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
+          deepEqualEntityAware([] as SingleFieldValueHolder<BlahFields, 'id'>[]),
+        ),
+      ).once();
       expect(result).toEqual(
-        new Map([
-          ['wat', [{ id: 'wat' }]],
-          ['who', [{ id: 'who' }]],
-        ]),
+        new SingleFieldValueHolderMap(
+          new Map([
+            [new SingleFieldValueHolder('wat'), [{ id: 'wat' }]],
+            [new SingleFieldValueHolder('who'), [{ id: 'who' }]],
+          ]),
+        ),
       );
     });
 
     it('does not fetch from the DB or cache results when all cache fetches are hits', async () => {
-      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createIdFetcher(['wat', 'who']);
 
-      when(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).thenResolve(
+      when(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([
+            new SingleFieldValueHolder('wat'),
+            new SingleFieldValueHolder('who'),
+          ]),
+        ),
+      ).thenResolve(
         new Map([
-          ['wat', { status: CacheStatus.HIT, item: { id: 'wat' } }],
-          ['who', { status: CacheStatus.HIT, item: { id: 'who' } }],
+          [new SingleFieldValueHolder('wat'), { status: CacheStatus.HIT, item: { id: 'wat' } }],
+          [new SingleFieldValueHolder('who'), { status: CacheStatus.HIT, item: { id: 'who' } }],
         ]),
       );
 
-      const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
+      const result = await entityCache.readManyThroughAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder<BlahFields, 'id'>('wat'),
+          new SingleFieldValueHolder<BlahFields, 'id'>('who'),
+        ],
+        fetcher,
+      );
 
-      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).once();
+      verify(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([
+            new SingleFieldValueHolder('wat'),
+            new SingleFieldValueHolder('who'),
+          ]),
+        ),
+      ).once();
       verify(
         cacheAdapterMock.cacheManyAsync(
-          'id',
-          deepEqual(
-            new Map([
-              ['wat', { id: 'wat' }],
-              ['who', { id: 'who' }],
-            ]),
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(
+            new SingleFieldValueHolderMap(
+              new Map([
+                [new SingleFieldValueHolder('wat'), { id: 'wat' }],
+                [new SingleFieldValueHolder('who'), { id: 'who' }],
+              ]),
+            ),
           ),
         ),
       ).never();
-      verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).never();
+      verify(
+        cacheAdapterMock.cacheDBMissesAsync(
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
+          deepEqualEntityAware([] as SingleFieldValueHolder<BlahFields, 'id'>[]),
+        ),
+      ).never();
       expect(result).toEqual(
-        new Map([
-          ['wat', [{ id: 'wat' }]],
-          ['who', [{ id: 'who' }]],
-        ]),
+        new SingleFieldValueHolderMap(
+          new Map([
+            [new SingleFieldValueHolder('wat'), [{ id: 'wat' }]],
+            [new SingleFieldValueHolder('who'), [{ id: 'who' }]],
+          ]),
+        ),
       );
     });
 
     it('negatively caches db misses', async () => {
-      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
 
       // simulate db miss
       const fetcher = createIdFetcher(['wat', 'who']);
 
-      when(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).thenResolve(
-        new Map([['why', { status: CacheStatus.MISS }]]),
+      when(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([new SingleFieldValueHolder('why')]),
+        ),
+      ).thenResolve(
+        new SingleFieldValueHolderMap(
+          new Map([[new SingleFieldValueHolder('why'), { status: CacheStatus.MISS }]]),
+        ),
       );
 
-      const result = await entityCache.readManyThroughAsync('id', ['why'], fetcher);
+      const result = await entityCache.readManyThroughAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [new SingleFieldValueHolder<BlahFields, 'id'>('why')],
+        fetcher,
+      );
 
-      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).once();
-      verify(cacheAdapterMock.cacheManyAsync('id', deepEqual(new Map()))).once();
-      verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual(['why']))).once();
-      expect(result).toEqual(new Map());
+      verify(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([new SingleFieldValueHolder('why')]),
+        ),
+      ).once();
+      verify(
+        cacheAdapterMock.cacheManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldValueHolderMap(new Map())),
+        ),
+      ).once();
+      verify(
+        cacheAdapterMock.cacheDBMissesAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([new SingleFieldValueHolder('why')]),
+        ),
+      ).once();
+      expect(result).toEqual(new SingleFieldValueHolderMap(new Map()));
     });
 
     it('does not return or fetch negatively cached results from DB', async () => {
-      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createIdFetcher([]);
 
-      when(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).thenResolve(
-        new Map([['why', { status: CacheStatus.NEGATIVE }]]),
+      when(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([new SingleFieldValueHolder('why')]),
+        ),
+      ).thenResolve(
+        new SingleFieldValueHolderMap(
+          new Map([[new SingleFieldValueHolder('why'), { status: CacheStatus.NEGATIVE }]]),
+        ),
       );
 
-      const result = await entityCache.readManyThroughAsync('id', ['why'], fetcher);
-      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).once();
-      verify(cacheAdapterMock.cacheManyAsync('id', anything())).never();
-      verify(cacheAdapterMock.cacheDBMissesAsync('id', anything())).never();
-      expect(result).toEqual(new Map());
+      const result = await entityCache.readManyThroughAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [new SingleFieldValueHolder<BlahFields, 'id'>('why')],
+        fetcher,
+      );
+      verify(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([new SingleFieldValueHolder('why')]),
+        ),
+      ).once();
+      verify(cacheAdapterMock.cacheManyAsync(new SingleFieldHolder('id'), anything())).never();
+      verify(cacheAdapterMock.cacheDBMissesAsync(new SingleFieldHolder('id'), anything())).never();
+      expect(result).toEqual(new SingleFieldValueHolderMap(new Map()));
     });
 
     it('does a mix and match of hit, miss, and negative', async () => {
-      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createIdFetcher(['wat', 'who', 'why']);
 
       when(
-        cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how'])),
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([
+            new SingleFieldValueHolder('wat'),
+            new SingleFieldValueHolder('who'),
+            new SingleFieldValueHolder('why'),
+            new SingleFieldValueHolder('how'),
+          ]),
+        ),
       ).thenResolve(
-        new Map([
-          ['wat', { status: CacheStatus.MISS }],
-          ['who', { status: CacheStatus.NEGATIVE }],
-          ['why', { status: CacheStatus.HIT, item: { id: 'why' } }],
-          ['how', { status: CacheStatus.MISS }],
-        ]),
+        new SingleFieldValueHolderMap(
+          new Map([
+            [new SingleFieldValueHolder('wat'), { status: CacheStatus.MISS }],
+            [new SingleFieldValueHolder('who'), { status: CacheStatus.NEGATIVE }],
+            [new SingleFieldValueHolder('why'), { status: CacheStatus.HIT, item: { id: 'why' } }],
+            [new SingleFieldValueHolder('how'), { status: CacheStatus.MISS }],
+          ]),
+        ),
       );
 
       const result = await entityCache.readManyThroughAsync(
-        'id',
-        ['wat', 'who', 'why', 'how'],
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder<BlahFields, 'id'>('wat'),
+          new SingleFieldValueHolder<BlahFields, 'id'>('who'),
+          new SingleFieldValueHolder<BlahFields, 'id'>('why'),
+          new SingleFieldValueHolder<BlahFields, 'id'>('how'),
+        ],
         fetcher,
       );
-      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how']))).once();
       verify(
-        cacheAdapterMock.cacheManyAsync('id', deepEqual(new Map([['wat', { id: 'wat' }]]))),
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([
+            new SingleFieldValueHolder('wat'),
+            new SingleFieldValueHolder('who'),
+            new SingleFieldValueHolder('why'),
+            new SingleFieldValueHolder('how'),
+          ]),
+        ),
       ).once();
-      verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual(['how']))).once();
-      expect(result).toEqual(
-        new Map([
-          ['wat', [{ id: 'wat' }]],
-          ['why', [{ id: 'why' }]],
-        ]),
-      );
+      verify(
+        cacheAdapterMock.cacheManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(
+            new SingleFieldValueHolderMap(
+              new Map([[new SingleFieldValueHolder('wat'), { id: 'wat' }]]),
+            ),
+          ),
+        ),
+      ).once();
+      verify(
+        cacheAdapterMock.cacheDBMissesAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([new SingleFieldValueHolder('how')]),
+        ),
+      ).once();
+      expect(
+        isEqualWithEntityAware(
+          result,
+          new SingleFieldValueHolderMap(
+            new Map([
+              [new SingleFieldValueHolder('wat'), [{ id: 'wat' }]],
+              [new SingleFieldValueHolder('why'), [{ id: 'why' }]],
+            ]),
+          ),
+        ),
+      ).toBe(true);
     });
 
     it('does not call into cache for field that is not cacheable', async () => {
-      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(false), cacheAdapter);
       const fetcher = createIdFetcher(['wat']);
-      const result = await entityCache.readManyThroughAsync('id', ['wat'], fetcher);
-      verify(cacheAdapterMock.loadManyAsync('id', anything())).never();
-      expect(result).toEqual(new Map([['wat', [{ id: 'wat' }]]]));
+      const result = await entityCache.readManyThroughAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [new SingleFieldValueHolder<BlahFields, 'id'>('wat')],
+        fetcher,
+      );
+      verify(cacheAdapterMock.loadManyAsync(new SingleFieldHolder('id'), anything())).never();
+      expect(result).toEqual(
+        new SingleFieldValueHolderMap(
+          new Map([[new SingleFieldValueHolder('wat'), [{ id: 'wat' }]]]),
+        ),
+      );
     });
 
     it('does not cache when DB returns multiple objects for what is supposed to be unique and returns empty', async () => {
       const consoleSpy = jest.spyOn(console, 'warn');
 
-      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createFetcherNonUnique(['wat', 'who']);
 
-      when(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).thenResolve(
-        new Map([
-          ['wat', { status: CacheStatus.MISS }],
-          ['who', { status: CacheStatus.MISS }],
-        ]),
+      when(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([
+            new SingleFieldValueHolder('wat'),
+            new SingleFieldValueHolder('who'),
+          ]),
+        ),
+      ).thenResolve(
+        new SingleFieldValueHolderMap(
+          new Map([
+            [new SingleFieldValueHolder('wat'), { status: CacheStatus.MISS }],
+            [new SingleFieldValueHolder('who'), { status: CacheStatus.MISS }],
+          ]),
+        ),
       );
 
-      const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
+      const result = await entityCache.readManyThroughAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder<BlahFields, 'id'>('wat'),
+          new SingleFieldValueHolder<BlahFields, 'id'>('who'),
+        ],
+        fetcher,
+      );
 
-      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).once();
+      verify(
+        cacheAdapterMock.loadManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([
+            new SingleFieldValueHolder('wat'),
+            new SingleFieldValueHolder('who'),
+          ]),
+        ),
+      ).once();
       verify(
         cacheAdapterMock.cacheManyAsync(
-          'id',
-          deepEqual(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(
             new Map([
-              ['wat', { id: 'wat' }],
-              ['who', { id: 'who' }],
+              [new SingleFieldValueHolder('wat'), { id: 'wat' }],
+              [new SingleFieldValueHolder('who'), { id: 'who' }],
             ]),
           ),
         ),
       ).never();
-      verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).once();
-      expect(result).toEqual(new Map());
+      verify(
+        cacheAdapterMock.cacheDBMissesAsync(
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
+          deepEqualEntityAware([] as SingleFieldValueHolder<BlahFields, 'id'>[]),
+        ),
+      ).once();
+      expect(result).toEqual(new SingleFieldValueHolderMap(new Map()));
 
       expect(consoleSpy).toHaveBeenCalledWith(
-        'unique key id in blah returned multiple rows for wat',
+        'unique key SingleField(id) in table blah returned multiple rows for SingleFieldValue(wat)',
       );
       expect(consoleSpy).toHaveBeenCalledWith(
-        'unique key id in blah returned multiple rows for who',
+        'unique key SingleField(id) in table blah returned multiple rows for SingleFieldValue(who)',
       );
     });
   });
 
   describe('invalidateManyAsync', () => {
     it('calls cache adapter invalidate', async () => {
-      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields, 'id'>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
-      await entityCache.invalidateManyAsync('id', ['wat']);
-      verify(cacheAdapterMock.invalidateManyAsync('id', deepEqual(['wat']))).once();
+      await entityCache.invalidateManyAsync(new SingleFieldHolder('id'), [
+        new SingleFieldValueHolder('wat'),
+      ]);
+      verify(
+        cacheAdapterMock.invalidateManyAsync(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware([new SingleFieldValueHolder('wat')]),
+        ),
+      ).once();
     });
   });
 });

package/src/metrics/EntityMetricsUtils.ts

@@ -2,6 +2,7 @@ import IEntityMetricsAdapter, {
   EntityMetricsLoadType,
   EntityMetricsMutationType,
 } from './IEntityMetricsAdapter';
+import { IEntityLoadValue } from '../internal/EntityLoadInterfaces';
 import { reduceMap } from '../utils/collections/maps';
 
 export const timeAndLogLoadEventAsync =
@@ -31,8 +32,12 @@ export const timeAndLogLoadMapEventAsync =
     loadType: EntityMetricsLoadType,
     entityClassName: string,
   ) =>
-  async <TFields, N extends keyof TFields>(
-    promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>,
+  async <
+    TFields extends Record<string, any>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    promise: Promise<ReadonlyMap<TLoadValue, readonly Readonly<TFields>[]>>,
   ) => {
     const startTime = Date.now();
     const result = await promise;

package/src/metrics/IEntityMetricsAdapter.ts

@@ -2,6 +2,7 @@ import {
   EntityAuthorizationAction,
   EntityPrivacyPolicyEvaluationMode,
 } from '../EntityPrivacyPolicy';
+import { EntityLoadMethodType } from '../internal/EntityLoadInterfaces';
 
 export enum EntityMetricsLoadType {
   LOAD_MANY,
@@ -84,6 +85,11 @@ export interface IncrementLoadCountEvent {
    */
   type: IncrementLoadCountEventType;
 
+  /**
+   * Load method type for this event.
+   */
+  loadType: EntityLoadMethodType;
+
   /**
    * Number of field values being loaded for this call.
    */

package/src/rules/AlwaysAllowPrivacyPolicyRule.ts

@@ -8,18 +8,18 @@ import ViewerContext from '../ViewerContext';
  * Privacy policy rule that always allows.
  */
 export default class AlwaysAllowPrivacyPolicyRule<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
-> extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+> extends PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
     _evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields

package/src/rules/AlwaysDenyPrivacyPolicyRule.ts

@@ -8,18 +8,18 @@ import ViewerContext from '../ViewerContext';
  * Privacy policy rule that always denies.
  */
 export default class AlwaysDenyPrivacyPolicyRule<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
-> extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+> extends PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
     _evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields