@expo/entity 0.34.0 → 0.36.0

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

@@ -1,24 +1,24 @@
 import Entity from '../../Entity';
 import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
-import { UUIDField, EnumField, StringField } from '../../EntityFields';
+import { UUIDField, StringField, StrictEnumField } from '../../EntityFields';
 import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
+import ViewerContext from '../../ViewerContext';
 import { successfulResults, failedResults } from '../../entityUtils';
 import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
-import TestViewerContext from '../../testfixtures/TestViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe('Two entities backed by the same table', () => {
   test('load by different types', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
-    const viewerContext = new TestViewerContext(companionProvider);
+    const viewerContext = new ViewerContext(companionProvider);
 
-    const one = await OneTestEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const one = await OneTestEntity.creator(viewerContext)
       .setField('entity_type', EntityType.ONE)
       .setField('common_other_field', 'wat')
       .enforceCreateAsync();
 
-    const two = await TwoTestEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const two = await TwoTestEntity.creator(viewerContext)
       .setField('entity_type', EntityType.TWO)
       .setField('other_field', 'blah')
       .setField('common_other_field', 'wat')
@@ -28,21 +28,16 @@ describe('Two entities backed by the same table', () => {
     expect(two).toBeInstanceOf(TwoTestEntity);
 
     await expect(
-      TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
-        .enforcing()
-        .loadByIDAsync(one.getID())
+      TwoTestEntity.loader(viewerContext).enforcing().loadByIDAsync(one.getID()),
     ).rejects.toThrowError('TwoTestEntity must be instantiated with two data');
 
     await expect(
-      OneTestEntity.loader(viewerContext, viewerContext.getQueryContext())
-        .enforcing()
-        .loadByIDAsync(two.getID())
+      OneTestEntity.loader(viewerContext).enforcing().loadByIDAsync(two.getID()),
     ).rejects.toThrowError('OneTestEntity must be instantiated with one data');
 
-    const manyResults = await OneTestEntity.loader(
-      viewerContext,
-      viewerContext.getQueryContext()
-    ).loadManyByFieldEqualingAsync('common_other_field', 'wat');
+    const manyResults = await OneTestEntity.loader(viewerContext)
+      .withAuthorizationResults()
+      .loadManyByFieldEqualingAsync('common_other_field', 'wat');
     const successfulManyResults = successfulResults(manyResults);
     const failedManyResults = failedResults(manyResults);
 
@@ -51,23 +46,22 @@ describe('Two entities backed by the same table', () => {
 
     expect(successfulManyResults[0]!.enforceValue().getID()).toEqual(one.getID());
     expect(failedManyResults[0]!.enforceError().message).toEqual(
-      'OneTestEntity must be instantiated with one data'
+      'OneTestEntity must be instantiated with one data',
     );
 
-    const fieldEqualityConjunctionResults = await OneTestEntity.loader(
-      viewerContext,
-      viewerContext.getQueryContext()
-    ).loadManyByFieldEqualityConjunctionAsync([
-      {
-        fieldName: 'common_other_field',
-        fieldValue: 'wat',
-      },
-    ]);
+    const fieldEqualityConjunctionResults = await OneTestEntity.loader(viewerContext)
+      .withAuthorizationResults()
+      .loadManyByFieldEqualityConjunctionAsync([
+        {
+          fieldName: 'common_other_field',
+          fieldValue: 'wat',
+        },
+      ]);
     const successfulfieldEqualityConjunctionResultsResults = successfulResults(
-      fieldEqualityConjunctionResults
+      fieldEqualityConjunctionResults,
     );
     const failedfieldEqualityConjunctionResultsResults = failedResults(
-      fieldEqualityConjunctionResults
+      fieldEqualityConjunctionResults,
     );
     expect(successfulfieldEqualityConjunctionResultsResults).toHaveLength(1);
     expect(failedfieldEqualityConjunctionResultsResults).toHaveLength(1);
@@ -103,38 +97,33 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
     common_other_field: new StringField({
       columnName: 'common_other_field',
     }),
-    entity_type: new EnumField({
+    entity_type: new StrictEnumField({
       columnName: 'entity_type',
+      enum: EntityType,
     }),
   },
   databaseAdapterFlavor: 'postgres',
   cacheAdapterFlavor: 'redis',
 });
 
-class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
-  any,
-  string,
-  TestViewerContext,
-  any,
-  any
-> {
+class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
 }
 
-class OneTestEntity extends Entity<TestFields, string, TestViewerContext, OneTestFields> {
+class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
   constructor(constructorParams: {
-    viewerContext: TestViewerContext;
+    viewerContext: ViewerContext;
     id: string;
     databaseFields: Readonly<TestFields>;
     selectedFields: Readonly<Pick<TestFields, OneTestFields>>;
@@ -148,7 +137,7 @@ class OneTestEntity extends Entity<TestFields, string, TestViewerContext, OneTes
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     OneTestEntity,
     TestEntityPrivacyPolicy,
     OneTestFields
@@ -162,9 +151,9 @@ class OneTestEntity extends Entity<TestFields, string, TestViewerContext, OneTes
   }
 }
 
-class TwoTestEntity extends Entity<TestFields, string, TestViewerContext, TwoTestFields> {
+class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
   constructor(constructorParams: {
-    viewerContext: TestViewerContext;
+    viewerContext: ViewerContext;
     id: string;
     databaseFields: Readonly<TestFields>;
     selectedFields: Readonly<Pick<TestFields, TwoTestFields>>;
@@ -178,7 +167,7 @@ class TwoTestEntity extends Entity<TestFields, string, TestViewerContext, TwoTes
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TwoTestEntity,
     TestEntityPrivacyPolicy,
     TwoTestFields

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

@@ -3,26 +3,26 @@ import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
 import { UUIDField, StringField } from '../../EntityFields';
 import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
+import ViewerContext from '../../ViewerContext';
 import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
-import TestViewerContext from '../../testfixtures/TestViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe('Two entities backed by the same table', () => {
   test('mutate through different types and keep consistent cache and dataloader', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
-    const viewerContext = new TestViewerContext(companionProvider);
+    const viewerContext = new ViewerContext(companionProvider);
 
-    const entity1 = await OneTestEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const entity1 = await OneTestEntity.creator(viewerContext)
       .setField('fake_field', 'hello')
       .enforceCreateAsync();
     expect(entity1).toBeInstanceOf(OneTestEntity);
 
-    const entity2 = await TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const entity2 = await TwoTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity1.getID());
     expect(entity2).toBeInstanceOf(TwoTestEntity);
 
-    const updated2 = await TwoTestEntity.updater(entity2, viewerContext.getQueryContext())
+    const updated2 = await TwoTestEntity.updater(entity2)
       .setField('fake_field', 'world')
       .setField('other_field', 'wat')
       .enforceUpdateAsync();
@@ -32,7 +32,7 @@ describe('Two entities backed by the same table', () => {
       fake_field: 'world',
     });
 
-    const loaded1 = await OneTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loaded1 = await OneTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity1.getID());
     expect(loaded1.getAllFields()).toMatchObject({
@@ -43,14 +43,14 @@ describe('Two entities backed by the same table', () => {
 
   test('cached field that differs between the two to test invalidation', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
-    const viewerContext = new TestViewerContext(companionProvider);
+    const viewerContext = new ViewerContext(companionProvider);
 
-    const entity = await TwoTestEntity.creator(viewerContext, viewerContext.getQueryContext())
+    const entity = await TwoTestEntity.creator(viewerContext)
       .setField('fake_field', 'hello')
       .setField('other_field', 'huh')
       .enforceCreateAsync();
 
-    const loadedEntity = await TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loadedEntity = await TwoTestEntity.loader(viewerContext)
       .enforcing()
       .loadByFieldEqualingAsync('other_field', 'huh');
     expect(loadedEntity?.getAllFields()).toMatchObject({
@@ -59,14 +59,12 @@ describe('Two entities backed by the same table', () => {
       other_field: 'huh',
     });
 
-    const loaded1 = await OneTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loaded1 = await OneTestEntity.loader(viewerContext)
       .enforcing()
       .loadByIDAsync(entity.getID());
-    await OneTestEntity.updater(loaded1, viewerContext.getQueryContext())
-      .setField('fake_field', 'world')
-      .enforceUpdateAsync();
+    await OneTestEntity.updater(loaded1).setField('fake_field', 'world').enforceUpdateAsync();
 
-    const loaded2 = await TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loaded2 = await TwoTestEntity.loader(viewerContext)
       .enforcing()
       .loadByFieldEqualingAsync('other_field', 'huh');
     expect(loaded2?.getAllFields()).toMatchObject({
@@ -75,7 +73,7 @@ describe('Two entities backed by the same table', () => {
       other_field: 'huh',
     });
 
-    const loaded22 = await TwoTestEntity.loader(viewerContext, viewerContext.getQueryContext())
+    const loaded22 = await TwoTestEntity.loader(viewerContext)
       .enforcing()
       .loadByFieldEqualingAsync('fake_field', 'world');
     expect(loaded22?.getAllFields()).toMatchObject({
@@ -116,32 +114,26 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
   cacheAdapterFlavor: 'redis',
 });
 
-class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
-  any,
-  string,
-  TestViewerContext,
-  any,
-  any
-> {
+class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
 }
 
-class OneTestEntity extends Entity<TestFields, string, TestViewerContext, OneTestFields> {
+class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     OneTestEntity,
     TestEntityPrivacyPolicy,
     OneTestFields
@@ -155,11 +147,11 @@ class OneTestEntity extends Entity<TestFields, string, TestViewerContext, OneTes
   }
 }
 
-class TwoTestEntity extends Entity<TestFields, string, TestViewerContext, TwoTestFields> {
+class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TwoTestEntity,
     TestEntityPrivacyPolicy,
     TwoTestFields

package/src/__tests__/entityUtils-test.ts

@@ -52,7 +52,7 @@ describe(successfulResultsFilterMap, () => {
         a: result1,
         b: result2,
         c: result3,
-      })
+      }),
     );
 
     const resultingMap = successfulResultsFilterMap(allResults);
@@ -73,7 +73,7 @@ describe(failedResultsFilterMap, () => {
         a: result1,
         b: result2,
         c: result3,
-      })
+      }),
     );
 
     const resultingMap = failedResultsFilterMap(allResults);

package/src/entityUtils.ts

@@ -5,7 +5,7 @@ import { Result, Success, Failure } from '@expo/results';
  * @param resultsPromise - promise returning an array of results to enforce
  */
 export const enforceResultsAsync = async <T>(
-  resultsPromise: Promise<readonly Result<T>[]>
+  resultsPromise: Promise<readonly Result<T>[]>,
 ): Promise<readonly T[]> => {
   const results = await resultsPromise;
   return results.map((result) => result.enforceValue());
@@ -44,7 +44,7 @@ export const failedResults = <T>(results: readonly Result<T>[]): readonly Failur
  * @param results - map of results to filter.
  */
 export const successfulResultsFilterMap = <K, T>(
-  results: ReadonlyMap<K, Result<T>>
+  results: ReadonlyMap<K, Result<T>>,
 ): ReadonlyMap<K, Success<T>> => {
   const ret: Map<K, Success<T>> = new Map();
   for (const [k, result] of results) {
@@ -60,7 +60,7 @@ export const successfulResultsFilterMap = <K, T>(
  * @param results - map of results to filter.
  */
 export const failedResultsFilterMap = <K, T>(
-  results: ReadonlyMap<K, Result<T>>
+  results: ReadonlyMap<K, Result<T>>,
 ): ReadonlyMap<K, Failure<T>> => {
   const ret: Map<K, Failure<T>> = new Map();
   for (const [k, result] of results) {
@@ -97,6 +97,6 @@ const isError = <T>(value: T | Error): value is Error => {
 export const pick = <T extends object, U extends keyof T>(object: T, props: U[]): Pick<T, U> => {
   const propsSet = new Set(props);
   return Object.fromEntries(
-    Object.entries(object).filter((entry) => propsSet.has(entry[0] as any))
+    Object.entries(object).filter((entry) => propsSet.has(entry[0] as any)),
   ) as any;
 };

package/src/errors/EntityError.ts

@@ -24,7 +24,10 @@ export default abstract class EntityError extends ES6Error {
   public abstract readonly state: EntityErrorState;
   public abstract readonly code: EntityErrorCode;
 
-  constructor(message: string, public readonly cause?: Error) {
+  constructor(
+    message: string,
+    public override readonly cause?: Error,
+  ) {
     super(message);
   }
 }

package/src/errors/EntityInvalidFieldValueError.ts

@@ -17,7 +17,7 @@ export default class EntityInvalidFieldValueError<
     TSelectedFields
   >,
   N extends keyof TFields,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
   public readonly state = EntityErrorState.PERMANENT;
   public readonly code = EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE;
@@ -32,7 +32,7 @@ export default class EntityInvalidFieldValueError<
       TSelectedFields
     >,
     fieldName: N,
-    fieldValue?: TFields[N]
+    fieldValue?: TFields[N],
   ) {
     super(`Entity field not valid: ${entityClass.name} (${String(fieldName)} = ${fieldValue})`);
   }

package/src/errors/EntityNotAuthorizedError.ts

@@ -8,7 +8,7 @@ export default class EntityNotAuthorizedError<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
   public readonly state = EntityErrorState.PERMANENT;
   public readonly code = EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED;
@@ -19,10 +19,10 @@ export default class EntityNotAuthorizedError<
     entity: TEntity,
     viewerContext: TViewerContext,
     action: EntityAuthorizationAction,
-    ruleIndex: number
+    ruleIndex: number,
   ) {
     super(
-      `Entity not authorized: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${ruleIndex})`
+      `Entity not authorized: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${ruleIndex})`,
     );
     this.entityClassName = entity.constructor.name;
   }

package/src/errors/EntityNotFoundError.ts

@@ -17,7 +17,7 @@ export default class EntityNotFoundError<
     TSelectedFields
   >,
   N extends keyof TFields,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
   public readonly state = EntityErrorState.PERMANENT;
   public readonly code = EntityErrorCode.ERR_ENTITY_NOT_FOUND;
@@ -32,7 +32,7 @@ export default class EntityNotFoundError<
       TSelectedFields
     >,
     fieldName: N,
-    fieldValue: TFields[N]
+    fieldValue: TFields[N],
   ) {
     super(`Entity not found: ${entityClass.name} (${String(fieldName)} = ${fieldValue})`);
   }

package/src/index.ts

@@ -76,3 +76,4 @@ export { default as StubDatabaseAdapterProvider } from './utils/testing/StubData
 export { default as StubQueryContextProvider } from './utils/testing/StubQueryContextProvider';
 export * from './utils/testing/createUnitTestEntityCompanionProvider';
 export * from './utils/collections/maps';
+export * from './utils/EntityPrivacyUtils';

package/src/internal/EntityDataManager.ts

@@ -25,7 +25,7 @@ import { computeIfAbsent, zipToMap } from '../utils/collections/maps';
  *
  * It is also responsible for invalidating all sources of data when mutated using EntityMutator.
  */
-export default class EntityDataManager<TFields> {
+export default class EntityDataManager<TFields extends Record<string, any>> {
   private readonly fieldDataLoaders: Map<
     keyof TFields,
     DataLoader<NonNullable<TFields[keyof TFields]>, readonly Readonly<TFields>[]>
@@ -36,30 +36,30 @@ export default class EntityDataManager<TFields> {
     private readonly entityCache: ReadThroughEntityCache<TFields>,
     private readonly queryContextProvider: EntityQueryContextProvider,
     private readonly metricsAdapter: IEntityMetricsAdapter,
-    private readonly entityClassName: string
+    private readonly entityClassName: string,
   ) {}
 
   private getFieldDataLoaderForFieldName<N extends keyof TFields>(
-    fieldName: N
+    fieldName: N,
   ): DataLoader<NonNullable<TFields[N]>, readonly Readonly<TFields>[]> {
     return computeIfAbsent(this.fieldDataLoaders, fieldName, () => {
       return new DataLoader(
         async (
-          fieldValues: readonly NonNullable<TFields[N]>[]
+          fieldValues: readonly NonNullable<TFields[N]>[],
         ): Promise<readonly (readonly TFields[])[]> => {
           const objectMap = await this.loadManyForDataLoaderByFieldEqualingAsync(
             fieldName,
-            fieldValues
+            fieldValues,
           );
           return fieldValues.map((fv) => objectMap.get(fv) ?? []);
-        }
+        },
       );
     });
   }
 
   private async loadManyForDataLoaderByFieldEqualingAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
     this.metricsAdapter.incrementDataManagerLoadCount({
       type: IncrementLoadCountEventType.CACHE,
@@ -76,11 +76,11 @@ export default class EntityDataManager<TFields> {
           entityClassName: this.entityClassName,
         });
         return await this.databaseAdapter.fetchManyWhereAsync(
-          this.queryContextProvider.getNonTransactionalQueryContext(),
+          this.queryContextProvider.getQueryContext(),
           fieldName,
-          fetcherValues
+          fetcherValues,
         );
-      }
+      },
     );
   }
 
@@ -95,28 +95,28 @@ export default class EntityDataManager<TFields> {
   async loadManyByFieldEqualingAsync<N extends keyof TFields>(
     queryContext: EntityQueryContext,
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
     return await timeAndLogLoadMapEventAsync(
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY,
-      this.entityClassName
+      this.entityClassName,
     )(this.loadManyByFieldEqualingInternalAsync(queryContext, fieldName, fieldValues));
   }
 
   private async loadManyByFieldEqualingInternalAsync<N extends keyof TFields>(
     queryContext: EntityQueryContext,
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
     const nullOrUndefinedValueIndex = fieldValues.findIndex(
-      (value) => value === null || value === undefined
+      (value) => value === null || value === undefined,
     );
     if (nullOrUndefinedValueIndex >= 0) {
       throw new Error(
         `Invalid load: ${this.entityClassName} (${String(fieldName)} = ${
           fieldValues[nullOrUndefinedValueIndex]
-        })`
+        })`,
       );
     }
 
@@ -153,18 +153,18 @@ export default class EntityDataManager<TFields> {
   async loadManyByFieldEqualityConjunctionAsync<N extends keyof TFields>(
     queryContext: EntityQueryContext,
     fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
-    querySelectionModifiers: QuerySelectionModifiers<TFields>
+    querySelectionModifiers: QuerySelectionModifiers<TFields>,
   ): Promise<readonly Readonly<TFields>[]> {
     return await timeAndLogLoadEventAsync(
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
-      this.entityClassName
+      this.entityClassName,
     )(
       this.databaseAdapter.fetchManyByFieldEqualityConjunctionAsync(
         queryContext,
         fieldEqualityOperands,
-        querySelectionModifiers
-      )
+        querySelectionModifiers,
+      ),
     );
   }
 
@@ -181,25 +181,25 @@ export default class EntityDataManager<TFields> {
     queryContext: EntityQueryContext,
     rawWhereClause: string,
     bindings: any[] | object,
-    querySelectionModifiers: QuerySelectionModifiersWithOrderByRaw<TFields>
+    querySelectionModifiers: QuerySelectionModifiersWithOrderByRaw<TFields>,
   ): Promise<readonly Readonly<TFields>[]> {
     return await timeAndLogLoadEventAsync(
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY_RAW,
-      this.entityClassName
+      this.entityClassName,
     )(
       this.databaseAdapter.fetchManyByRawWhereClauseAsync(
         queryContext,
         rawWhereClause,
         bindings,
-        querySelectionModifiers
-      )
+        querySelectionModifiers,
+      ),
     );
   }
 
   private async invalidateManyByFieldEqualingAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {
     await this.entityCache.invalidateManyAsync(fieldName, fieldValues);
     const dataLoader = this.getFieldDataLoaderForFieldName(fieldName);
@@ -222,7 +222,7 @@ export default class EntityDataManager<TFields> {
             value as NonNullable<TFields[keyof TFields]>,
           ]);
         }
-      })
+      }),
     );
   }
 }