@expo/entity 0.35.0 → 0.36.0

package/src/__tests__/EntitySelfReferentialEdges-test.ts

@@ -96,25 +96,33 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
     await CategoryEntity.enforceDeleteAsync(parentCategory);
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.toBeNull();
   });
 
@@ -135,10 +143,10 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     await CategoryEntity.enforceDeleteAsync(categoryA);
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryB.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryB.getID()),
     ).resolves.toBeNull();
   });
 });
@@ -159,19 +167,25 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
     await CategoryEntity.enforceDeleteAsync(parentCategory);
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
 
     const loadedSubCategory = await CategoryEntity.loader(viewerContext)
@@ -211,7 +225,7 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
 describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
   it('invalidates the cache', async () => {
     const { CategoryEntity } = makeEntityClass(
-      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY
+      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY,
     );
 
     const companionProvider = createUnitTestEntityCompanionProvider();
@@ -226,21 +240,23 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
       CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', parentCategory.getID())
+        .loadByFieldEqualingAsync('parent_category_id', parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
       CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', subCategory.getID())
+        .loadByFieldEqualingAsync('parent_category_id', subCategory.getID()),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
-      CategoryEntity
+      CategoryEntity,
     )['entityCompanion']['tableDataCoordinator'][
       'cacheAdapter'
     ] as InMemoryFullCacheStubCacheAdapter<CategoryFields>;
@@ -251,7 +267,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
 
     const subSubCategoryCachedBefore = await categoryCacheAdapter.loadManyAsync(
       'parent_category_id',
-      [subCategory.getID()]
+      [subCategory.getID()],
     );
     expect(subSubCategoryCachedBefore.get(subCategory.getID())?.status).toEqual(CacheStatus.HIT);
 
@@ -264,24 +280,28 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
 
     const subSubCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync(
       'parent_category_id',
-      [subCategory.getID()]
+      [subCategory.getID()],
     );
     expect(subSubCategoryCachedAfter.get(subCategory.getID())?.status).toEqual(CacheStatus.MISS);
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
   });
 
   it('handles cycles', async () => {
     const { CategoryEntity } = makeEntityClass(
-      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY
+      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY,
     );
 
     const companionProvider = createUnitTestEntityCompanionProvider();
@@ -298,16 +318,16 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     await expect(
       CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryA.getID())
+        .loadByFieldEqualingAsync('parent_category_id', categoryA.getID()),
     ).resolves.not.toBeNull();
     await expect(
       CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryB.getID())
+        .loadByFieldEqualingAsync('parent_category_id', categoryB.getID()),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
-      CategoryEntity
+      CategoryEntity,
     )['entityCompanion']['tableDataCoordinator'][
       'cacheAdapter'
     ] as InMemoryFullCacheStubCacheAdapter<CategoryFields>;

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -20,7 +20,7 @@ describe(GenericEntityCacheAdapter, () => {
           ['id.wat', { status: CacheStatus.HIT, item: { id: 'wat' } }],
           ['id.who', { status: CacheStatus.NEGATIVE }],
           ['id.why', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
@@ -55,7 +55,7 @@ describe(GenericEntityCacheAdapter, () => {
       await cacheAdapter.cacheManyAsync('id', new Map([['wat', { id: 'wat' }]]));
 
       verify(
-        mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]])))
+        mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]]))),
       ).once();
     });
   });

package/src/__tests__/ViewerContext-test.ts

@@ -22,7 +22,7 @@ describe(ViewerContext, () => {
           'postgres',
           async (queryContext) => {
             return queryContext.isInTransaction();
-          }
+          },
         );
       expect(didCreateTransaction).toBe(true);
     });

package/src/__tests__/ViewerScopedEntityCompanion-test.ts

@@ -23,10 +23,10 @@ describe(ViewerScopedEntityCompanion, () => {
       >();
     const viewerScopedEntityCompanion = new ViewerScopedEntityCompanion(entityCompanion, vc);
     expect(viewerScopedEntityCompanion.getLoaderFactory()).toBeInstanceOf(
-      ViewerScopedEntityLoaderFactory
+      ViewerScopedEntityLoaderFactory,
     );
     expect(viewerScopedEntityCompanion.getMutatorFactory()).toBeInstanceOf(
-      ViewerScopedEntityMutatorFactory
+      ViewerScopedEntityMutatorFactory,
     );
   });
 });

package/src/__tests__/ViewerScopedEntityCompanionProvider-test.ts

@@ -12,10 +12,10 @@ describe(ViewerScopedEntityCompanionProvider, () => {
     const entityCompanionProvider = instance(mock(EntityCompanionProvider));
     const viewerScopedEntityCompanionProvider = new ViewerScopedEntityCompanionProvider(
       entityCompanionProvider,
-      vc
+      vc,
     );
     expect(
-      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(TestEntity)
+      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(TestEntity),
     ).toBeInstanceOf(ViewerScopedEntityCompanion);
   });
 });

package/src/__tests__/ViewerScopedEntityLoaderFactory-test.ts

@@ -9,7 +9,8 @@ import ViewerScopedEntityLoaderFactory from '../ViewerScopedEntityLoaderFactory'
 describe(ViewerScopedEntityLoaderFactory, () => {
   it('correctly scopes viewer to entity loads', async () => {
     const viewerContext = instance(mock(ViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const privacyPolicyEvaluationContext =
+      instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>());
     const queryContext = instance(mock(EntityQueryContext));
     const baseLoader = mock<EntityLoaderFactory<any, any, any, any, any, any>>(EntityLoaderFactory);
     const baseLoaderInstance = instance(baseLoader);

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

@@ -1,7 +1,7 @@
 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';
@@ -28,17 +28,16 @@ describe('Two entities backed by the same table', () => {
     expect(two).toBeInstanceOf(TwoTestEntity);
 
     await expect(
-      TwoTestEntity.loader(viewerContext).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).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).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);
 
@@ -47,22 +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
-    ).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);
@@ -98,8 +97,9 @@ 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',

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,
@@ -78,9 +78,9 @@ export default class EntityDataManager<TFields> {
         return await this.databaseAdapter.fetchManyWhereAsync(
           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]>,
           ]);
         }
-      })
+      }),
     );
   }
 }