@expo/entity 0.45.0 → 0.46.0

package/build/src/internal/__tests__/EntityDataManager-test.js

@@ -0,0 +1,666 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const ts_mockito_1 = require("ts-mockito");
+const EntityQueryContext_1 = require("../../EntityQueryContext");
+const IEntityMetricsAdapter_1 = require("../../metrics/IEntityMetricsAdapter");
+const NoOpEntityMetricsAdapter_1 = require("../../metrics/NoOpEntityMetricsAdapter");
+const StubCacheAdapter_1 = require("../../utils/__testfixtures__/StubCacheAdapter");
+const StubDatabaseAdapter_1 = require("../../utils/__testfixtures__/StubDatabaseAdapter");
+const StubQueryContextProvider_1 = require("../../utils/__testfixtures__/StubQueryContextProvider");
+const TestEntity_1 = require("../../utils/__testfixtures__/TestEntity");
+const CompositeFieldHolder_1 = require("../CompositeFieldHolder");
+const EntityDataManager_1 = require("../EntityDataManager");
+const EntityLoadInterfaces_1 = require("../EntityLoadInterfaces");
+const ReadThroughEntityCache_1 = require("../ReadThroughEntityCache");
+const SingleFieldHolder_1 = require("../SingleFieldHolder");
+const getObjects = () => new Map([
+    [
+        TestEntity_1.testEntityConfiguration.tableName,
+        [
+            {
+                customIdField: '1',
+                testIndexedField: 'unique1',
+                stringField: 'hello',
+                intField: 1,
+                dateField: new Date(),
+                nullableField: null,
+            },
+            {
+                customIdField: '2',
+                testIndexedField: 'unique2',
+                stringField: 'hello',
+                intField: 1,
+                dateField: new Date(),
+                nullableField: null,
+            },
+            {
+                customIdField: '3',
+                testIndexedField: 'unique3',
+                stringField: 'world',
+                intField: 1,
+                dateField: new Date(),
+                nullableField: null,
+            },
+        ],
+    ],
+]);
+(0, globals_1.describe)(EntityDataManager_1.EntityDataManager, () => {
+    (0, globals_1.it)('loads from db with a no-cache adapter', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.NoCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        const entityDatas = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('customIdField'), [new SingleFieldHolder_1.SingleFieldValueHolder('2')]);
+        (0, globals_1.expect)(entityDatas.get(new SingleFieldHolder_1.SingleFieldValueHolder('2'))).toHaveLength(1);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalled();
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalled();
+        dbSpy.mockClear();
+        cacheSpy.mockClear();
+        const entityDatas2 = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique2'), new SingleFieldHolder_1.SingleFieldValueHolder('unique3')]);
+        (0, globals_1.expect)(entityDatas2.get(new SingleFieldHolder_1.SingleFieldValueHolder('unique2'))).toHaveLength(1);
+        (0, globals_1.expect)(entityDatas2.get(new SingleFieldHolder_1.SingleFieldValueHolder('unique3'))).toHaveLength(1);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalled();
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalled();
+        dbSpy.mockClear();
+        cacheSpy.mockClear();
+    });
+    (0, globals_1.it)('loads from a caching adaptor', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        const entityDatas = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('customIdField'), [new SingleFieldHolder_1.SingleFieldValueHolder('1')]);
+        (0, globals_1.expect)(entityDatas.get(new SingleFieldHolder_1.SingleFieldValueHolder('1'))).toHaveLength(1);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalled();
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalled();
+        dbSpy.mockClear();
+        cacheSpy.mockClear();
+        const entityDatas2 = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique2'), new SingleFieldHolder_1.SingleFieldValueHolder('unique3')]);
+        (0, globals_1.expect)(entityDatas2.get(new SingleFieldHolder_1.SingleFieldValueHolder('unique2'))).toHaveLength(1);
+        (0, globals_1.expect)(entityDatas2.get(new SingleFieldHolder_1.SingleFieldValueHolder('unique3'))).toHaveLength(1);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalled();
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalled();
+        dbSpy.mockClear();
+        cacheSpy.mockClear();
+    });
+    (0, globals_1.it)('loads from a caching adapter with a cache hit', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        // use second data manager to ensure that cache is hit instead of data loader
+        const entityDataManager2 = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique2')]);
+        await entityDataManager2.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique2')]);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(1);
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(2);
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.it)('loads from data loader for same query', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique2')]);
+        await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique2')]);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(1);
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(1);
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.it)('loads and in-memory caches (dataloader) non-unique, non-cacheable loads', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        const entityData = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+        const entityData2 = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(1);
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(1);
+        (0, globals_1.expect)(entityData).toEqual(entityData2);
+        (0, globals_1.expect)(entityData.get(new SingleFieldHolder_1.SingleFieldValueHolder('hello'))).toHaveLength(2);
+        (0, globals_1.expect)(entityData.get(new SingleFieldHolder_1.SingleFieldValueHolder('world'))).toHaveLength(1);
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.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_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        const [entityData, entityData2, entityData3, entityData4] = await new StubQueryContextProvider_1.StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+            const [entityData, entityData2] = await Promise.all([
+                entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]),
+                entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]),
+            ]);
+            const [entityData3, entityData4] = await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+                const entityData3 = await entityDataManager.loadManyEqualingAsync(innerQueryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+                const entityData4 = await queryContext.runInNestedTransactionAsync(async (innerInnerQueryContext) => {
+                    return await entityDataManager.loadManyEqualingAsync(innerInnerQueryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.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
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(3);
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(0);
+        (0, globals_1.expect)(entityData).toEqual(entityData2);
+        (0, globals_1.expect)(entityData2).toEqual(entityData3);
+        (0, globals_1.expect)(entityData3).toEqual(entityData4);
+        (0, globals_1.expect)(entityData.get(new SingleFieldHolder_1.SingleFieldValueHolder('hello'))).toHaveLength(2);
+        (0, globals_1.expect)(entityData.get(new SingleFieldHolder_1.SingleFieldValueHolder('world'))).toHaveLength(1);
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.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_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        const [entityData, entityData2, entityData3, entityData4] = await new StubQueryContextProvider_1.StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+            const entityData = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+            const entityData2 = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+            const [entityData3, entityData4] = await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+                const entityData3 = await entityDataManager.loadManyEqualingAsync(innerQueryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+                const entityData4 = await queryContext.runInNestedTransactionAsync(async (innerInnerQueryContext) => {
+                    return await entityDataManager.loadManyEqualingAsync(innerInnerQueryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.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
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(3);
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(0);
+        (0, globals_1.expect)(entityData).toEqual(entityData2);
+        (0, globals_1.expect)(entityData2).toEqual(entityData3);
+        (0, globals_1.expect)(entityData3).toEqual(entityData4);
+        (0, globals_1.expect)(entityData.get(new SingleFieldHolder_1.SingleFieldValueHolder('hello'))).toHaveLength(2);
+        (0, globals_1.expect)(entityData.get(new SingleFieldHolder_1.SingleFieldValueHolder('world'))).toHaveLength(1);
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.it)('loads and does not in-memory cache (dataloader) loads in transaction when disabled', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        const [entityData, entityData2, entityData3, entityData4] = await new StubQueryContextProvider_1.StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+            const entityData = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+            const entityData2 = await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+            const [entityData3, entityData4] = await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+                const entityData3 = await entityDataManager.loadManyEqualingAsync(innerQueryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+                const entityData4 = await queryContext.runInNestedTransactionAsync(async (innerInnerQueryContext) => {
+                    return await entityDataManager.loadManyEqualingAsync(innerInnerQueryContext, new SingleFieldHolder_1.SingleFieldHolder('stringField'), [new SingleFieldHolder_1.SingleFieldValueHolder('hello'), new SingleFieldHolder_1.SingleFieldValueHolder('world')]);
+                });
+                return [entityData3, entityData4];
+            });
+            return [entityData, entityData2, entityData3, entityData4];
+        }, {
+            transactionalDataLoaderMode: EntityQueryContext_1.TransactionalDataLoaderMode.DISABLED,
+        });
+        // entityData, entityData2, entityData3 (new nested transaction), and entityData4 (new nested transaction) loads should all need to call the database
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(4);
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(0);
+        (0, globals_1.expect)(entityData).toEqual(entityData2);
+        (0, globals_1.expect)(entityData2).toEqual(entityData3);
+        (0, globals_1.expect)(entityData3).toEqual(entityData4);
+        (0, globals_1.expect)(entityData.get(new SingleFieldHolder_1.SingleFieldValueHolder('hello'))).toHaveLength(2);
+        (0, globals_1.expect)(entityData.get(new SingleFieldHolder_1.SingleFieldValueHolder('world'))).toHaveLength(1);
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.it)('invalidates objects', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const objectInQuestion = objects.get(TestEntity_1.testEntityConfiguration.tableName)[1];
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+        await entityDataManager.invalidateKeyValuePairsAsync([
+            [
+                new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'),
+                new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField']),
+            ],
+        ]);
+        await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(2);
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(2);
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.it)('invalidates all fields for an object', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const objectInQuestion = objects.get(TestEntity_1.testEntityConfiguration.tableName)[1];
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+        await entityDataManager.invalidateKeyValuePairsAsync([
+            [
+                new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'),
+                new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField']),
+            ],
+        ]);
+        await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('customIdField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['customIdField'])]);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(2);
+        (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(2);
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.it)('invalidates transactions and nested transactions correctly', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        await new StubQueryContextProvider_1.StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+            const objectInQuestion = objects.get(TestEntity_1.testEntityConfiguration.tableName)[1];
+            const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+            const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+            await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+            entityDataManager.invalidateKeyValuePairsForTransaction(queryContext, [
+                [
+                    new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'),
+                    new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField']),
+                ],
+            ]);
+            await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+            (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(2);
+            (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(0);
+            dbSpy.mockClear();
+            cacheSpy.mockClear();
+            await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+                await entityDataManager.loadManyEqualingAsync(innerQueryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+                entityDataManager.invalidateKeyValuePairsForTransaction(innerQueryContext, [
+                    [
+                        new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'),
+                        new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField']),
+                    ],
+                ]);
+                await entityDataManager.loadManyEqualingAsync(innerQueryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+                (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(2);
+                (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(0);
+                dbSpy.mockClear();
+                cacheSpy.mockClear();
+            });
+        });
+    });
+    (0, globals_1.it)('does not use transactional dataloader when disabled', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        await new StubQueryContextProvider_1.StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+            const objectInQuestion = objects.get(TestEntity_1.testEntityConfiguration.tableName)[1];
+            const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+            const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+            await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+            entityDataManager.invalidateKeyValuePairsForTransaction(queryContext, [
+                [
+                    new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'),
+                    new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField']),
+                ],
+            ]);
+            await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder(objectInQuestion['testIndexedField'])]);
+            (0, globals_1.expect)(dbSpy).toHaveBeenCalledTimes(2);
+            (0, globals_1.expect)(cacheSpy).toHaveBeenCalledTimes(0);
+            dbSpy.mockClear();
+            cacheSpy.mockClear();
+        }, { transactionalDataLoaderMode: EntityQueryContext_1.TransactionalDataLoaderMode.DISABLED });
+        (0, globals_1.expect)(entityDataManager['transactionalDataLoaders'].size).toBe(0);
+    });
+    (0, globals_1.it)('does not load from cache when in transaction', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        const entityDatas = await new StubQueryContextProvider_1.StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+            return await entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('customIdField'), [new SingleFieldHolder_1.SingleFieldValueHolder('1')]);
+        }, {});
+        (0, globals_1.expect)(entityDatas.get(new SingleFieldHolder_1.SingleFieldValueHolder('1'))).toHaveLength(1);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalled();
+        (0, globals_1.expect)(cacheSpy).not.toHaveBeenCalled();
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.it)('loads by field equality conjunction and does not cache', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        const dbSpy = globals_1.jest.spyOn(databaseAdapter, 'fetchManyByFieldEqualityConjunctionAsync');
+        const cacheSpy = globals_1.jest.spyOn(entityCache, 'readManyThroughAsync');
+        const entityDatas = await entityDataManager.loadManyByFieldEqualityConjunctionAsync(queryContext, [
+            {
+                fieldName: 'stringField',
+                fieldValue: 'hello',
+            },
+            {
+                fieldName: 'intField',
+                fieldValue: 1,
+            },
+        ], {});
+        (0, globals_1.expect)(entityDatas).toHaveLength(2);
+        (0, globals_1.expect)(dbSpy).toHaveBeenCalled();
+        (0, globals_1.expect)(cacheSpy).not.toHaveBeenCalled();
+        dbSpy.mockReset();
+        cacheSpy.mockReset();
+    });
+    (0, globals_1.it)('handles DB errors as expected', async () => {
+        const databaseAdapterMock = (0, ts_mockito_1.mock)();
+        (0, ts_mockito_1.when)(databaseAdapterMock.fetchManyWhereAsync((0, ts_mockito_1.anything)(), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anything)())).thenReject(new Error('DB query failed'));
+        const databaseAdapter = (0, ts_mockito_1.instance)(databaseAdapterMock);
+        const cacheAdapterProvider = new StubCacheAdapter_1.NoCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        await (0, globals_1.expect)(entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('customIdField'), [new SingleFieldHolder_1.SingleFieldValueHolder('2')])).rejects.toThrow();
+    });
+    (0, globals_1.describe)('metrics', () => {
+        (0, globals_1.it)('records metrics appropriately outside of transactions', async () => {
+            const metricsAdapterMock = (0, ts_mockito_1.mock)();
+            const metricsAdapter = (0, ts_mockito_1.instance)(metricsAdapterMock);
+            const objects = getObjects();
+            const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+            const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+            const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+            const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+            const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+            const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), metricsAdapter, TestEntity_1.TestEntity.name);
+            const queryContext = new StubQueryContextProvider_1.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_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique1')]);
+            (0, ts_mockito_1.verify)(metricsAdapterMock.logDataManagerLoadEvent((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.EntityMetricsLoadType.LOAD_MANY,
+                isInTransaction: false,
+                entityClassName: TestEntity_1.TestEntity.name,
+                duration: (0, ts_mockito_1.anyNumber)(),
+                count: 1,
+            }))).once();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.anything)())).thrice();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATALOADER,
+                isInTransaction: false,
+                fieldValueCount: 1,
+                entityClassName: TestEntity_1.TestEntity.name,
+                loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+            }))).once();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.CACHE,
+                isInTransaction: false,
+                fieldValueCount: 1,
+                entityClassName: TestEntity_1.TestEntity.name,
+                loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+            }))).once();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATABASE,
+                isInTransaction: false,
+                fieldValueCount: 1,
+                entityClassName: TestEntity_1.TestEntity.name,
+                loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+            }))).once();
+            (0, ts_mockito_1.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_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique1')]);
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.anything)())).once();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATALOADER,
+                isInTransaction: false,
+                fieldValueCount: 1,
+                entityClassName: TestEntity_1.TestEntity.name,
+                loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+            }))).once();
+            (0, ts_mockito_1.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_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+            const entityDataManager2 = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache2, new StubQueryContextProvider_1.StubQueryContextProvider(), metricsAdapter, TestEntity_1.TestEntity.name);
+            await entityDataManager2.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique1'), new SingleFieldHolder_1.SingleFieldValueHolder('unique2')]);
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.anything)())).thrice();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATALOADER,
+                isInTransaction: false,
+                fieldValueCount: 2,
+                entityClassName: TestEntity_1.TestEntity.name,
+                loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+            }))).once();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.CACHE,
+                isInTransaction: false,
+                fieldValueCount: 2,
+                entityClassName: TestEntity_1.TestEntity.name,
+                loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+            }))).once();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATABASE,
+                isInTransaction: false,
+                fieldValueCount: 1,
+                entityClassName: TestEntity_1.TestEntity.name,
+                loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+            }))).once();
+            (0, ts_mockito_1.resetCalls)(metricsAdapterMock);
+            await entityDataManager.loadManyByFieldEqualityConjunctionAsync(queryContext, [
+                {
+                    fieldName: 'testIndexedField',
+                    fieldValue: 'unique1',
+                },
+            ], {});
+            (0, ts_mockito_1.verify)(metricsAdapterMock.logDataManagerLoadEvent((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
+                isInTransaction: false,
+                entityClassName: TestEntity_1.TestEntity.name,
+                duration: (0, ts_mockito_1.anyNumber)(),
+                count: 1,
+            }))).once();
+            (0, ts_mockito_1.resetCalls)(metricsAdapterMock);
+            const databaseAdapterSpy = (0, ts_mockito_1.spy)(databaseAdapter);
+            (0, ts_mockito_1.when)(databaseAdapterSpy.fetchManyByRawWhereClauseAsync((0, ts_mockito_1.anything)(), (0, ts_mockito_1.anyString)(), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anything)())).thenResolve([]);
+            await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
+            (0, ts_mockito_1.verify)(metricsAdapterMock.logDataManagerLoadEvent((0, ts_mockito_1.deepEqual)({
+                type: IEntityMetricsAdapter_1.EntityMetricsLoadType.LOAD_MANY_RAW,
+                isInTransaction: false,
+                entityClassName: TestEntity_1.TestEntity.name,
+                duration: (0, ts_mockito_1.anyNumber)(),
+                count: 0,
+            }))).once();
+            (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.anything)())).never();
+        });
+        (0, globals_1.it)('records metrics appropriately inside of transactions', async () => {
+            const metricsAdapterMock = (0, ts_mockito_1.mock)();
+            const metricsAdapter = (0, ts_mockito_1.instance)(metricsAdapterMock);
+            const objects = getObjects();
+            const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+            const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+            const cacheAdapterProvider = new StubCacheAdapter_1.InMemoryFullCacheStubCacheAdapterProvider();
+            const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+            const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+            const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), metricsAdapter, TestEntity_1.TestEntity.name);
+            await new StubQueryContextProvider_1.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_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique1')]);
+                (0, ts_mockito_1.verify)(metricsAdapterMock.logDataManagerLoadEvent((0, ts_mockito_1.deepEqual)({
+                    type: IEntityMetricsAdapter_1.EntityMetricsLoadType.LOAD_MANY,
+                    isInTransaction: true,
+                    entityClassName: TestEntity_1.TestEntity.name,
+                    duration: (0, ts_mockito_1.anyNumber)(),
+                    count: 1,
+                }))).once();
+                (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.anything)())).twice();
+                (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                    type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATALOADER,
+                    isInTransaction: true,
+                    fieldValueCount: 1,
+                    entityClassName: TestEntity_1.TestEntity.name,
+                    loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+                }))).once();
+                (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                    type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATABASE,
+                    isInTransaction: true,
+                    fieldValueCount: 1,
+                    entityClassName: TestEntity_1.TestEntity.name,
+                    loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+                }))).once();
+                (0, ts_mockito_1.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_1.SingleFieldHolder('testIndexedField'), [new SingleFieldHolder_1.SingleFieldValueHolder('unique1')]);
+                (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.anything)())).once();
+                (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.deepEqual)({
+                    type: IEntityMetricsAdapter_1.IncrementLoadCountEventType.DATALOADER,
+                    isInTransaction: true,
+                    fieldValueCount: 1,
+                    entityClassName: TestEntity_1.TestEntity.name,
+                    loadType: EntityLoadInterfaces_1.EntityLoadMethodType.SINGLE,
+                }))).once();
+                (0, ts_mockito_1.resetCalls)(metricsAdapterMock);
+                await entityDataManager.loadManyByFieldEqualityConjunctionAsync(queryContext, [
+                    {
+                        fieldName: 'testIndexedField',
+                        fieldValue: 'unique1',
+                    },
+                ], {});
+                (0, ts_mockito_1.verify)(metricsAdapterMock.logDataManagerLoadEvent((0, ts_mockito_1.deepEqual)({
+                    type: IEntityMetricsAdapter_1.EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
+                    isInTransaction: true,
+                    entityClassName: TestEntity_1.TestEntity.name,
+                    duration: (0, ts_mockito_1.anyNumber)(),
+                    count: 1,
+                }))).once();
+                (0, ts_mockito_1.resetCalls)(metricsAdapterMock);
+                const databaseAdapterSpy = (0, ts_mockito_1.spy)(databaseAdapter);
+                (0, ts_mockito_1.when)(databaseAdapterSpy.fetchManyByRawWhereClauseAsync((0, ts_mockito_1.anything)(), (0, ts_mockito_1.anyString)(), (0, ts_mockito_1.anything)(), (0, ts_mockito_1.anything)())).thenResolve([]);
+                await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
+                (0, ts_mockito_1.verify)(metricsAdapterMock.logDataManagerLoadEvent((0, ts_mockito_1.deepEqual)({
+                    type: IEntityMetricsAdapter_1.EntityMetricsLoadType.LOAD_MANY_RAW,
+                    isInTransaction: true,
+                    entityClassName: TestEntity_1.TestEntity.name,
+                    duration: (0, ts_mockito_1.anyNumber)(),
+                    count: 0,
+                }))).once();
+                (0, ts_mockito_1.verify)(metricsAdapterMock.incrementDataManagerLoadCount((0, ts_mockito_1.anything)())).never();
+            });
+        });
+    });
+    (0, globals_1.it)('throws when a single value load-by value is null or undefined', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.NoCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        await (0, globals_1.expect)(entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('nullableField'), [new SingleFieldHolder_1.SingleFieldValueHolder(null)])).rejects.toThrow('Invalid load: TestEntity (nullableField = null)');
+        await (0, globals_1.expect)(entityDataManager.loadManyEqualingAsync(queryContext, new SingleFieldHolder_1.SingleFieldHolder('nullableField'), [new SingleFieldHolder_1.SingleFieldValueHolder(undefined)])).rejects.toThrow('Invalid load: TestEntity (nullableField = undefined)');
+    });
+    (0, globals_1.it)('throws when a composite value load-by value is null or undefined', async () => {
+        const objects = getObjects();
+        const dataStore = StubDatabaseAdapter_1.StubDatabaseAdapter.convertFieldObjectsToDataStore(TestEntity_1.testEntityConfiguration, objects);
+        const databaseAdapter = new StubDatabaseAdapter_1.StubDatabaseAdapter(TestEntity_1.testEntityConfiguration, dataStore);
+        const cacheAdapterProvider = new StubCacheAdapter_1.NoCacheStubCacheAdapterProvider();
+        const cacheAdapter = cacheAdapterProvider.getCacheAdapter(TestEntity_1.testEntityConfiguration);
+        const entityCache = new ReadThroughEntityCache_1.ReadThroughEntityCache(TestEntity_1.testEntityConfiguration, cacheAdapter);
+        const entityDataManager = new EntityDataManager_1.EntityDataManager(databaseAdapter, entityCache, new StubQueryContextProvider_1.StubQueryContextProvider(), new NoOpEntityMetricsAdapter_1.NoOpEntityMetricsAdapter(), TestEntity_1.TestEntity.name);
+        const queryContext = new StubQueryContextProvider_1.StubQueryContextProvider().getQueryContext();
+        await (0, globals_1.expect)(entityDataManager.loadManyEqualingAsync(queryContext, new CompositeFieldHolder_1.CompositeFieldHolder([
+            'nullableField',
+            'testIndexedField',
+        ]), [
+            new CompositeFieldHolder_1.CompositeFieldValueHolder({
+                nullableField: null,
+                testIndexedField: 'unique1',
+            }),
+        ])).rejects.toThrow('Invalid load: TestEntity (nullableField,testIndexedField = CompositeFieldValue(nullableField=null,testIndexedField=unique1))');
+        await (0, globals_1.expect)(entityDataManager.loadManyEqualingAsync(queryContext, new CompositeFieldHolder_1.CompositeFieldHolder([
+            'nullableField',
+            'testIndexedField',
+        ]), [
+            new CompositeFieldHolder_1.CompositeFieldValueHolder({
+                nullableField: undefined,
+                testIndexedField: 'unique1',
+            }),
+        ])).rejects.toThrow('Invalid load: TestEntity (nullableField,testIndexedField = CompositeFieldValue(nullableField=undefined,testIndexedField=unique1))');
+    });
+});
+//# sourceMappingURL=EntityDataManager-test.js.map