@expo/entity 0.34.0 → 0.36.0

package/src/EntityMutatorFactory.ts

@@ -26,7 +26,7 @@ export default class EntityMutatorFactory<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > {
   constructor(
     private readonly entityCompanionProvider: EntityCompanionProvider,
@@ -63,7 +63,7 @@ export default class EntityMutatorFactory<
       TSelectedFields
     >,
     private readonly databaseAdapter: EntityDatabaseAdapter<TFields>,
-    private readonly metricsAdapter: IEntityMetricsAdapter
+    private readonly metricsAdapter: IEntityMetricsAdapter,
   ) {}
 
   /**
@@ -74,7 +74,7 @@ export default class EntityMutatorFactory<
    */
   forCreate(
     viewerContext: TViewerContext,
-    queryContext: EntityQueryContext
+    queryContext: EntityQueryContext,
   ): CreateMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return new CreateMutator(
       this.entityCompanionProvider,
@@ -87,7 +87,7 @@ export default class EntityMutatorFactory<
       this.mutationTriggers,
       this.entityLoaderFactory,
       this.databaseAdapter,
-      this.metricsAdapter
+      this.metricsAdapter,
     );
   }
 
@@ -99,7 +99,7 @@ export default class EntityMutatorFactory<
    */
   forUpdate(
     existingEntity: TEntity,
-    queryContext: EntityQueryContext
+    queryContext: EntityQueryContext,
   ): UpdateMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return new UpdateMutator(
       this.entityCompanionProvider,
@@ -113,7 +113,7 @@ export default class EntityMutatorFactory<
       this.entityLoaderFactory,
       this.databaseAdapter,
       this.metricsAdapter,
-      existingEntity
+      existingEntity,
     );
   }
 
@@ -124,7 +124,7 @@ export default class EntityMutatorFactory<
    */
   forDelete(
     existingEntity: TEntity,
-    queryContext: EntityQueryContext
+    queryContext: EntityQueryContext,
   ): DeleteMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return new DeleteMutator(
       this.entityCompanionProvider,
@@ -138,7 +138,7 @@ export default class EntityMutatorFactory<
       this.entityLoaderFactory,
       this.databaseAdapter,
       this.metricsAdapter,
-      existingEntity
+      existingEntity,
     );
   }
 }

package/src/EntityPrivacyPolicy.ts

@@ -11,7 +11,19 @@ import PrivacyPolicyRule, { RuleEvaluationResult } from './rules/PrivacyPolicyRu
 /**
  * Information about the reason this privacy policy is being evaluated.
  */
-export type EntityPrivacyPolicyEvaluationContext = {
+export type EntityPrivacyPolicyEvaluationContext<
+  TFields extends object,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields = keyof TFields,
+> = {
+  /**
+   * When this privacy policy is being evaluated as a result of an update, this will be populated with the value
+   * of the entity before the update. Note that this doesn't only apply to UPDATE authorization actions though:
+   * when an entity is updated it is re-LOADed after the update completes.
+   */
+  previousValue: TEntity | null;
   /**
    * When this privacy policy is being evaluated as a result of a cascading deletion, this will be populated
    * with information on the cascading delete.
@@ -45,7 +57,7 @@ export type EntityPrivacyPolicyEvaluator<
   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,
 > =
   | {
       mode: EntityPrivacyPolicyEvaluationMode.ENFORCE;
@@ -53,13 +65,13 @@ export type EntityPrivacyPolicyEvaluator<
   | {
       mode: EntityPrivacyPolicyEvaluationMode.DRY_RUN;
       denyHandler: (
-        error: EntityNotAuthorizedError<TFields, TID, TViewerContext, TEntity, TSelectedFields>
+        error: EntityNotAuthorizedError<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
       ) => void;
     }
   | {
       mode: EntityPrivacyPolicyEvaluationMode.ENFORCE_AND_LOG;
       denyHandler: (
-        error: EntityNotAuthorizedError<TFields, TID, TViewerContext, TEntity, TSelectedFields>
+        error: EntityNotAuthorizedError<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
       ) => void;
     };
 
@@ -96,7 +108,7 @@ export default abstract class EntityPrivacyPolicy<
   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,
 > {
   protected readonly createRules: readonly PrivacyPolicyRule<
     TFields,
@@ -136,7 +148,7 @@ export default abstract class EntityPrivacyPolicy<
    * Override to enable dry run evaluation of the policy.
    */
   protected getPrivacyPolicyEvaluator(
-    _viewerContext: TViewerContext
+    _viewerContext: TViewerContext,
   ): EntityPrivacyPolicyEvaluator<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
     return {
       mode: EntityPrivacyPolicyEvaluationMode.ENFORCE,
@@ -154,9 +166,15 @@ export default abstract class EntityPrivacyPolicy<
   async authorizeCreateAsync(
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
     entity: TEntity,
-    metricsAdapter: IEntityMetricsAdapter
+    metricsAdapter: IEntityMetricsAdapter,
   ): Promise<TEntity> {
     return await this.authorizeForRulesetAsync(
       this.createRules,
@@ -165,7 +183,7 @@ export default abstract class EntityPrivacyPolicy<
       evaluationContext,
       entity,
       EntityAuthorizationAction.CREATE,
-      metricsAdapter
+      metricsAdapter,
     );
   }
 
@@ -180,9 +198,15 @@ export default abstract class EntityPrivacyPolicy<
   async authorizeReadAsync(
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
     entity: TEntity,
-    metricsAdapter: IEntityMetricsAdapter
+    metricsAdapter: IEntityMetricsAdapter,
   ): Promise<TEntity> {
     return await this.authorizeForRulesetAsync(
       this.readRules,
@@ -191,7 +215,7 @@ export default abstract class EntityPrivacyPolicy<
       evaluationContext,
       entity,
       EntityAuthorizationAction.READ,
-      metricsAdapter
+      metricsAdapter,
     );
   }
 
@@ -206,9 +230,15 @@ export default abstract class EntityPrivacyPolicy<
   async authorizeUpdateAsync(
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
     entity: TEntity,
-    metricsAdapter: IEntityMetricsAdapter
+    metricsAdapter: IEntityMetricsAdapter,
   ): Promise<TEntity> {
     return await this.authorizeForRulesetAsync(
       this.updateRules,
@@ -217,7 +247,7 @@ export default abstract class EntityPrivacyPolicy<
       evaluationContext,
       entity,
       EntityAuthorizationAction.UPDATE,
-      metricsAdapter
+      metricsAdapter,
     );
   }
 
@@ -232,9 +262,15 @@ export default abstract class EntityPrivacyPolicy<
   async authorizeDeleteAsync(
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
     entity: TEntity,
-    metricsAdapter: IEntityMetricsAdapter
+    metricsAdapter: IEntityMetricsAdapter,
   ): Promise<TEntity> {
     return await this.authorizeForRulesetAsync(
       this.deleteRules,
@@ -243,7 +279,7 @@ export default abstract class EntityPrivacyPolicy<
       evaluationContext,
       entity,
       EntityAuthorizationAction.DELETE,
-      metricsAdapter
+      metricsAdapter,
     );
   }
 
@@ -251,10 +287,16 @@ export default abstract class EntityPrivacyPolicy<
     ruleset: readonly PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>[],
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
     entity: TEntity,
     action: EntityAuthorizationAction,
-    metricsAdapter: IEntityMetricsAdapter
+    metricsAdapter: IEntityMetricsAdapter,
   ): Promise<TEntity> {
     const privacyPolicyEvaluator = this.getPrivacyPolicyEvaluator(viewerContext);
     switch (privacyPolicyEvaluator.mode) {
@@ -266,7 +308,7 @@ export default abstract class EntityPrivacyPolicy<
             queryContext,
             evaluationContext,
             entity,
-            action
+            action,
           );
           metricsAdapter.logAuthorizationEvent({
             entityClassName: entity.constructor.name,
@@ -295,7 +337,7 @@ export default abstract class EntityPrivacyPolicy<
             queryContext,
             evaluationContext,
             entity,
-            action
+            action,
           );
           metricsAdapter.logAuthorizationEvent({
             entityClassName: entity.constructor.name,
@@ -325,7 +367,7 @@ export default abstract class EntityPrivacyPolicy<
             queryContext,
             evaluationContext,
             entity,
-            action
+            action,
           );
           metricsAdapter.logAuthorizationEvent({
             entityClassName: entity.constructor.name,
@@ -354,9 +396,15 @@ export default abstract class EntityPrivacyPolicy<
     ruleset: readonly PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>[],
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
     entity: TEntity,
-    action: EntityAuthorizationAction
+    action: EntityAuthorizationAction,
   ): Promise<TEntity> {
     for (let i = 0; i < ruleset.length; i++) {
       const rule = ruleset[i]!;
@@ -364,7 +412,7 @@ export default abstract class EntityPrivacyPolicy<
         viewerContext,
         queryContext,
         evaluationContext,
-        entity
+        entity,
       );
       switch (ruleEvaluationResult) {
         case RuleEvaluationResult.DENY:
@@ -380,7 +428,9 @@ export default abstract class EntityPrivacyPolicy<
         case RuleEvaluationResult.ALLOW:
           return entity;
         default:
-          throw new Error('should not be a fourth type of rule evaluation result');
+          throw new Error(
+            `Invalid RuleEvaluationResult returned from rule: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${i})`,
+          );
       }
     }
 
@@ -388,7 +438,7 @@ export default abstract class EntityPrivacyPolicy<
       entity,
       viewerContext,
       action,
-      -1
+      -1,
     );
   }
 }

package/src/EntityQueryContext.ts

@@ -36,7 +36,7 @@ export abstract class EntityQueryContext {
 
   abstract runInTransactionIfNotInTransactionAsync<T>(
     transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
-    transactionConfig?: TransactionConfig
+    transactionConfig?: TransactionConfig,
   ): Promise<T>;
 }
 
@@ -49,7 +49,7 @@ export abstract class EntityQueryContext {
 export class EntityNonTransactionalQueryContext extends EntityQueryContext {
   constructor(
     queryInterface: any,
-    private readonly entityQueryContextProvider: EntityQueryContextProvider
+    private readonly entityQueryContextProvider: EntityQueryContextProvider,
   ) {
     super(queryInterface);
   }
@@ -60,11 +60,11 @@ export class EntityNonTransactionalQueryContext extends EntityQueryContext {
 
   async runInTransactionIfNotInTransactionAsync<T>(
     transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
-    transactionConfig?: TransactionConfig
+    transactionConfig?: TransactionConfig,
   ): Promise<T> {
     return await this.entityQueryContextProvider.runInTransactionAsync(
       transactionScope,
-      transactionConfig
+      transactionConfig,
     );
   }
 }
@@ -82,7 +82,7 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
 
   constructor(
     queryInterface: any,
-    private readonly entityQueryContextProvider: EntityQueryContextProvider
+    private readonly entityQueryContextProvider: EntityQueryContextProvider,
   ) {
     super(queryInterface);
   }
@@ -98,7 +98,7 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
   public appendPreCommitCallback(callback: PreCommitCallback, order: number): void {
     assert(
       order >= Number.MIN_SAFE_INTEGER && order <= Number.MAX_SAFE_INTEGER,
-      `Invalid order specified: ${order}`
+      `Invalid order specified: ${order}`,
     );
     this.preCommitCallbacks.push({ callback, order });
   }
@@ -148,21 +148,21 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
 
   async runInTransactionIfNotInTransactionAsync<T>(
     transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
-    transactionConfig?: TransactionConfig
+    transactionConfig?: TransactionConfig,
   ): Promise<T> {
     assert(
       transactionConfig === undefined,
-      'Should not pass transactionConfig to a nested transaction'
+      'Should not pass transactionConfig to a nested transaction',
     );
     return await transactionScope(this);
   }
 
   async runInNestedTransactionAsync<T>(
-    transactionScope: (innerQueryContext: EntityTransactionalQueryContext) => Promise<T>
+    transactionScope: (innerQueryContext: EntityTransactionalQueryContext) => Promise<T>,
   ): Promise<T> {
     return await this.entityQueryContextProvider.runInNestedTransactionAsync(
       this,
-      transactionScope
+      transactionScope,
     );
   }
 }
@@ -172,7 +172,8 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
  * to EntityMutator and EntityLoader methods, those methods and their
  * dependent triggers and validators will run within the nested transaction.
  *
- * This exists to forward post-commit callbacks to the parent query context.
+ * This exists to forward post-commit callbacks to the parent query context but only after
+ * successful commit of the nested transaction.
  */
 export class EntityNestedTransactionalQueryContext extends EntityTransactionalQueryContext {
   private readonly postCommitInvalidationCallbacksToTransfer: PostCommitCallback[] = [];
@@ -181,7 +182,7 @@ export class EntityNestedTransactionalQueryContext extends EntityTransactionalQu
   constructor(
     queryInterface: any,
     private readonly parentQueryContext: EntityTransactionalQueryContext,
-    entityQueryContextProvider: EntityQueryContextProvider
+    entityQueryContextProvider: EntityQueryContextProvider,
   ) {
     super(queryInterface, entityQueryContextProvider);
   }
@@ -196,7 +197,7 @@ export class EntityNestedTransactionalQueryContext extends EntityTransactionalQu
 
   public override runPostCommitCallbacksAsync(): Promise<void> {
     throw new Error(
-      'Must not call runPostCommitCallbacksAsync on EntityNestedTransactionalQueryContext'
+      'Must not call runPostCommitCallbacksAsync on EntityNestedTransactionalQueryContext',
     );
   }
 

package/src/EntityQueryContextProvider.ts

@@ -12,7 +12,7 @@ export default abstract class EntityQueryContextProvider {
   /**
    * Vend a regular (non-transactional) entity query context.
    */
-  public getNonTransactionalQueryContext(): EntityNonTransactionalQueryContext {
+  public getQueryContext(): EntityNonTransactionalQueryContext {
     return new EntityNonTransactionalQueryContext(this.getQueryInterface(), this);
   }
 
@@ -25,11 +25,11 @@ export default abstract class EntityQueryContextProvider {
    * Vend a transaction runner for use in runInTransactionAsync.
    */
   protected abstract createTransactionRunner<T>(
-    transactionConfig?: TransactionConfig
+    transactionConfig?: TransactionConfig,
   ): (transactionScope: (queryInterface: any) => Promise<T>) => Promise<T>;
 
   protected abstract createNestedTransactionRunner<T>(
-    outerQueryInterface: any
+    outerQueryInterface: any,
   ): (transactionScope: (queryInterface: any) => Promise<T>) => Promise<T>;
 
   /**
@@ -38,7 +38,7 @@ export default abstract class EntityQueryContextProvider {
    */
   async runInTransactionAsync<T>(
     transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
-    transactionConfig?: TransactionConfig
+    transactionConfig?: TransactionConfig,
   ): Promise<T> {
     const [returnedValue, queryContext] = await this.createTransactionRunner<
       [T, EntityTransactionalQueryContext]
@@ -60,7 +60,7 @@ export default abstract class EntityQueryContextProvider {
    */
   async runInNestedTransactionAsync<T>(
     outerQueryContext: EntityTransactionalQueryContext,
-    transactionScope: (innerQueryContext: EntityNestedTransactionalQueryContext) => Promise<T>
+    transactionScope: (innerQueryContext: EntityNestedTransactionalQueryContext) => Promise<T>,
   ): Promise<T> {
     const [returnedValue, innerQueryContext] = await this.createNestedTransactionRunner<
       [T, EntityNestedTransactionalQueryContext]
@@ -68,7 +68,7 @@ export default abstract class EntityQueryContextProvider {
       const innerQueryContext = new EntityNestedTransactionalQueryContext(
         innerQueryInterface,
         outerQueryContext,
-        this
+        this,
       );
       const result = await transactionScope(innerQueryContext);
       await innerQueryContext.runPreCommitCallbacksAsync();

package/src/EntitySecondaryCacheLoader.ts

@@ -20,8 +20,8 @@ export interface ISecondaryEntityCache<TFields, TLoadParams> {
   loadManyThroughAsync(
     loadParamsArray: readonly Readonly<TLoadParams>[],
     fetcher: (
-      fetcherLoadParamsArray: readonly Readonly<TLoadParams>[]
-    ) => Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>>
+      fetcherLoadParamsArray: readonly Readonly<TLoadParams>[],
+    ) => Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>>,
   ): Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>>;
 
   /**
@@ -56,7 +56,7 @@ export default abstract class EntitySecondaryCacheLoader<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > {
   constructor(
     private readonly secondaryEntityCache: ISecondaryEntityCache<TFields, TLoadParams>,
@@ -67,7 +67,7 @@ export default abstract class EntitySecondaryCacheLoader<
       TEntity,
       TPrivacyPolicy,
       TSelectedFields
-    >
+    >,
   ) {}
 
   /**
@@ -76,17 +76,19 @@ export default abstract class EntitySecondaryCacheLoader<
    * @param loadParamsArray - array of loadParams to load through the cache
    */
   public async loadManyAsync(
-    loadParamsArray: readonly Readonly<TLoadParams>[]
+    loadParamsArray: readonly Readonly<TLoadParams>[],
   ): Promise<ReadonlyMap<Readonly<TLoadParams>, Result<TEntity> | null>> {
     const loadParamsToFieldObjects = await this.secondaryEntityCache.loadManyThroughAsync(
       loadParamsArray,
-      this.fetchObjectsFromDatabaseAsync.bind(this)
+      this.fetchObjectsFromDatabaseAsync.bind(this),
     );
 
     // convert value to and from array to reuse complex code
-    const entitiesMap = await this.entityLoader.constructAndAuthorizeEntitiesAsync(
-      mapMap(loadParamsToFieldObjects, (fieldObject) => (fieldObject ? [fieldObject] : []))
-    );
+    const entitiesMap = await this.entityLoader
+      .utils()
+      .constructAndAuthorizeEntitiesAsync(
+        mapMap(loadParamsToFieldObjects, (fieldObject) => (fieldObject ? [fieldObject] : [])),
+      );
     return mapMap(entitiesMap, (fieldObjects) => fieldObjects[0] ?? null);
   }
 
@@ -96,7 +98,7 @@ export default abstract class EntitySecondaryCacheLoader<
    * @param loadParamsArray - array of load params objects to invalidate
    */
   public async invalidateManyAsync(
-    loadParamsArray: readonly Readonly<TLoadParams>[]
+    loadParamsArray: readonly Readonly<TLoadParams>[],
   ): Promise<void> {
     await this.secondaryEntityCache.invalidateManyAsync(loadParamsArray);
   }
@@ -107,6 +109,6 @@ export default abstract class EntitySecondaryCacheLoader<
    * @param loadParamsArray - array of load params objects to load
    */
   protected abstract fetchObjectsFromDatabaseAsync(
-    loadParamsArray: readonly Readonly<TLoadParams>[]
+    loadParamsArray: readonly Readonly<TLoadParams>[],
   ): Promise<ReadonlyMap<Readonly<Readonly<TLoadParams>>, Readonly<TFields> | null>>;
 }

package/src/GenericEntityCacheAdapter.ts

@@ -13,16 +13,16 @@ export default class GenericEntityCacheAdapter<TFields> implements IEntityCacheA
 
   public async loadManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
     const redisCacheKeyToFieldValueMapping = new Map(
       fieldValues.map((fieldValue) => [
         this.genericCacher.makeCacheKey(fieldName, fieldValue),
         fieldValue,
-      ])
+      ]),
     );
     const cacheResults = await this.genericCacher.loadManyAsync(
-      Array.from(redisCacheKeyToFieldValueMapping.keys())
+      Array.from(redisCacheKeyToFieldValueMapping.keys()),
     );
 
     return mapKeys(cacheResults, (redisCacheKey) => {
@@ -30,7 +30,7 @@ export default class GenericEntityCacheAdapter<TFields> implements IEntityCacheA
       invariant(
         fieldValue !== undefined,
         'Unspecified cache key %s returned from generic cacher',
-        redisCacheKey
+        redisCacheKey,
       );
       return fieldValue;
     });
@@ -38,28 +38,28 @@ export default class GenericEntityCacheAdapter<TFields> implements IEntityCacheA
 
   public async cacheManyAsync<N extends keyof TFields>(
     fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
+    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
   ): Promise<void> {
     await this.genericCacher.cacheManyAsync(
-      mapKeys(objectMap, (fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue))
+      mapKeys(objectMap, (fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
     );
   }
 
   public async cacheDBMissesAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {
     await this.genericCacher.cacheDBMissesAsync(
-      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue))
+      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
     );
   }
 
   public async invalidateManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {
     await this.genericCacher.invalidateManyAsync(
-      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue))
+      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
     );
   }
 }

package/src/GenericSecondaryEntityCache.ts

@@ -15,14 +15,14 @@ export default abstract class GenericSecondaryEntityCache<TFields, TLoadParams>
 {
   constructor(
     protected readonly cacher: IEntityGenericCacher<TFields>,
-    protected readonly constructCacheKey: (params: Readonly<TLoadParams>) => string
+    protected readonly constructCacheKey: (params: Readonly<TLoadParams>) => string,
   ) {}
 
   public async loadManyThroughAsync(
     loadParamsArray: readonly Readonly<TLoadParams>[],
     fetcher: (
-      fetcherLoadParamsArray: readonly Readonly<TLoadParams>[]
-    ) => Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>>
+      fetcherLoadParamsArray: readonly Readonly<TLoadParams>[],
+    ) => Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>>,
   ): Promise<ReadonlyMap<Readonly<TLoadParams>, Readonly<TFields> | null>> {
     const cacheKeys = loadParamsArray.map(this.constructCacheKey);
     const cacheKeyToLoadParamsMap = zipToMap(cacheKeys, loadParamsArray);
@@ -31,14 +31,14 @@ export default abstract class GenericSecondaryEntityCache<TFields, TLoadParams>
 
     invariant(
       cacheLoadResults.size === loadParamsArray.length,
-      `${this.constructor.name} loadMany should return a result for each key`
+      `${this.constructor.name} loadMany should return a result for each key`,
     );
 
     const cacheKeysToFetch = Array.from(
       filterMap(
         cacheLoadResults,
-        (cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS
-      ).keys()
+        (cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS,
+      ).keys(),
     );
 
     // put cache hits in result map

package/src/IEntityCacheAdapter.ts

@@ -13,7 +13,7 @@ export default interface IEntityCacheAdapter<TFields> {
    */
   loadManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>>;
 
   /**
@@ -23,7 +23,7 @@ export default interface IEntityCacheAdapter<TFields> {
    */
   cacheManyAsync<N extends keyof TFields>(
     fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
+    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
   ): Promise<void>;
 
   /**
@@ -34,7 +34,7 @@ export default interface IEntityCacheAdapter<TFields> {
    */
   cacheDBMissesAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void>;
 
   /**
@@ -44,6 +44,6 @@ export default interface IEntityCacheAdapter<TFields> {
    */
   invalidateManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void>;
 }