@expo/entity 0.42.0 → 0.44.0

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

@@ -4,14 +4,15 @@ import {
   when,
   anything,
   verify,
-  objectContaining,
   spy,
   anyString,
   resetCalls,
   deepEqual,
+  anyNumber,
 } from 'ts-mockito';
 
 import EntityDatabaseAdapter from '../../EntityDatabaseAdapter';
+import { TransactionalDataLoaderMode } from '../../EntityQueryContext';
 import IEntityMetricsAdapter, {
   EntityMetricsLoadType,
   IncrementLoadCountEventType,
@@ -310,6 +311,237 @@ describe(EntityDataManager, () => {
     cacheSpy.mockReset();
   });
 
+  it('loads and in-memory batches (dataloader) loads in transaction when enabled with TransactionalDataLoaderMode.ENABLED_BATCH_ONLY and does not read from cache for transactions and nested transactions', async () => {
+    const objects = getObjects();
+    const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
+      testEntityConfiguration,
+      objects,
+    );
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
+    const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const entityDataManager = new EntityDataManager(
+      databaseAdapter,
+      entityCache,
+      new StubQueryContextProvider(),
+      new NoOpEntityMetricsAdapter(),
+      TestEntity.name,
+    );
+
+    const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+    const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
+
+    const [entityData, entityData2, entityData3, entityData4] =
+      await new StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+        const [entityData, entityData2] = await Promise.all([
+          entityDataManager.loadManyEqualingAsync(
+            queryContext,
+            new SingleFieldHolder('stringField'),
+            [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+          ),
+          entityDataManager.loadManyEqualingAsync(
+            queryContext,
+            new SingleFieldHolder('stringField'),
+            [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+          ),
+        ]);
+        const [entityData3, entityData4] = await queryContext.runInNestedTransactionAsync(
+          async (innerQueryContext) => {
+            const entityData3 = await entityDataManager.loadManyEqualingAsync(
+              innerQueryContext,
+              new SingleFieldHolder('stringField'),
+              [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+            );
+
+            const entityData4 = await queryContext.runInNestedTransactionAsync(
+              async (innerInnerQueryContext) => {
+                return await entityDataManager.loadManyEqualingAsync(
+                  innerInnerQueryContext,
+                  new SingleFieldHolder('stringField'),
+                  [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+                );
+              },
+            );
+
+            return [entityData3, entityData4];
+          },
+        );
+        return [entityData, entityData2, entityData3, entityData4];
+      });
+
+    // entityData, entityData3 (new nested transaction), and entityData4 (new nested transaction) loads should all need to call the database
+    // entityData and entityData2 should be batched to one db load call
+    expect(dbSpy).toHaveBeenCalledTimes(3);
+    expect(cacheSpy).toHaveBeenCalledTimes(0);
+
+    expect(entityData).toMatchObject(entityData2);
+    expect(entityData2).toMatchObject(entityData3);
+    expect(entityData3).toMatchObject(entityData4);
+    expect(entityData.get(new SingleFieldValueHolder('hello'))).toHaveLength(2);
+    expect(entityData.get(new SingleFieldValueHolder('world'))).toHaveLength(1);
+
+    dbSpy.mockReset();
+    cacheSpy.mockReset();
+  });
+
+  it('loads and in-memory caches (dataloader) loads in transaction when enabled with TransactionalDataLoaderMode.ENABLED and does not read from cache for transactions and nested transactions', async () => {
+    const objects = getObjects();
+    const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
+      testEntityConfiguration,
+      objects,
+    );
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
+    const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const entityDataManager = new EntityDataManager(
+      databaseAdapter,
+      entityCache,
+      new StubQueryContextProvider(),
+      new NoOpEntityMetricsAdapter(),
+      TestEntity.name,
+    );
+
+    const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+    const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
+
+    const [entityData, entityData2, entityData3, entityData4] =
+      await new StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+        const entityData = await entityDataManager.loadManyEqualingAsync(
+          queryContext,
+          new SingleFieldHolder('stringField'),
+          [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+        );
+        const entityData2 = await entityDataManager.loadManyEqualingAsync(
+          queryContext,
+          new SingleFieldHolder('stringField'),
+          [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+        );
+        const [entityData3, entityData4] = await queryContext.runInNestedTransactionAsync(
+          async (innerQueryContext) => {
+            const entityData3 = await entityDataManager.loadManyEqualingAsync(
+              innerQueryContext,
+              new SingleFieldHolder('stringField'),
+              [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+            );
+
+            const entityData4 = await queryContext.runInNestedTransactionAsync(
+              async (innerInnerQueryContext) => {
+                return await entityDataManager.loadManyEqualingAsync(
+                  innerInnerQueryContext,
+                  new SingleFieldHolder('stringField'),
+                  [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+                );
+              },
+            );
+
+            return [entityData3, entityData4];
+          },
+        );
+        return [entityData, entityData2, entityData3, entityData4];
+      });
+
+    // entityData, entityData3 (new nested transaction), and entityData4 (new nested transaction) loads should all need to call the database
+    // entityData2 load should be cached in the dataloader
+    expect(dbSpy).toHaveBeenCalledTimes(3);
+    expect(cacheSpy).toHaveBeenCalledTimes(0);
+
+    expect(entityData).toMatchObject(entityData2);
+    expect(entityData2).toMatchObject(entityData3);
+    expect(entityData3).toMatchObject(entityData4);
+    expect(entityData.get(new SingleFieldValueHolder('hello'))).toHaveLength(2);
+    expect(entityData.get(new SingleFieldValueHolder('world'))).toHaveLength(1);
+
+    dbSpy.mockReset();
+    cacheSpy.mockReset();
+  });
+
+  it('loads and does not in-memory cache (dataloader) loads in transaction when disabled', async () => {
+    const objects = getObjects();
+    const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
+      testEntityConfiguration,
+      objects,
+    );
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
+    const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const entityDataManager = new EntityDataManager(
+      databaseAdapter,
+      entityCache,
+      new StubQueryContextProvider(),
+      new NoOpEntityMetricsAdapter(),
+      TestEntity.name,
+    );
+
+    const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+    const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
+
+    const [entityData, entityData2, entityData3, entityData4] =
+      await new StubQueryContextProvider().runInTransactionAsync(
+        async (queryContext) => {
+          const entityData = await entityDataManager.loadManyEqualingAsync(
+            queryContext,
+            new SingleFieldHolder('stringField'),
+            [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+          );
+          const entityData2 = await entityDataManager.loadManyEqualingAsync(
+            queryContext,
+            new SingleFieldHolder('stringField'),
+            [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+          );
+          const [entityData3, entityData4] = await queryContext.runInNestedTransactionAsync(
+            async (innerQueryContext) => {
+              const entityData3 = await entityDataManager.loadManyEqualingAsync(
+                innerQueryContext,
+                new SingleFieldHolder('stringField'),
+                [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+              );
+
+              const entityData4 = await queryContext.runInNestedTransactionAsync(
+                async (innerInnerQueryContext) => {
+                  return await entityDataManager.loadManyEqualingAsync(
+                    innerInnerQueryContext,
+                    new SingleFieldHolder('stringField'),
+                    [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
+                  );
+                },
+              );
+
+              return [entityData3, entityData4];
+            },
+          );
+          return [entityData, entityData2, entityData3, entityData4];
+        },
+        {
+          transactionalDataLoaderMode: TransactionalDataLoaderMode.DISABLED,
+        },
+      );
+
+    // entityData, entityData2, entityData3 (new nested transaction), and entityData4 (new nested transaction) loads should all need to call the database
+    expect(dbSpy).toHaveBeenCalledTimes(4);
+    expect(cacheSpy).toHaveBeenCalledTimes(0);
+
+    expect(entityData).toMatchObject(entityData2);
+    expect(entityData2).toMatchObject(entityData3);
+    expect(entityData3).toMatchObject(entityData4);
+    expect(entityData.get(new SingleFieldValueHolder('hello'))).toHaveLength(2);
+    expect(entityData.get(new SingleFieldValueHolder('world'))).toHaveLength(1);
+
+    dbSpy.mockReset();
+    cacheSpy.mockReset();
+  });
+
   it('invalidates objects', async () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
@@ -412,7 +644,141 @@ describe(EntityDataManager, () => {
     cacheSpy.mockReset();
   });
 
-  it('loads only from DB when in transaction', async () => {
+  it('invalidates transactions and nested transactions correctly', async () => {
+    const objects = getObjects();
+    const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
+      testEntityConfiguration,
+      objects,
+    );
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
+    const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const entityDataManager = new EntityDataManager(
+      databaseAdapter,
+      entityCache,
+      new StubQueryContextProvider(),
+      new NoOpEntityMetricsAdapter(),
+      TestEntity.name,
+    );
+
+    await new StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+      const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1]!;
+
+      const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+      const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
+
+      await entityDataManager.loadManyEqualingAsync(
+        queryContext,
+        new SingleFieldHolder('testIndexedField'),
+        [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
+      );
+      entityDataManager.invalidateKeyValuePairsForTransaction(queryContext, [
+        [
+          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(0);
+
+      dbSpy.mockClear();
+      cacheSpy.mockClear();
+
+      await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+        await entityDataManager.loadManyEqualingAsync(
+          innerQueryContext,
+          new SingleFieldHolder('testIndexedField'),
+          [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
+        );
+        entityDataManager.invalidateKeyValuePairsForTransaction(innerQueryContext, [
+          [
+            new SingleFieldHolder('testIndexedField'),
+            new SingleFieldValueHolder(objectInQuestion['testIndexedField']),
+          ],
+        ]);
+        await entityDataManager.loadManyEqualingAsync(
+          innerQueryContext,
+          new SingleFieldHolder('testIndexedField'),
+          [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
+        );
+
+        expect(dbSpy).toHaveBeenCalledTimes(2);
+        expect(cacheSpy).toHaveBeenCalledTimes(0);
+
+        dbSpy.mockClear();
+        cacheSpy.mockClear();
+      });
+    });
+  });
+
+  it('does not use transactional dataloader when disabled', async () => {
+    const objects = getObjects();
+    const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
+      testEntityConfiguration,
+      objects,
+    );
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      dataStore,
+    );
+    const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const entityDataManager = new EntityDataManager(
+      databaseAdapter,
+      entityCache,
+      new StubQueryContextProvider(),
+      new NoOpEntityMetricsAdapter(),
+      TestEntity.name,
+    );
+
+    await new StubQueryContextProvider().runInTransactionAsync(
+      async (queryContext) => {
+        const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1]!;
+
+        const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
+
+        await entityDataManager.loadManyEqualingAsync(
+          queryContext,
+          new SingleFieldHolder('testIndexedField'),
+          [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
+        );
+        entityDataManager.invalidateKeyValuePairsForTransaction(queryContext, [
+          [
+            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(0);
+
+        dbSpy.mockClear();
+        cacheSpy.mockClear();
+      },
+      { transactionalDataLoaderMode: TransactionalDataLoaderMode.DISABLED },
+    );
+
+    expect(entityDataManager['transactionalDataLoaders'].size).toBe(0);
+  });
+
+  it('does not load from cache when in transaction', async () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
@@ -533,194 +899,350 @@ describe(EntityDataManager, () => {
     ).rejects.toThrow();
   });
 
-  it('records metrics appropriately', async () => {
-    const metricsAdapterMock = mock<IEntityMetricsAdapter>();
-    const metricsAdapter = instance(metricsAdapterMock);
-
-    const objects = getObjects();
-    const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
-      testEntityConfiguration,
-      objects,
-    );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
-      testEntityConfiguration,
-      dataStore,
-    );
-    const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
-    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
-    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
-    const entityDataManager = new EntityDataManager(
-      databaseAdapter,
-      entityCache,
-      new StubQueryContextProvider(),
-      metricsAdapter,
-      TestEntity.name,
-    );
-    const queryContext = new StubQueryContextProvider().getQueryContext();
-
-    // 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({
-          type: EntityMetricsLoadType.LOAD_MANY,
-          entityClassName: TestEntity.name,
-          count: 1,
-        }),
-      ),
-    ).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();
-
-    resetCalls(metricsAdapterMock);
-
-    // make second call to loadManyByFieldEqualingAsync, ensure metrics are only recorded for dataloader since
-    // entity is in local dataloader
-    await entityDataManager.loadManyEqualingAsync(
-      queryContext,
-      new SingleFieldHolder('testIndexedField'),
-      [new SingleFieldValueHolder('unique1')],
-    );
-    verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).once();
-    verify(
-      metricsAdapterMock.incrementDataManagerLoadCount(
-        deepEqual({
-          type: IncrementLoadCountEventType.DATALOADER,
-          fieldValueCount: 1,
-          entityClassName: TestEntity.name,
-          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: 2,
-          entityClassName: TestEntity.name,
-          loadType: EntityLoadMethodType.SINGLE,
-        }),
-      ),
-    ).once();
-    verify(
-      metricsAdapterMock.incrementDataManagerLoadCount(
-        deepEqual({
-          type: IncrementLoadCountEventType.CACHE,
-          fieldValueCount: 2,
-          entityClassName: TestEntity.name,
-          loadType: EntityLoadMethodType.SINGLE,
-        }),
-      ),
-    ).once();
-    verify(
-      metricsAdapterMock.incrementDataManagerLoadCount(
-        deepEqual({
-          type: IncrementLoadCountEventType.DATABASE,
-          fieldValueCount: 1,
-          entityClassName: TestEntity.name,
-          loadType: EntityLoadMethodType.SINGLE,
-        }),
-      ),
-    ).once();
-
-    resetCalls(metricsAdapterMock);
+  describe('metrics', () => {
+    it('records metrics appropriately outside of transactions', async () => {
+      const metricsAdapterMock = mock<IEntityMetricsAdapter>();
+      const metricsAdapter = instance(metricsAdapterMock);
+
+      const objects = getObjects();
+      const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
+        testEntityConfiguration,
+        objects,
+      );
+      const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+        testEntityConfiguration,
+        dataStore,
+      );
+      const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
+      const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+      const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+      const entityDataManager = new EntityDataManager(
+        databaseAdapter,
+        entityCache,
+        new StubQueryContextProvider(),
+        metricsAdapter,
+        TestEntity.name,
+      );
+      const queryContext = new StubQueryContextProvider().getQueryContext();
+
+      // 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(
+          deepEqual({
+            type: EntityMetricsLoadType.LOAD_MANY,
+            isInTransaction: false,
+            entityClassName: TestEntity.name,
+            duration: anyNumber(),
+            count: 1,
+          }),
+        ),
+      ).once();
+      verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).thrice();
+      verify(
+        metricsAdapterMock.incrementDataManagerLoadCount(
+          deepEqual({
+            type: IncrementLoadCountEventType.DATALOADER,
+            isInTransaction: false,
+            fieldValueCount: 1,
+            entityClassName: TestEntity.name,
+            loadType: EntityLoadMethodType.SINGLE,
+          }),
+        ),
+      ).once();
+      verify(
+        metricsAdapterMock.incrementDataManagerLoadCount(
+          deepEqual({
+            type: IncrementLoadCountEventType.CACHE,
+            isInTransaction: false,
+            fieldValueCount: 1,
+            entityClassName: TestEntity.name,
+            loadType: EntityLoadMethodType.SINGLE,
+          }),
+        ),
+      ).once();
+      verify(
+        metricsAdapterMock.incrementDataManagerLoadCount(
+          deepEqual({
+            type: IncrementLoadCountEventType.DATABASE,
+            isInTransaction: false,
+            fieldValueCount: 1,
+            entityClassName: TestEntity.name,
+            loadType: EntityLoadMethodType.SINGLE,
+          }),
+        ),
+      ).once();
 
-    await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
-      queryContext,
-      [
-        {
-          fieldName: 'testIndexedField',
-          fieldValue: 'unique1',
-        },
-      ],
-      {},
-    );
-    verify(
-      metricsAdapterMock.logDataManagerLoadEvent(
-        objectContaining({
-          type: EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
-          entityClassName: TestEntity.name,
-          count: 1,
-        }),
-      ),
-    ).once();
+      resetCalls(metricsAdapterMock);
 
-    resetCalls(metricsAdapterMock);
+      // make second call to loadManyByFieldEqualingAsync, ensure metrics are only recorded for dataloader since
+      // entity is in local dataloader
+      await entityDataManager.loadManyEqualingAsync(
+        queryContext,
+        new SingleFieldHolder('testIndexedField'),
+        [new SingleFieldValueHolder('unique1')],
+      );
+      verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).once();
+      verify(
+        metricsAdapterMock.incrementDataManagerLoadCount(
+          deepEqual({
+            type: IncrementLoadCountEventType.DATALOADER,
+            isInTransaction: false,
+            fieldValueCount: 1,
+            entityClassName: TestEntity.name,
+            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,
+            isInTransaction: false,
+            fieldValueCount: 2,
+            entityClassName: TestEntity.name,
+            loadType: EntityLoadMethodType.SINGLE,
+          }),
+        ),
+      ).once();
+      verify(
+        metricsAdapterMock.incrementDataManagerLoadCount(
+          deepEqual({
+            type: IncrementLoadCountEventType.CACHE,
+            isInTransaction: false,
+            fieldValueCount: 2,
+            entityClassName: TestEntity.name,
+            loadType: EntityLoadMethodType.SINGLE,
+          }),
+        ),
+      ).once();
+      verify(
+        metricsAdapterMock.incrementDataManagerLoadCount(
+          deepEqual({
+            type: IncrementLoadCountEventType.DATABASE,
+            isInTransaction: false,
+            fieldValueCount: 1,
+            entityClassName: TestEntity.name,
+            loadType: EntityLoadMethodType.SINGLE,
+          }),
+        ),
+      ).once();
 
-    const databaseAdapterSpy = spy(databaseAdapter);
-    when(
-      databaseAdapterSpy.fetchManyByRawWhereClauseAsync(
-        anything(),
-        anyString(),
-        anything(),
-        anything(),
-      ),
-    ).thenResolve([]);
-    await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
-    verify(
-      metricsAdapterMock.logDataManagerLoadEvent(
-        objectContaining({
-          type: EntityMetricsLoadType.LOAD_MANY_RAW,
-          entityClassName: TestEntity.name,
-          count: 0,
-        }),
-      ),
-    ).once();
+      resetCalls(metricsAdapterMock);
 
-    verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
+      await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
+        queryContext,
+        [
+          {
+            fieldName: 'testIndexedField',
+            fieldValue: 'unique1',
+          },
+        ],
+        {},
+      );
+      verify(
+        metricsAdapterMock.logDataManagerLoadEvent(
+          deepEqual({
+            type: EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
+            isInTransaction: false,
+            entityClassName: TestEntity.name,
+            duration: anyNumber(),
+            count: 1,
+          }),
+        ),
+      ).once();
+
+      resetCalls(metricsAdapterMock);
+
+      const databaseAdapterSpy = spy(databaseAdapter);
+      when(
+        databaseAdapterSpy.fetchManyByRawWhereClauseAsync(
+          anything(),
+          anyString(),
+          anything(),
+          anything(),
+        ),
+      ).thenResolve([]);
+      await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
+      verify(
+        metricsAdapterMock.logDataManagerLoadEvent(
+          deepEqual({
+            type: EntityMetricsLoadType.LOAD_MANY_RAW,
+            isInTransaction: false,
+            entityClassName: TestEntity.name,
+            duration: anyNumber(),
+            count: 0,
+          }),
+        ),
+      ).once();
+
+      verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
+    });
+
+    it('records metrics appropriately inside of transactions', async () => {
+      const metricsAdapterMock = mock<IEntityMetricsAdapter>();
+      const metricsAdapter = instance(metricsAdapterMock);
+
+      const objects = getObjects();
+      const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
+        testEntityConfiguration,
+        objects,
+      );
+      const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+        testEntityConfiguration,
+        dataStore,
+      );
+      const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
+      const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+      const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+      const entityDataManager = new EntityDataManager(
+        databaseAdapter,
+        entityCache,
+        new StubQueryContextProvider(),
+        metricsAdapter,
+        TestEntity.name,
+      );
+
+      await new StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+        // 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(
+            deepEqual({
+              type: EntityMetricsLoadType.LOAD_MANY,
+              isInTransaction: true,
+              entityClassName: TestEntity.name,
+              duration: anyNumber(),
+              count: 1,
+            }),
+          ),
+        ).once();
+        verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).twice();
+        verify(
+          metricsAdapterMock.incrementDataManagerLoadCount(
+            deepEqual({
+              type: IncrementLoadCountEventType.DATALOADER,
+              isInTransaction: true,
+              fieldValueCount: 1,
+              entityClassName: TestEntity.name,
+              loadType: EntityLoadMethodType.SINGLE,
+            }),
+          ),
+        ).once();
+        verify(
+          metricsAdapterMock.incrementDataManagerLoadCount(
+            deepEqual({
+              type: IncrementLoadCountEventType.DATABASE,
+              isInTransaction: true,
+              fieldValueCount: 1,
+              entityClassName: TestEntity.name,
+              loadType: EntityLoadMethodType.SINGLE,
+            }),
+          ),
+        ).once();
+
+        resetCalls(metricsAdapterMock);
+
+        // make second call to loadManyByFieldEqualingAsync, ensure metrics are only recorded for dataloader since
+        // entity is in local dataloader
+        await entityDataManager.loadManyEqualingAsync(
+          queryContext,
+          new SingleFieldHolder('testIndexedField'),
+          [new SingleFieldValueHolder('unique1')],
+        );
+        verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).once();
+        verify(
+          metricsAdapterMock.incrementDataManagerLoadCount(
+            deepEqual({
+              type: IncrementLoadCountEventType.DATALOADER,
+              isInTransaction: true,
+              fieldValueCount: 1,
+              entityClassName: TestEntity.name,
+              loadType: EntityLoadMethodType.SINGLE,
+            }),
+          ),
+        ).once();
+
+        resetCalls(metricsAdapterMock);
+
+        await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
+          queryContext,
+          [
+            {
+              fieldName: 'testIndexedField',
+              fieldValue: 'unique1',
+            },
+          ],
+          {},
+        );
+        verify(
+          metricsAdapterMock.logDataManagerLoadEvent(
+            deepEqual({
+              type: EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
+              isInTransaction: true,
+              entityClassName: TestEntity.name,
+              duration: anyNumber(),
+              count: 1,
+            }),
+          ),
+        ).once();
+
+        resetCalls(metricsAdapterMock);
+
+        const databaseAdapterSpy = spy(databaseAdapter);
+        when(
+          databaseAdapterSpy.fetchManyByRawWhereClauseAsync(
+            anything(),
+            anyString(),
+            anything(),
+            anything(),
+          ),
+        ).thenResolve([]);
+        await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
+        verify(
+          metricsAdapterMock.logDataManagerLoadEvent(
+            deepEqual({
+              type: EntityMetricsLoadType.LOAD_MANY_RAW,
+              isInTransaction: true,
+              entityClassName: TestEntity.name,
+              duration: anyNumber(),
+              count: 0,
+            }),
+          ),
+        ).once();
+
+        verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
+      });
+    });
   });
 
   it('throws when a single value load-by value is null or undefined', async () => {