@expo/entity 0.41.0 → 0.43.0

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

@@ -17,15 +17,21 @@ import IEntityMetricsAdapter, {
   IncrementLoadCountEventType,
 } from '../../metrics/IEntityMetricsAdapter';
 import NoOpEntityMetricsAdapter from '../../metrics/NoOpEntityMetricsAdapter';
-import TestEntity, { testEntityConfiguration, TestFields } from '../../testfixtures/TestEntity';
 import {
   NoCacheStubCacheAdapterProvider,
   InMemoryFullCacheStubCacheAdapterProvider,
-} from '../../utils/testing/StubCacheAdapter';
-import StubDatabaseAdapter from '../../utils/testing/StubDatabaseAdapter';
-import StubQueryContextProvider from '../../utils/testing/StubQueryContextProvider';
+} from '../../utils/__testfixtures__/StubCacheAdapter';
+import StubDatabaseAdapter from '../../utils/__testfixtures__/StubDatabaseAdapter';
+import StubQueryContextProvider from '../../utils/__testfixtures__/StubQueryContextProvider';
+import TestEntity, {
+  testEntityConfiguration,
+  TestFields,
+} from '../../utils/__testfixtures__/TestEntity';
+import { CompositeFieldHolder, CompositeFieldValueHolder } from '../CompositeFieldHolder';
 import EntityDataManager from '../EntityDataManager';
+import { EntityLoadMethodType } from '../EntityLoadInterfaces';
 import ReadThroughEntityCache from '../ReadThroughEntityCache';
+import { SingleFieldHolder, SingleFieldValueHolder } from '../SingleFieldHolder';
 
 const getObjects = (): Map<string, TestFields[]> =>
   new Map([
@@ -67,7 +73,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -83,25 +92,25 @@ describe(EntityDataManager, () => {
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
-    const entityDatas = await entityDataManager.loadManyByFieldEqualingAsync(
+    const entityDatas = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      'customIdField',
-      ['2'],
+      new SingleFieldHolder('customIdField'),
+      [new SingleFieldValueHolder('2')],
     );
-    expect(entityDatas.get('2')).toHaveLength(1);
+    expect(entityDatas.get(new SingleFieldValueHolder('2'))).toHaveLength(1);
 
     expect(dbSpy).toHaveBeenCalled();
     expect(cacheSpy).toHaveBeenCalled();
     dbSpy.mockClear();
     cacheSpy.mockClear();
 
-    const entityDatas2 = await entityDataManager.loadManyByFieldEqualingAsync(
+    const entityDatas2 = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      'testIndexedField',
-      ['unique2', 'unique3'],
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique2'), new SingleFieldValueHolder('unique3')],
     );
-    expect(entityDatas2.get('unique2')).toHaveLength(1);
-    expect(entityDatas2.get('unique3')).toHaveLength(1);
+    expect(entityDatas2.get(new SingleFieldValueHolder('unique2'))).toHaveLength(1);
+    expect(entityDatas2.get(new SingleFieldValueHolder('unique3'))).toHaveLength(1);
 
     expect(dbSpy).toHaveBeenCalled();
     expect(cacheSpy).toHaveBeenCalled();
@@ -115,7 +124,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -131,25 +143,25 @@ describe(EntityDataManager, () => {
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
-    const entityDatas = await entityDataManager.loadManyByFieldEqualingAsync(
+    const entityDatas = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      'customIdField',
-      ['1'],
+      new SingleFieldHolder('customIdField'),
+      [new SingleFieldValueHolder('1')],
     );
-    expect(entityDatas.get('1')).toHaveLength(1);
+    expect(entityDatas.get(new SingleFieldValueHolder('1'))).toHaveLength(1);
 
     expect(dbSpy).toHaveBeenCalled();
     expect(cacheSpy).toHaveBeenCalled();
     dbSpy.mockClear();
     cacheSpy.mockClear();
 
-    const entityDatas2 = await entityDataManager.loadManyByFieldEqualingAsync(
+    const entityDatas2 = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      'testIndexedField',
-      ['unique2', 'unique3'],
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique2'), new SingleFieldValueHolder('unique3')],
     );
-    expect(entityDatas2.get('unique2')).toHaveLength(1);
-    expect(entityDatas2.get('unique3')).toHaveLength(1);
+    expect(entityDatas2.get(new SingleFieldValueHolder('unique2'))).toHaveLength(1);
+    expect(entityDatas2.get(new SingleFieldValueHolder('unique3'))).toHaveLength(1);
 
     expect(dbSpy).toHaveBeenCalled();
     expect(cacheSpy).toHaveBeenCalled();
@@ -163,7 +175,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -187,12 +202,16 @@ describe(EntityDataManager, () => {
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
-    await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      'unique2',
-    ]);
-    await entityDataManager2.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      'unique2',
-    ]);
+    await entityDataManager.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique2')],
+    );
+    await entityDataManager2.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique2')],
+    );
 
     expect(dbSpy).toHaveBeenCalledTimes(1);
     expect(cacheSpy).toHaveBeenCalledTimes(2);
@@ -207,7 +226,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -223,12 +245,16 @@ describe(EntityDataManager, () => {
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
-    await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      'unique2',
-    ]);
-    await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      'unique2',
-    ]);
+    await entityDataManager.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique2')],
+    );
+    await entityDataManager.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique2')],
+    );
 
     expect(dbSpy).toHaveBeenCalledTimes(1);
     expect(cacheSpy).toHaveBeenCalledTimes(1);
@@ -243,7 +269,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -259,23 +288,23 @@ describe(EntityDataManager, () => {
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
-    const entityData = await entityDataManager.loadManyByFieldEqualingAsync(
+    const entityData = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      'stringField',
-      ['hello', 'world'],
+      new SingleFieldHolder('stringField'),
+      [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
     );
-    const entityData2 = await entityDataManager.loadManyByFieldEqualingAsync(
+    const entityData2 = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      'stringField',
-      ['hello', 'world'],
+      new SingleFieldHolder('stringField'),
+      [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
     );
 
     expect(dbSpy).toHaveBeenCalledTimes(1);
     expect(cacheSpy).toHaveBeenCalledTimes(1);
 
     expect(entityData).toMatchObject(entityData2);
-    expect(entityData.get('hello')).toHaveLength(2);
-    expect(entityData.get('world')).toHaveLength(1);
+    expect(entityData.get(new SingleFieldValueHolder('hello'))).toHaveLength(2);
+    expect(entityData.get(new SingleFieldValueHolder('world'))).toHaveLength(1);
 
     dbSpy.mockReset();
     cacheSpy.mockReset();
@@ -287,7 +316,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -305,13 +337,22 @@ describe(EntityDataManager, () => {
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
-    await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField'],
-    ]);
-    await entityDataManager.invalidateObjectFieldsAsync(objectInQuestion);
-    await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField'],
+    await entityDataManager.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
+    );
+    await entityDataManager.invalidateKeyValuePairsAsync([
+      [
+        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldValueHolder(objectInQuestion['testIndexedField']),
+      ],
     ]);
+    await entityDataManager.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
+    );
 
     expect(dbSpy).toHaveBeenCalledTimes(2);
     expect(cacheSpy).toHaveBeenCalledTimes(2);
@@ -326,7 +367,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -344,13 +388,22 @@ describe(EntityDataManager, () => {
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
-    await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField'],
-    ]);
-    await entityDataManager.invalidateObjectFieldsAsync(objectInQuestion);
-    await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', [
-      objectInQuestion['customIdField'],
+    await entityDataManager.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
+    );
+    await entityDataManager.invalidateKeyValuePairsAsync([
+      [
+        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldValueHolder(objectInQuestion['testIndexedField']),
+      ],
     ]);
+    await entityDataManager.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('customIdField'),
+      [new SingleFieldValueHolder(objectInQuestion['customIdField'])],
+    );
 
     expect(dbSpy).toHaveBeenCalledTimes(2);
     expect(cacheSpy).toHaveBeenCalledTimes(2);
@@ -365,7 +418,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -382,14 +438,16 @@ describe(EntityDataManager, () => {
 
     const entityDatas = await new StubQueryContextProvider().runInTransactionAsync(
       async (queryContext) => {
-        return await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', [
-          '1',
-        ]);
+        return await entityDataManager.loadManyEqualingAsync(
+          queryContext,
+          new SingleFieldHolder('customIdField'),
+          [new SingleFieldValueHolder('1')],
+        );
       },
       {},
     );
 
-    expect(entityDatas.get('1')).toHaveLength(1);
+    expect(entityDatas.get(new SingleFieldValueHolder('1'))).toHaveLength(1);
 
     expect(dbSpy).toHaveBeenCalled();
     expect(cacheSpy).not.toHaveBeenCalled();
@@ -404,7 +462,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -445,7 +506,7 @@ describe(EntityDataManager, () => {
   });
 
   it('handles DB errors as expected', async () => {
-    const databaseAdapterMock = mock<EntityDatabaseAdapter<TestFields>>();
+    const databaseAdapterMock = mock<EntityDatabaseAdapter<TestFields, 'customIdField'>>();
     when(databaseAdapterMock.fetchManyWhereAsync(anything(), anything(), anything())).thenReject(
       new Error('DB query failed'),
     );
@@ -464,7 +525,11 @@ describe(EntityDataManager, () => {
     const queryContext = new StubQueryContextProvider().getQueryContext();
 
     await expect(
-      entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', ['2']),
+      entityDataManager.loadManyEqualingAsync(
+        queryContext,
+        new SingleFieldHolder('customIdField'),
+        [new SingleFieldValueHolder('2')],
+      ),
     ).rejects.toThrow();
   });
 
@@ -477,7 +542,10 @@ describe(EntityDataManager, () => {
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -490,7 +558,13 @@ describe(EntityDataManager, () => {
     );
     const queryContext = new StubQueryContextProvider().getQueryContext();
 
-    await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', ['1']);
+    // make call to loadManyByFieldEqualingAsync to populate cache and dataloader, ensure metrics are recorded
+    // for dataloader, cache, and database
+    await entityDataManager.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique1')],
+    );
     verify(
       metricsAdapterMock.logDataManagerLoadEvent(
         objectContaining({
@@ -500,33 +574,84 @@ describe(EntityDataManager, () => {
         }),
       ),
     ).once();
+    verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).thrice();
+    verify(
+      metricsAdapterMock.incrementDataManagerLoadCount(
+        deepEqual({
+          type: IncrementLoadCountEventType.DATALOADER,
+          fieldValueCount: 1,
+          entityClassName: TestEntity.name,
+          loadType: EntityLoadMethodType.SINGLE,
+        }),
+      ),
+    ).once();
+    verify(
+      metricsAdapterMock.incrementDataManagerLoadCount(
+        deepEqual({
+          type: IncrementLoadCountEventType.CACHE,
+          fieldValueCount: 1,
+          entityClassName: TestEntity.name,
+          loadType: EntityLoadMethodType.SINGLE,
+        }),
+      ),
+    ).once();
+    verify(
+      metricsAdapterMock.incrementDataManagerLoadCount(
+        deepEqual({
+          type: IncrementLoadCountEventType.DATABASE,
+          fieldValueCount: 1,
+          entityClassName: TestEntity.name,
+          loadType: EntityLoadMethodType.SINGLE,
+        }),
+      ),
+    ).once();
 
-    await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
+    resetCalls(metricsAdapterMock);
+
+    // make second call to loadManyByFieldEqualingAsync, ensure metrics are only recorded for dataloader since
+    // entity is in local dataloader
+    await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      [
-        {
-          fieldName: 'customIdField',
-          fieldValue: '1',
-        },
-      ],
-      {},
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique1')],
     );
+    verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).once();
     verify(
-      metricsAdapterMock.logDataManagerLoadEvent(
-        objectContaining({
-          type: EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
+      metricsAdapterMock.incrementDataManagerLoadCount(
+        deepEqual({
+          type: IncrementLoadCountEventType.DATALOADER,
+          fieldValueCount: 1,
           entityClassName: TestEntity.name,
-          count: 1,
+          loadType: EntityLoadMethodType.SINGLE,
         }),
       ),
     ).once();
 
+    resetCalls(metricsAdapterMock);
+
+    // make third call in new data manager but query two keys, ensure only one of the keys is fetched
+    // from the database and the other is fetched from the cache
+    const entityCache2 = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const entityDataManager2 = new EntityDataManager(
+      databaseAdapter,
+      entityCache2,
+      new StubQueryContextProvider(),
+      metricsAdapter,
+      TestEntity.name,
+    );
+    await entityDataManager2.loadManyEqualingAsync(
+      queryContext,
+      new SingleFieldHolder('testIndexedField'),
+      [new SingleFieldValueHolder('unique1'), new SingleFieldValueHolder('unique2')],
+    );
+    verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).thrice();
     verify(
       metricsAdapterMock.incrementDataManagerLoadCount(
         deepEqual({
           type: IncrementLoadCountEventType.DATALOADER,
-          fieldValueCount: 1,
+          fieldValueCount: 2,
           entityClassName: TestEntity.name,
+          loadType: EntityLoadMethodType.SINGLE,
         }),
       ),
     ).once();
@@ -534,8 +659,9 @@ describe(EntityDataManager, () => {
       metricsAdapterMock.incrementDataManagerLoadCount(
         deepEqual({
           type: IncrementLoadCountEventType.CACHE,
-          fieldValueCount: 1,
+          fieldValueCount: 2,
           entityClassName: TestEntity.name,
+          loadType: EntityLoadMethodType.SINGLE,
         }),
       ),
     ).once();
@@ -545,6 +671,29 @@ describe(EntityDataManager, () => {
           type: IncrementLoadCountEventType.DATABASE,
           fieldValueCount: 1,
           entityClassName: TestEntity.name,
+          loadType: EntityLoadMethodType.SINGLE,
+        }),
+      ),
+    ).once();
+
+    resetCalls(metricsAdapterMock);
+
+    await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
+      queryContext,
+      [
+        {
+          fieldName: 'testIndexedField',
+          fieldValue: 'unique1',
+        },
+      ],
+      {},
+    );
+    verify(
+      metricsAdapterMock.logDataManagerLoadEvent(
+        objectContaining({
+          type: EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
+          entityClassName: TestEntity.name,
+          count: 1,
         }),
       ),
     ).once();
@@ -574,13 +723,16 @@ describe(EntityDataManager, () => {
     verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
   });
 
-  it('throws when a load-by value is null or undefined', async () => {
+  it('throws when a single value load-by value is null or undefined', async () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
       objects,
     );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(testEntityConfiguration, dataStore);
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
     const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
     const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -594,13 +746,78 @@ describe(EntityDataManager, () => {
     const queryContext = new StubQueryContextProvider().getQueryContext();
 
     await expect(
-      entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'nullableField', [null as any]),
+      entityDataManager.loadManyEqualingAsync(
+        queryContext,
+        new SingleFieldHolder('nullableField'),
+        [new SingleFieldValueHolder(null as any)],
+      ),
     ).rejects.toThrowError('Invalid load: TestEntity (nullableField = null)');
 
     await expect(
-      entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'nullableField', [
-        undefined as any,
-      ]),
+      entityDataManager.loadManyEqualingAsync(
+        queryContext,
+        new SingleFieldHolder('nullableField'),
+        [new SingleFieldValueHolder(undefined as any)],
+      ),
     ).rejects.toThrowError('Invalid load: TestEntity (nullableField = undefined)');
   });
+
+  it('throws when a composite value load-by value is null or undefined', async () => {
+    const objects = getObjects();
+    const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
+      testEntityConfiguration,
+      objects,
+    );
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
+    const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const entityDataManager = new EntityDataManager(
+      databaseAdapter,
+      entityCache,
+      new StubQueryContextProvider(),
+      new NoOpEntityMetricsAdapter(),
+      TestEntity.name,
+    );
+    const queryContext = new StubQueryContextProvider().getQueryContext();
+
+    await expect(
+      entityDataManager.loadManyEqualingAsync(
+        queryContext,
+        new CompositeFieldHolder<TestFields, 'customIdField'>([
+          'nullableField',
+          'testIndexedField',
+        ]),
+        [
+          new CompositeFieldValueHolder({
+            nullableField: null as any,
+            testIndexedField: 'unique1',
+          }),
+        ],
+      ),
+    ).rejects.toThrowError(
+      'Invalid load: TestEntity (nullableField,testIndexedField = CompositeFieldValue(nullableField=null,testIndexedField=unique1))',
+    );
+
+    await expect(
+      entityDataManager.loadManyEqualingAsync(
+        queryContext,
+        new CompositeFieldHolder<TestFields, 'customIdField'>([
+          'nullableField',
+          'testIndexedField',
+        ]),
+        [
+          new CompositeFieldValueHolder({
+            nullableField: undefined as any,
+            testIndexedField: 'unique1',
+          }),
+        ],
+      ),
+    ).rejects.toThrowError(
+      'Invalid load: TestEntity (nullableField,testIndexedField = CompositeFieldValue(nullableField=undefined,testIndexedField=unique1))',
+    );
+  });
 });

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

@@ -1,5 +1,5 @@
 import EntityConfiguration from '../../EntityConfiguration';
-import { UUIDField, StringField } from '../../EntityFields';
+import { StringField, UUIDField } from '../../EntityFields';
 import {
   getDatabaseFieldForEntityField,
   transformDatabaseObjectToFields,
@@ -16,12 +16,13 @@ type BlahT = {
   transformWrite: string;
 };
 
-const blahEntityConfiguration = new EntityConfiguration<BlahT>({
+const blahEntityConfiguration = new EntityConfiguration<BlahT, 'id'>({
   idField: 'id',
   tableName: 'blah_table',
   schema: {
     id: new UUIDField({
       columnName: 'id',
+      cache: false,
     }),
     cacheable: new StringField({
       columnName: 'cacheable',