@expo/entity 0.35.0 → 0.37.0

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

@@ -65,7 +65,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
@@ -76,7 +76,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
@@ -86,7 +86,7 @@ describe(EntityDataManager, () => {
     const entityDatas = await entityDataManager.loadManyByFieldEqualingAsync(
       queryContext,
       'customIdField',
-      ['2']
+      ['2'],
     );
     expect(entityDatas.get('2')).toHaveLength(1);
 
@@ -98,7 +98,7 @@ describe(EntityDataManager, () => {
     const entityDatas2 = await entityDataManager.loadManyByFieldEqualingAsync(
       queryContext,
       'testIndexedField',
-      ['unique2', 'unique3']
+      ['unique2', 'unique3'],
     );
     expect(entityDatas2.get('unique2')).toHaveLength(1);
     expect(entityDatas2.get('unique3')).toHaveLength(1);
@@ -113,7 +113,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -124,7 +124,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
@@ -134,7 +134,7 @@ describe(EntityDataManager, () => {
     const entityDatas = await entityDataManager.loadManyByFieldEqualingAsync(
       queryContext,
       'customIdField',
-      ['1']
+      ['1'],
     );
     expect(entityDatas.get('1')).toHaveLength(1);
 
@@ -146,7 +146,7 @@ describe(EntityDataManager, () => {
     const entityDatas2 = await entityDataManager.loadManyByFieldEqualingAsync(
       queryContext,
       'testIndexedField',
-      ['unique2', 'unique3']
+      ['unique2', 'unique3'],
     );
     expect(entityDatas2.get('unique2')).toHaveLength(1);
     expect(entityDatas2.get('unique3')).toHaveLength(1);
@@ -161,7 +161,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -172,7 +172,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
     // use second data manager to ensure that cache is hit instead of data loader
@@ -181,7 +181,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
@@ -205,7 +205,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -216,7 +216,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
@@ -241,7 +241,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -252,7 +252,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
@@ -262,12 +262,12 @@ describe(EntityDataManager, () => {
     const entityData = await entityDataManager.loadManyByFieldEqualingAsync(
       queryContext,
       'stringField',
-      ['hello', 'world']
+      ['hello', 'world'],
     );
     const entityData2 = await entityDataManager.loadManyByFieldEqualingAsync(
       queryContext,
       'stringField',
-      ['hello', 'world']
+      ['hello', 'world'],
     );
 
     expect(dbSpy).toHaveBeenCalledTimes(1);
@@ -285,7 +285,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -296,7 +296,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
@@ -324,7 +324,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -335,7 +335,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
@@ -363,7 +363,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -374,7 +374,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
@@ -386,7 +386,7 @@ describe(EntityDataManager, () => {
           '1',
         ]);
       },
-      {}
+      {},
     );
 
     expect(entityDatas.get('1')).toHaveLength(1);
@@ -402,7 +402,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -413,7 +413,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
@@ -432,7 +432,7 @@ describe(EntityDataManager, () => {
           fieldValue: 1,
         },
       ],
-      {}
+      {},
     );
 
     expect(entityDatas).toHaveLength(2);
@@ -447,7 +447,7 @@ describe(EntityDataManager, () => {
   it('handles DB errors as expected', async () => {
     const databaseAdapterMock = mock<EntityDatabaseAdapter<TestFields>>();
     when(databaseAdapterMock.fetchManyWhereAsync(anything(), anything(), anything())).thenReject(
-      new Error('DB query failed')
+      new Error('DB query failed'),
     );
 
     const databaseAdapter = instance(databaseAdapterMock);
@@ -459,12 +459,12 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
     await expect(
-      entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', ['2'])
+      entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', ['2']),
     ).rejects.toThrow();
   });
 
@@ -475,7 +475,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
@@ -486,7 +486,7 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       metricsAdapter,
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
@@ -497,8 +497,8 @@ describe(EntityDataManager, () => {
           type: EntityMetricsLoadType.LOAD_MANY,
           entityClassName: TestEntity.name,
           count: 1,
-        })
-      )
+        }),
+      ),
     ).once();
 
     await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
@@ -509,7 +509,7 @@ describe(EntityDataManager, () => {
           fieldValue: '1',
         },
       ],
-      {}
+      {},
     );
     verify(
       metricsAdapterMock.logDataManagerLoadEvent(
@@ -517,8 +517,8 @@ describe(EntityDataManager, () => {
           type: EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
           entityClassName: TestEntity.name,
           count: 1,
-        })
-      )
+        }),
+      ),
     ).once();
 
     verify(
@@ -527,8 +527,8 @@ describe(EntityDataManager, () => {
           type: IncrementLoadCountEventType.DATALOADER,
           fieldValueCount: 1,
           entityClassName: TestEntity.name,
-        })
-      )
+        }),
+      ),
     ).once();
     verify(
       metricsAdapterMock.incrementDataManagerLoadCount(
@@ -536,8 +536,8 @@ describe(EntityDataManager, () => {
           type: IncrementLoadCountEventType.CACHE,
           fieldValueCount: 1,
           entityClassName: TestEntity.name,
-        })
-      )
+        }),
+      ),
     ).once();
     verify(
       metricsAdapterMock.incrementDataManagerLoadCount(
@@ -545,8 +545,8 @@ describe(EntityDataManager, () => {
           type: IncrementLoadCountEventType.DATABASE,
           fieldValueCount: 1,
           entityClassName: TestEntity.name,
-        })
-      )
+        }),
+      ),
     ).once();
 
     resetCalls(metricsAdapterMock);
@@ -557,8 +557,8 @@ describe(EntityDataManager, () => {
         anything(),
         anyString(),
         anything(),
-        anything()
-      )
+        anything(),
+      ),
     ).thenResolve([]);
     await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
     verify(
@@ -567,8 +567,8 @@ describe(EntityDataManager, () => {
           type: EntityMetricsLoadType.LOAD_MANY_RAW,
           entityClassName: TestEntity.name,
           count: 0,
-        })
-      )
+        }),
+      ),
     ).once();
 
     verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
@@ -578,7 +578,7 @@ describe(EntityDataManager, () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
-      objects
+      objects,
     );
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
     const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
@@ -589,18 +589,18 @@ describe(EntityDataManager, () => {
       entityCache,
       StubQueryContextProvider,
       new NoOpEntityMetricsAdapter(),
-      TestEntity.name
+      TestEntity.name,
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
     await expect(
-      entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'nullableField', [null as any])
+      entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'nullableField', [null as any]),
     ).rejects.toThrowError('Invalid load: TestEntity (nullableField = null)');
 
     await expect(
       entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'nullableField', [
         undefined as any,
-      ])
+      ]),
     ).rejects.toThrowError('Invalid load: TestEntity (nullableField = undefined)');
   });
 });

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

@@ -44,10 +44,10 @@ const blahEntityConfiguration = new EntityConfiguration<BlahT>({
 describe(getDatabaseFieldForEntityField, () => {
   it('returns correct mapping', () => {
     expect(getDatabaseFieldForEntityField(blahEntityConfiguration, 'cacheable')).toEqual(
-      'cacheable'
+      'cacheable',
     );
     expect(
-      getDatabaseFieldForEntityField(blahEntityConfiguration, 'uniqueButNotCacheable')
+      getDatabaseFieldForEntityField(blahEntityConfiguration, 'uniqueButNotCacheable'),
     ).toEqual('unique_but_not_cacheable');
   });
 });
@@ -59,7 +59,7 @@ describe(transformDatabaseObjectToFields, () => {
         id: 'blah',
         unique_but_not_cacheable: 'wat',
         who: 'why',
-      })
+      }),
     ).toEqual({
       id: 'blah',
       uniqueButNotCacheable: 'wat',
@@ -79,7 +79,7 @@ describe(transformDatabaseObjectToFields, () => {
     expect(
       transformDatabaseObjectToFields(blahEntityConfiguration, fieldTransformMap, {
         transform_read: 'wat',
-      })
+      }),
     ).toEqual({
       transformRead: 'wat-read-transformed',
     });
@@ -93,7 +93,7 @@ describe(transformFieldsToDatabaseObject, () => {
         id: 'blah',
         cacheable: 'wat',
         uniqueButNotCacheable: 'wat',
-      })
+      }),
     ).toEqual({
       id: 'blah',
       cacheable: 'wat',
@@ -114,7 +114,7 @@ describe(transformFieldsToDatabaseObject, () => {
     expect(
       transformFieldsToDatabaseObject(blahEntityConfiguration, fieldTransformMap, {
         transformWrite: 'wat',
-      })
+      }),
     ).toEqual({
       transform_write: 'wat-write-transformed',
     });
@@ -122,7 +122,7 @@ describe(transformFieldsToDatabaseObject, () => {
 });
 
 describe(transformCacheObjectToFields, () => {
-  it('does field read transformation', () => {
+  it('does field read transformation, keeping unknown fields for cache version inconsistencies', () => {
     const fieldTransformMap = new Map([
       [
         StringField.name,
@@ -136,16 +136,18 @@ describe(transformCacheObjectToFields, () => {
       transformCacheObjectToFields(blahEntityConfiguration, fieldTransformMap, {
         id: 'hello',
         transformRead: 'wat',
-      })
+        unknownField: 'who',
+      }),
     ).toEqual({
       id: 'hello',
       transformRead: 'wat-read-transformed-cache',
+      unknownField: 'who',
     });
   });
 });
 
 describe(transformFieldsToCacheObject, () => {
-  it('does field write transformation', () => {
+  it('does field write transformation, keeping unknown fields at runtime for cache version inconsistencies', () => {
     const fieldTransformMap = new Map([
       [
         StringField.name,
@@ -159,10 +161,12 @@ describe(transformFieldsToCacheObject, () => {
       transformFieldsToCacheObject(blahEntityConfiguration, fieldTransformMap, {
         id: 'hello',
         transformWrite: 'wat',
-      })
+        unknownField: 'who',
+      } as any),
     ).toEqual({
       id: 'hello',
       transformWrite: 'wat-write-transformed-cache',
+      unknownField: 'who',
     });
   });
 });

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

@@ -23,7 +23,7 @@ const makeEntityConfiguration = (cacheIdField: boolean): EntityConfiguration<Bla
 const createIdFetcher =
   (ids: string[]) =>
   async <N extends keyof BlahFields>(
-    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[]
+    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
     const results = new Map();
     fetcherFieldValues.forEach((v) => {
@@ -36,6 +36,22 @@ const createIdFetcher =
     return results;
   };
 
+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.forEach((v) => {
+      if (ids.includes(v)) {
+        results.set(v, [{ id: v }, { id: v + '2' }]);
+      } else {
+        results.set(v, []);
+      }
+    });
+    return results;
+  };
+
 describe(ReadThroughEntityCache, () => {
   describe('readManyThroughAsync', () => {
     it('fetches from DB upon cache miss and caches the result', async () => {
@@ -48,7 +64,7 @@ describe(ReadThroughEntityCache, () => {
         new Map([
           ['wat', { status: CacheStatus.MISS }],
           ['who', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
@@ -61,16 +77,16 @@ describe(ReadThroughEntityCache, () => {
             new Map([
               ['wat', { id: 'wat' }],
               ['who', { id: 'who' }],
-            ])
-          )
-        )
+            ]),
+          ),
+        ),
       ).once();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).once();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['who', [{ id: 'who' }]],
-        ])
+        ]),
       );
     });
 
@@ -84,7 +100,7 @@ describe(ReadThroughEntityCache, () => {
         new Map([
           ['wat', { status: CacheStatus.HIT, item: { id: 'wat' } }],
           ['who', { status: CacheStatus.HIT, item: { id: 'who' } }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
@@ -97,16 +113,16 @@ describe(ReadThroughEntityCache, () => {
             new Map([
               ['wat', { id: 'wat' }],
               ['who', { id: 'who' }],
-            ])
-          )
-        )
+            ]),
+          ),
+        ),
       ).never();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).never();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['who', [{ id: 'who' }]],
-        ])
+        ]),
       );
     });
 
@@ -119,7 +135,7 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher(['wat', 'who']);
 
       when(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).thenResolve(
-        new Map([['why', { status: CacheStatus.MISS }]])
+        new Map([['why', { status: CacheStatus.MISS }]]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['why'], fetcher);
@@ -137,7 +153,7 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher([]);
 
       when(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).thenResolve(
-        new Map([['why', { status: CacheStatus.NEGATIVE }]])
+        new Map([['why', { status: CacheStatus.NEGATIVE }]]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['why'], fetcher);
@@ -154,31 +170,31 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher(['wat', 'who', 'why']);
 
       when(
-        cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how']))
+        cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how'])),
       ).thenResolve(
         new Map([
           ['wat', { status: CacheStatus.MISS }],
           ['who', { status: CacheStatus.NEGATIVE }],
           ['why', { status: CacheStatus.HIT, item: { id: 'why' } }],
           ['how', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync(
         'id',
         ['wat', 'who', 'why', 'how'],
-        fetcher
+        fetcher,
       );
       verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how']))).once();
       verify(
-        cacheAdapterMock.cacheManyAsync('id', deepEqual(new Map([['wat', { id: 'wat' }]])))
+        cacheAdapterMock.cacheManyAsync('id', deepEqual(new Map([['wat', { id: 'wat' }]]))),
       ).once();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual(['how']))).once();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['why', [{ id: 'why' }]],
-        ])
+        ]),
       );
     });
 
@@ -191,6 +207,46 @@ describe(ReadThroughEntityCache, () => {
       verify(cacheAdapterMock.loadManyAsync('id', anything())).never();
       expect(result).toEqual(new Map([['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 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 }],
+        ]),
+      );
+
+      const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
+
+      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).once();
+      verify(
+        cacheAdapterMock.cacheManyAsync(
+          'id',
+          deepEqual(
+            new Map([
+              ['wat', { id: 'wat' }],
+              ['who', { id: 'who' }],
+            ]),
+          ),
+        ),
+      ).never();
+      verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).once();
+      expect(result).toEqual(new Map());
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'unique key id in blah returned multiple rows for wat',
+      );
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'unique key id in blah returned multiple rows for who',
+      );
+    });
   });
 
   describe('invalidateManyAsync', () => {