@expo/entity 0.38.0 → 0.40.0

package/src/__tests__/EntitySelfReferentialEdges-test.ts

@@ -87,13 +87,15 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', parentCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', subCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
 
     await expect(
       CategoryEntity.loader(viewerContext)
@@ -109,7 +111,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
         .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory);
+    await CategoryEntity.deleter(parentCategory).enforcing().deleteAsync();
 
     await expect(
       CategoryEntity.loader(viewerContext)
@@ -132,15 +134,17 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', categoryA.getID())
-      .enforceCreateAsync();
+      .createAsync();
     await CategoryEntity.updater(categoryA)
+      .enforcing()
       .setField('parent_category_id', categoryB.getID())
-      .enforceUpdateAsync();
+      .updateAsync();
 
-    await CategoryEntity.enforceDeleteAsync(categoryA);
+    await CategoryEntity.deleter(categoryA).enforcing().deleteAsync();
 
     await expect(
       CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID()),
@@ -158,13 +162,15 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', parentCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', subCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
 
     await expect(
       CategoryEntity.loader(viewerContext)
@@ -180,7 +186,7 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
         .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory);
+    await CategoryEntity.deleter(parentCategory).enforcing().deleteAsync();
 
     await expect(
       CategoryEntity.loader(viewerContext)
@@ -205,15 +211,17 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', categoryA.getID())
-      .enforceCreateAsync();
+      .createAsync();
     await CategoryEntity.updater(categoryA)
+      .enforcing()
       .setField('parent_category_id', categoryB.getID())
-      .enforceUpdateAsync();
+      .updateAsync();
 
-    await CategoryEntity.enforceDeleteAsync(categoryA);
+    await CategoryEntity.deleter(categoryA).enforcing().deleteAsync();
 
     const loadedCategoryB = await CategoryEntity.loader(viewerContext)
       .enforcing()
@@ -231,13 +239,15 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', parentCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', subCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
 
     await expect(
       CategoryEntity.loader(viewerContext)
@@ -271,7 +281,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     );
     expect(subSubCategoryCachedBefore.get(subCategory.getID())?.status).toEqual(CacheStatus.HIT);
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory);
+    await CategoryEntity.deleter(parentCategory).enforcing().deleteAsync();
 
     const subCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
       parentCategory.getID(),
@@ -307,13 +317,15 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).enforcing().createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
+      .enforcing()
       .setField('parent_category_id', categoryA.getID())
-      .enforceCreateAsync();
+      .createAsync();
     await CategoryEntity.updater(categoryA)
+      .enforcing()
       .setField('parent_category_id', categoryB.getID())
-      .enforceUpdateAsync();
+      .updateAsync();
 
     await expect(
       CategoryEntity.loader(viewerContext)
@@ -338,7 +350,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     expect(categoriesCachedBefore.get(categoryA.getID())?.status).toEqual(CacheStatus.HIT);
     expect(categoriesCachedBefore.get(categoryB.getID())?.status).toEqual(CacheStatus.HIT);
 
-    await CategoryEntity.enforceDeleteAsync(categoryA);
+    await CategoryEntity.deleter(categoryA).enforcing().deleteAsync();
 
     const categoriesCachedAfter = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
       categoryA.getID(),

package/src/__tests__/ReadonlyEntity-test.ts

@@ -127,7 +127,7 @@ describe(ReadonlyEntity, () => {
     }).toThrow();
   });
 
-  it('returns correct viewerCo}ntext from instantiation', () => {
+  it('returns correct viewerContext from instantiation', () => {
     const viewerContext = instance(mock(ViewerContext));
     const data = {
       id: 'what',

package/src/__tests__/cases/TwoEntitySameTableDisjointRows-test.ts

@@ -14,15 +14,17 @@ describe('Two entities backed by the same table', () => {
     const viewerContext = new ViewerContext(companionProvider);
 
     const one = await OneTestEntity.creator(viewerContext)
+      .enforcing()
       .setField('entity_type', EntityType.ONE)
       .setField('common_other_field', 'wat')
-      .enforceCreateAsync();
+      .createAsync();
 
     const two = await TwoTestEntity.creator(viewerContext)
+      .enforcing()
       .setField('entity_type', EntityType.TWO)
       .setField('other_field', 'blah')
       .setField('common_other_field', 'wat')
-      .enforceCreateAsync();
+      .createAsync();
 
     expect(one).toBeInstanceOf(OneTestEntity);
     expect(two).toBeInstanceOf(TwoTestEntity);

package/src/__tests__/cases/TwoEntitySameTableOverlappingRows-test.ts

@@ -13,8 +13,9 @@ describe('Two entities backed by the same table', () => {
     const viewerContext = new ViewerContext(companionProvider);
 
     const entity1 = await OneTestEntity.creator(viewerContext)
+      .enforcing()
       .setField('fake_field', 'hello')
-      .enforceCreateAsync();
+      .createAsync();
     expect(entity1).toBeInstanceOf(OneTestEntity);
 
     const entity2 = await TwoTestEntity.loader(viewerContext)
@@ -23,9 +24,10 @@ describe('Two entities backed by the same table', () => {
     expect(entity2).toBeInstanceOf(TwoTestEntity);
 
     const updated2 = await TwoTestEntity.updater(entity2)
+      .enforcing()
       .setField('fake_field', 'world')
       .setField('other_field', 'wat')
-      .enforceUpdateAsync();
+      .updateAsync();
     expect(updated2.getAllFields()).toMatchObject({
       id: updated2.getID(),
       other_field: 'wat',
@@ -46,9 +48,10 @@ describe('Two entities backed by the same table', () => {
     const viewerContext = new ViewerContext(companionProvider);
 
     const entity = await TwoTestEntity.creator(viewerContext)
+      .enforcing()
       .setField('fake_field', 'hello')
       .setField('other_field', 'huh')
-      .enforceCreateAsync();
+      .createAsync();
 
     const loadedEntity = await TwoTestEntity.loader(viewerContext)
       .enforcing()
@@ -62,7 +65,7 @@ describe('Two entities backed by the same table', () => {
     const loaded1 = await OneTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity.getID());
-    await OneTestEntity.updater(loaded1).setField('fake_field', 'world').enforceUpdateAsync();
+    await OneTestEntity.updater(loaded1).enforcing().setField('fake_field', 'world').updateAsync();
 
     const loaded2 = await TwoTestEntity.loader(viewerContext)
       .enforcing()

package/src/__tests__/entityUtils-test.ts

@@ -7,6 +7,7 @@ import {
   successfulResultsFilterMap,
   failedResultsFilterMap,
   pick,
+  partitionArray,
 } from '../entityUtils';
 
 describe(enforceResultsAsync, () => {
@@ -97,3 +98,14 @@ describe(pick, () => {
     });
   });
 });
+
+describe(partitionArray, () => {
+  it('partitions array', () => {
+    type A = true;
+    type B = false;
+    const arr: (A | B)[] = [true, false, true, true, false];
+    const [as, bs] = partitionArray<A, B>(arr, (val: A | B): val is A => val === true);
+    expect(as).toMatchObject([true, true, true]);
+    expect(bs).toMatchObject([false, false]);
+  });
+});

package/src/entityUtils.ts

@@ -71,22 +71,37 @@ export const failedResultsFilterMap = <K, T>(
   return ret;
 };
 
+export type PartitionArrayPredicate<T, U> = (val: T | U) => val is T;
+
 /**
- * Partition array of values and errors into an array of values and an array of errors.
- * @param valuesAndErrors - array of values and errors
+ * Partition an array of values into two arrays based on evaluation of a binary predicate.
+ * @param values - array of values to partition
+ * @param predicate - binary predicate to evaluate partition group of each value
  */
-export const partitionErrors = <T>(valuesAndErrors: (T | Error)[]): [T[], Error[]] => {
-  const values: T[] = [];
-  const errors: Error[] = [];
+export const partitionArray = <T, U>(
+  values: (T | U)[],
+  predicate: PartitionArrayPredicate<T, U>,
+): [T[], U[]] => {
+  const ts: T[] = [];
+  const us: U[] = [];
 
-  for (const valueOrError of valuesAndErrors) {
-    if (isError(valueOrError)) {
-      errors.push(valueOrError);
+  for (const value of values) {
+    if (predicate(value)) {
+      ts.push(value);
     } else {
-      values.push(valueOrError);
+      us.push(value);
     }
   }
 
+  return [ts, us];
+};
+
+/**
+ * Partition array of values and errors into an array of values and an array of errors.
+ * @param valuesAndErrors - array of values and errors
+ */
+export const partitionErrors = <T>(valuesAndErrors: (T | Error)[]): [T[], Error[]] => {
+  const [errors, values] = partitionArray<Error, T>(valuesAndErrors, isError);
   return [values, errors];
 };
 

package/src/index.ts

@@ -4,31 +4,38 @@
  * @module @expo/entity
  */
 
+export { default as AuthorizationResultBasedEntityAssociationLoader } from './AuthorizationResultBasedEntityAssociationLoader';
+export * from './AuthorizationResultBasedEntityAssociationLoader';
 export { default as AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
+export * from './AuthorizationResultBasedEntityMutator';
 export { default as ComposedEntityCacheAdapter } from './ComposedEntityCacheAdapter';
 export { default as ComposedSecondaryEntityCache } from './ComposedSecondaryEntityCache';
+export { default as EnforcingEntityAssociationLoader } from './EnforcingEntityAssociationLoader';
+export { default as EnforcingEntityCreator } from './EnforcingEntityCreator';
+export { default as EnforcingEntityDeleter } from './EnforcingEntityDeleter';
 export { default as EnforcingEntityLoader } from './EnforcingEntityLoader';
+export { default as EnforcingEntityUpdater } from './EnforcingEntityUpdater';
 export { default as Entity } from './Entity';
 export * from './Entity';
 export { default as EntityAssociationLoader } from './EntityAssociationLoader';
-export * from './EntityAssociationLoader';
 export { default as EntityCompanion } from './EntityCompanion';
 export * from './EntityCompanion';
 export { default as EntityCompanionProvider } from './EntityCompanionProvider';
 export * from './EntityCompanionProvider';
 export { default as EntityConfiguration } from './EntityConfiguration';
+export { default as EntityCreator } from './EntityCreator';
 export { default as EntityDatabaseAdapter } from './EntityDatabaseAdapter';
 export * from './EntityDatabaseAdapter';
+export { default as EntityDeleter } from './EntityDeleter';
 export * from './EntityFieldDefinition';
 export * from './EntityFields';
 export { default as EntityLoader } from './EntityLoader';
 export { default as EntityLoaderFactory } from './EntityLoaderFactory';
 export { default as EntityLoaderUtils } from './EntityLoaderUtils';
 export * from './EntityMutationInfo';
-export { default as EntityMutationTriggerConfiguration } from './EntityMutationTriggerConfiguration';
+export { type default as EntityMutationTriggerConfiguration } from './EntityMutationTriggerConfiguration';
 export * from './EntityMutationTriggerConfiguration';
 export { default as EntityMutationValidator } from './EntityMutationValidator';
-export * from './EntityMutator';
 export { default as EntityMutatorFactory } from './EntityMutatorFactory';
 export { default as EntityPrivacyPolicy } from './EntityPrivacyPolicy';
 export * from './EntityPrivacyPolicy';
@@ -36,19 +43,20 @@ export * from './EntityQueryContext';
 export { default as EntityQueryContextProvider } from './EntityQueryContextProvider';
 export { default as EntitySecondaryCacheLoader } from './EntitySecondaryCacheLoader';
 export * from './EntitySecondaryCacheLoader';
+export { default as EntityUpdater } from './EntityUpdater';
+export * from './entityUtils';
 export { default as GenericEntityCacheAdapter } from './GenericEntityCacheAdapter';
 export { default as GenericSecondaryEntityCache } from './GenericSecondaryEntityCache';
-export { default as IEntityCacheAdapter } from './IEntityCacheAdapter';
-export { default as IEntityCacheAdapterProvider } from './IEntityCacheAdapterProvider';
-export { default as IEntityDatabaseAdapterProvider } from './IEntityDatabaseAdapterProvider';
-export { default as IEntityGenericCacher } from './IEntityGenericCacher';
+export { type default as IEntityCacheAdapter } from './IEntityCacheAdapter';
+export { type default as IEntityCacheAdapterProvider } from './IEntityCacheAdapterProvider';
+export { type default as IEntityDatabaseAdapterProvider } from './IEntityDatabaseAdapterProvider';
+export { type default as IEntityGenericCacher } from './IEntityGenericCacher';
 export { default as ReadonlyEntity } from './ReadonlyEntity';
 export { default as ViewerContext } from './ViewerContext';
 export { default as ViewerScopedEntityCompanion } from './ViewerScopedEntityCompanion';
 export { default as ViewerScopedEntityCompanionProvider } from './ViewerScopedEntityCompanionProvider';
 export { default as ViewerScopedEntityLoaderFactory } from './ViewerScopedEntityLoaderFactory';
 export { default as ViewerScopedEntityMutatorFactory } from './ViewerScopedEntityMutatorFactory';
-export * from './entityUtils';
 export { default as EntityCacheAdapterError } from './errors/EntityCacheAdapterError';
 export * from './errors/EntityCacheAdapterError';
 export { default as EntityDatabaseAdapterError } from './errors/EntityDatabaseAdapterError';
@@ -64,7 +72,7 @@ export { default as EntityTableDataCoordinator } from './internal/EntityTableDat
 export { default as ReadThroughEntityCache } from './internal/ReadThroughEntityCache';
 export * from './internal/ReadThroughEntityCache';
 export * from './metrics/EntityMetricsUtils';
-export { default as IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
+export { type default as IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
 export * from './metrics/IEntityMetricsAdapter';
 export { default as NoOpEntityMetricsAdapter } from './metrics/NoOpEntityMetricsAdapter';
 export { default as AlwaysAllowPrivacyPolicyRule } from './rules/AlwaysAllowPrivacyPolicyRule';
@@ -75,10 +83,10 @@ export * from './rules/PrivacyPolicyRule';
 export * from './utils/EntityPrivacyUtils';
 export * from './utils/mergeEntityMutationTriggerConfigurations';
 export * from './utils/collections/maps';
+export * from './utils/testing/createUnitTestEntityCompanionProvider';
+export { default as describeFieldTestCase } from './utils/testing/describeFieldTestCase';
 export * from './utils/testing/PrivacyPolicyRuleTestUtils';
 export * from './utils/testing/StubCacheAdapter';
 export { default as StubDatabaseAdapter } from './utils/testing/StubDatabaseAdapter';
 export { default as StubDatabaseAdapterProvider } from './utils/testing/StubDatabaseAdapterProvider';
 export { default as StubQueryContextProvider } from './utils/testing/StubQueryContextProvider';
-export * from './utils/testing/createUnitTestEntityCompanionProvider';
-export { default as describeFieldTestCase } from './utils/testing/describeFieldTestCase';

package/src/internal/EntityFieldTransformationUtils.ts

@@ -26,7 +26,7 @@ export const getDatabaseFieldForEntityField = <TFields extends Record<string, an
 ): string => {
   const databaseField = entityConfiguration.entityToDBFieldsKeyMapping.get(entityField);
   invariant(databaseField, `database field mapping missing for ${String(entityField)}`);
-  return databaseField!;
+  return databaseField;
 };
 
 export const transformDatabaseObjectToFields = <TFields extends Record<string, any>>(
@@ -60,7 +60,7 @@ export const transformFieldsToDatabaseObject = <TFields extends Record<string, a
     const val = fields[k]!;
     const databaseKey = entityConfiguration.entityToDBFieldsKeyMapping.get(k as any);
     invariant(databaseKey, `must be database key for field: ${k}`);
-    databaseObject[databaseKey!] = maybeTransformFieldValueToDatabaseValue(
+    databaseObject[databaseKey] = maybeTransformFieldValueToDatabaseValue(
       entityConfiguration,
       fieldTransformerMap,
       k,

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

@@ -74,11 +74,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -122,11 +122,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -170,16 +170,16 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
     // use second data manager to ensure that cache is hit instead of data loader
     const entityDataManager2 = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
@@ -214,11 +214,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -250,11 +250,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -294,11 +294,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1]!;
 
@@ -306,11 +306,11 @@ describe(EntityDataManager, () => {
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField']!,
+      objectInQuestion['testIndexedField'],
     ]);
     await entityDataManager.invalidateObjectFieldsAsync(objectInQuestion);
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField']!,
+      objectInQuestion['testIndexedField'],
     ]);
 
     expect(dbSpy).toHaveBeenCalledTimes(2);
@@ -333,11 +333,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1]!;
 
@@ -345,11 +345,11 @@ describe(EntityDataManager, () => {
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'testIndexedField', [
-      objectInQuestion['testIndexedField']!,
+      objectInQuestion['testIndexedField'],
     ]);
     await entityDataManager.invalidateObjectFieldsAsync(objectInQuestion);
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', [
-      objectInQuestion['customIdField']!,
+      objectInQuestion['customIdField'],
     ]);
 
     expect(dbSpy).toHaveBeenCalledTimes(2);
@@ -372,7 +372,7 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
@@ -380,7 +380,7 @@ describe(EntityDataManager, () => {
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
 
-    const entityDatas = await StubQueryContextProvider.runInTransactionAsync(
+    const entityDatas = await new StubQueryContextProvider().runInTransactionAsync(
       async (queryContext) => {
         return await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', [
           '1',
@@ -411,11 +411,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyByFieldEqualityConjunctionAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -457,11 +457,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     await expect(
       entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', ['2']),
@@ -484,11 +484,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       metricsAdapter,
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', ['1']);
     verify(
@@ -587,11 +587,11 @@ describe(EntityDataManager, () => {
     const entityDataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       new NoOpEntityMetricsAdapter(),
       TestEntity.name,
     );
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     await expect(
       entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'nullableField', [null as any]),