@expo/entity 0.35.0 → 0.36.0

package/src/__tests__/EntityPrivacyPolicy-test.ts

@@ -69,7 +69,7 @@ class AlwaysDenyPolicy extends EntityPrivacyPolicy<BlahFields, string, ViewerCon
 class DryRunAlwaysDenyPolicy extends AlwaysDenyPolicy {
   // public method for test spying
   public denyHandler(
-    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>
+    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>,
   ): void {}
 
   protected override getPrivacyPolicyEvaluator(): EntityPrivacyPolicyEvaluator<
@@ -88,7 +88,7 @@ class DryRunAlwaysDenyPolicy extends AlwaysDenyPolicy {
 class LoggingEnforceAlwaysDenyPolicy extends AlwaysDenyPolicy {
   // public method for test spying
   public denyHandler(
-    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>
+    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>,
   ): void {}
 
   protected override getPrivacyPolicyEvaluator(): EntityPrivacyPolicyEvaluator<
@@ -122,7 +122,7 @@ class AlwaysAllowPolicy extends EntityPrivacyPolicy<BlahFields, string, ViewerCo
 class DryRunAlwaysAllowPolicy extends AlwaysAllowPolicy {
   // public method for test spying
   public denyHandler(
-    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>
+    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>,
   ): void {}
 
   protected override getPrivacyPolicyEvaluator(): EntityPrivacyPolicyEvaluator<
@@ -141,7 +141,7 @@ class DryRunAlwaysAllowPolicy extends AlwaysAllowPolicy {
 class LoggingEnforceAlwaysAllowPolicy extends AlwaysAllowPolicy {
   // public method for test spying
   public denyHandler(
-    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>
+    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>,
   ): void {}
 
   protected override getPrivacyPolicyEvaluator(): EntityPrivacyPolicyEvaluator<
@@ -172,6 +172,30 @@ class SkipAllPolicy extends EntityPrivacyPolicy<BlahFields, string, ViewerContex
   ];
 }
 
+class InvalidCreateRuleResultPolicy extends EntityPrivacyPolicy<
+  BlahFields,
+  string,
+  ViewerContext,
+  BlahEntity
+> {
+  protected override readonly createRules = [
+    {
+      async evaluateAsync(): Promise<RuleEvaluationResult> {
+        return 2 as any;
+      },
+    },
+  ];
+  protected override readonly readRules = [
+    new AlwaysSkipPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+  ];
+  protected override readonly updateRules = [
+    new AlwaysSkipPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+  ];
+  protected override readonly deleteRules = [
+    new AlwaysSkipPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+  ];
+}
+
 class AlwaysThrowPrivacyPolicyRule extends PrivacyPolicyRule<
   BlahFields,
   string,
@@ -181,8 +205,13 @@ class AlwaysThrowPrivacyPolicyRule extends PrivacyPolicyRule<
   evaluateAsync(
     _viewerContext: ViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: BlahEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      BlahFields,
+      string,
+      ViewerContext,
+      BlahEntity
+    >,
+    _entity: BlahEntity,
   ): Promise<RuleEvaluationResult> {
     throw new Error('WooHoo!');
   }
@@ -198,7 +227,7 @@ class ThrowAllPolicy extends EntityPrivacyPolicy<BlahFields, string, ViewerConte
 class DryRunThrowAllPolicy extends ThrowAllPolicy {
   // public method for test spying
   public denyHandler(
-    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>
+    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>,
   ): void {}
 
   protected override getPrivacyPolicyEvaluator(): EntityPrivacyPolicyEvaluator<
@@ -217,7 +246,7 @@ class DryRunThrowAllPolicy extends ThrowAllPolicy {
 class LoggingEnforceThrowAllPolicy extends ThrowAllPolicy {
   // public method for test spying
   public denyHandler(
-    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>
+    _error: EntityNotAuthorizedError<BlahFields, string, ViewerContext, BlahEntity>,
   ): void {}
 
   protected override getPrivacyPolicyEvaluator(): EntityPrivacyPolicyEvaluator<
@@ -245,7 +274,12 @@ describe(EntityPrivacyPolicy, () => {
     it('throws EntityNotAuthorizedError when deny', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -261,8 +295,8 @@ describe(EntityPrivacyPolicy, () => {
           queryContext,
           privacyPolicyEvaluationContext,
           entity,
-          metricsAdapter
-        )
+          metricsAdapter,
+        ),
       ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
       verify(
         metricsAdapterMock.logAuthorizationEvent(
@@ -271,15 +305,20 @@ describe(EntityPrivacyPolicy, () => {
             action: EntityAuthorizationAction.CREATE,
             evaluationResult: EntityMetricsAuthorizationResult.DENY,
             privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode.ENFORCE,
-          })
-        )
+          }),
+        ),
       ).once();
     });
 
     it('returns entity when allowed', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -294,7 +333,7 @@ describe(EntityPrivacyPolicy, () => {
         queryContext,
         privacyPolicyEvaluationContext,
         entity,
-        metricsAdapter
+        metricsAdapter,
       );
       expect(approvedEntity).toEqual(entity);
       verify(
@@ -304,15 +343,20 @@ describe(EntityPrivacyPolicy, () => {
             action: EntityAuthorizationAction.CREATE,
             evaluationResult: EntityMetricsAuthorizationResult.ALLOW,
             privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode.ENFORCE,
-          })
-        )
+          }),
+        ),
       ).once();
     });
 
     it('throws EntityNotAuthorizedError when all skipped', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -328,8 +372,8 @@ describe(EntityPrivacyPolicy, () => {
           queryContext,
           privacyPolicyEvaluationContext,
           entity,
-          metricsAdapter
-        )
+          metricsAdapter,
+        ),
       ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
       verify(
         metricsAdapterMock.logAuthorizationEvent(
@@ -338,15 +382,49 @@ describe(EntityPrivacyPolicy, () => {
             action: EntityAuthorizationAction.CREATE,
             evaluationResult: EntityMetricsAuthorizationResult.DENY,
             privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode.ENFORCE,
-          })
-        )
+          }),
+        ),
       ).once();
     });
 
+    it('throws when an invalid result is returned', async () => {
+      const viewerContext = instance(mock(ViewerContext));
+      const queryContext = instance(mock(EntityQueryContext));
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
+      const metricsAdapterMock = mock<IEntityMetricsAdapter>();
+      const metricsAdapter = instance(metricsAdapterMock);
+      const entity = new BlahEntity({
+        viewerContext,
+        id: '1',
+        databaseFields: { id: '1' },
+        selectedFields: { id: '1' },
+      });
+      const policy = new InvalidCreateRuleResultPolicy();
+      await expect(
+        policy.authorizeCreateAsync(
+          viewerContext,
+          queryContext,
+          privacyPolicyEvaluationContext,
+          entity,
+          metricsAdapter,
+        ),
+      ).rejects.toThrow('Invalid RuleEvaluationResult returned from rule');
+    });
+
     it('throws EntityNotAuthorizedError when empty policy', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -362,8 +440,8 @@ describe(EntityPrivacyPolicy, () => {
           queryContext,
           privacyPolicyEvaluationContext,
           entity,
-          metricsAdapter
-        )
+          metricsAdapter,
+        ),
       ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
       verify(
         metricsAdapterMock.logAuthorizationEvent(
@@ -372,15 +450,20 @@ describe(EntityPrivacyPolicy, () => {
             action: EntityAuthorizationAction.CREATE,
             evaluationResult: EntityMetricsAuthorizationResult.DENY,
             privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode.ENFORCE,
-          })
-        )
+          }),
+        ),
       ).once();
     });
 
     it('throws when rule throws', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -396,8 +479,8 @@ describe(EntityPrivacyPolicy, () => {
           queryContext,
           privacyPolicyEvaluationContext,
           entity,
-          metricsAdapter
-        )
+          metricsAdapter,
+        ),
       ).rejects.toThrowError('WooHoo!');
       verify(metricsAdapterMock.logAuthorizationEvent(anything())).never();
     });
@@ -407,7 +490,12 @@ describe(EntityPrivacyPolicy, () => {
     it('returns entity when denied but calls denialHandler', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -425,7 +513,7 @@ describe(EntityPrivacyPolicy, () => {
         queryContext,
         privacyPolicyEvaluationContext,
         entity,
-        metricsAdapter
+        metricsAdapter,
       );
       expect(approvedEntity).toEqual(entity);
 
@@ -438,15 +526,20 @@ describe(EntityPrivacyPolicy, () => {
             action: EntityAuthorizationAction.CREATE,
             evaluationResult: EntityMetricsAuthorizationResult.DENY,
             privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode.DRY_RUN,
-          })
-        )
+          }),
+        ),
       ).once();
     });
 
     it('does not log when not denied', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -464,7 +557,7 @@ describe(EntityPrivacyPolicy, () => {
         queryContext,
         privacyPolicyEvaluationContext,
         entity,
-        metricsAdapter
+        metricsAdapter,
       );
       expect(approvedEntity).toEqual(entity);
 
@@ -477,15 +570,20 @@ describe(EntityPrivacyPolicy, () => {
             action: EntityAuthorizationAction.CREATE,
             evaluationResult: EntityMetricsAuthorizationResult.ALLOW,
             privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode.DRY_RUN,
-          })
-        )
+          }),
+        ),
       ).once();
     });
 
     it('passes through other errors', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -504,8 +602,8 @@ describe(EntityPrivacyPolicy, () => {
           queryContext,
           privacyPolicyEvaluationContext,
           entity,
-          metricsAdapter
-        )
+          metricsAdapter,
+        ),
       ).rejects.toThrowError('WooHoo!');
 
       verify(policySpy.denyHandler(anyOfClass(EntityNotAuthorizedError))).never();
@@ -518,7 +616,12 @@ describe(EntityPrivacyPolicy, () => {
     it('denies when denied but calls denialHandler', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -537,8 +640,8 @@ describe(EntityPrivacyPolicy, () => {
           queryContext,
           privacyPolicyEvaluationContext,
           entity,
-          metricsAdapter
-        )
+          metricsAdapter,
+        ),
       ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
       verify(policySpy.denyHandler(anyOfClass(EntityNotAuthorizedError))).once();
@@ -550,15 +653,20 @@ describe(EntityPrivacyPolicy, () => {
             action: EntityAuthorizationAction.CREATE,
             evaluationResult: EntityMetricsAuthorizationResult.DENY,
             privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode.ENFORCE_AND_LOG,
-          })
-        )
+          }),
+        ),
       ).once();
     });
 
     it('does not log when not denied', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -576,7 +684,7 @@ describe(EntityPrivacyPolicy, () => {
         queryContext,
         privacyPolicyEvaluationContext,
         entity,
-        metricsAdapter
+        metricsAdapter,
       );
       expect(approvedEntity).toEqual(entity);
 
@@ -589,15 +697,20 @@ describe(EntityPrivacyPolicy, () => {
             action: EntityAuthorizationAction.CREATE,
             evaluationResult: EntityMetricsAuthorizationResult.ALLOW,
             privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode.ENFORCE_AND_LOG,
-          })
-        )
+          }),
+        ),
       ).once();
     });
 
     it('passes through other errors', async () => {
       const viewerContext = instance(mock(ViewerContext));
       const queryContext = instance(mock(EntityQueryContext));
-      const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<BlahFields, string, ViewerContext, BlahEntity>
+          >(),
+        );
       const metricsAdapterMock = mock<IEntityMetricsAdapter>();
       const metricsAdapter = instance(metricsAdapterMock);
       const entity = new BlahEntity({
@@ -616,8 +729,8 @@ describe(EntityPrivacyPolicy, () => {
           queryContext,
           privacyPolicyEvaluationContext,
           entity,
-          metricsAdapter
-        )
+          metricsAdapter,
+        ),
       ).rejects.toThrowError('WooHoo!');
 
       verify(policySpy.denyHandler(anyOfClass(EntityNotAuthorizedError))).never();

package/src/__tests__/EntityQueryContext-test.ts

@@ -15,25 +15,25 @@ describe(EntityQueryContext, () => {
       const postCommitInvalidationCallback = jest.fn(async (): Promise<void> => {
         invariant(
           preCommitFirstCallback.mock.calls.length === 1,
-          'preCommit should be called before postCommitInvalidation'
+          'preCommit should be called before postCommitInvalidation',
         );
         invariant(
           preCommitSecondCallback.mock.calls.length === 1,
-          'preCommit should be called before postCommitInvalidation'
+          'preCommit should be called before postCommitInvalidation',
         );
       });
       const postCommitCallback = jest.fn(async (): Promise<void> => {
         invariant(
           preCommitFirstCallback.mock.calls.length === 1,
-          'preCommit should be called before postCommit'
+          'preCommit should be called before postCommit',
         );
         invariant(
           preCommitSecondCallback.mock.calls.length === 1,
-          'preCommit should be called before postCommit'
+          'preCommit should be called before postCommit',
         );
         invariant(
           postCommitInvalidationCallback.mock.calls.length === 1,
-          'postCommitInvalidation should be called before postCommit'
+          'postCommitInvalidation should be called before postCommit',
         );
       });
 
@@ -44,7 +44,7 @@ describe(EntityQueryContext, () => {
           queryContext.appendPostCommitInvalidationCallback(postCommitInvalidationCallback);
           queryContext.appendPreCommitCallback(preCommitSecondCallback, 2);
           queryContext.appendPreCommitCallback(preCommitFirstCallback, 1);
-        }
+        },
       );
 
       expect(preCommitFirstCallback).toHaveBeenCalledTimes(1);
@@ -70,8 +70,8 @@ describe(EntityQueryContext, () => {
             queryContext.appendPostCommitCallback(postCommitCallback);
             queryContext.appendPostCommitInvalidationCallback(postCommitInvalidationCallback);
             queryContext.appendPreCommitCallback(preCommitCallback, 0);
-          }
-        )
+          },
+        ),
       ).rejects.toThrowError('wat');
 
       expect(preCommitCallback).toHaveBeenCalledTimes(1);
@@ -102,7 +102,7 @@ describe(EntityQueryContext, () => {
             queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
               innerQueryContext.appendPostCommitCallback(postCommitCallback);
               innerQueryContext.appendPostCommitInvalidationCallback(
-                postCommitInvalidationCallback
+                postCommitInvalidationCallback,
               );
               innerQueryContext.appendPreCommitCallback(preCommitNestedCallback, 0);
             }),
@@ -112,14 +112,14 @@ describe(EntityQueryContext, () => {
                   // these two shouldn't be called
                   innerQueryContext.appendPostCommitCallback(postCommitCallback);
                   innerQueryContext.appendPostCommitInvalidationCallback(
-                    postCommitInvalidationCallback
+                    postCommitInvalidationCallback,
                   );
                   innerQueryContext.appendPreCommitCallback(preCommitNestedCallbackThrow, 0);
                 });
               } catch {}
             })(),
           ]);
-        }
+        },
       );
 
       expect(preCommitCallback).toHaveBeenCalledTimes(1);
@@ -128,6 +128,24 @@ describe(EntityQueryContext, () => {
       expect(postCommitCallback).toHaveBeenCalledTimes(2);
       expect(postCommitInvalidationCallback).toHaveBeenCalledTimes(2);
     });
+
+    it('does not support calling runPostCommitCallbacksAsync on nested transaction', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+
+      await expect(
+        viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+          'postgres',
+          async (queryContext) => {
+            await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+              await innerQueryContext.runPostCommitCallbacksAsync();
+            });
+          },
+        ),
+      ).rejects.toThrowError(
+        'Must not call runPostCommitCallbacksAsync on EntityNestedTransactionalQueryContext',
+      );
+    });
   });
 
   describe('transaction config', () => {
@@ -145,7 +163,7 @@ describe(EntityQueryContext, () => {
       await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
         'postgres',
         transactionScopeFn,
-        transactionConfig
+        transactionConfig,
       );
 
       expect(queryContextProviderSpy).toHaveBeenCalledWith(transactionScopeFn, transactionConfig);

package/src/__tests__/EntitySecondaryCacheLoader-test.ts

@@ -20,7 +20,7 @@ class TestSecondaryRedisCacheLoader extends EntitySecondaryCacheLoader<
   SimpleTestEntityPrivacyPolicy
 > {
   protected async fetchObjectsFromDatabaseAsync(
-    _loadParamsArray: readonly Readonly<TestLoadParams>[]
+    _loadParamsArray: readonly Readonly<TestLoadParams>[],
   ): Promise<ReadonlyMap<Readonly<TestLoadParams>, Readonly<SimpleTestFields>>> {
     // unused
     return new Map();
@@ -38,19 +38,19 @@ describe(EntitySecondaryCacheLoader, () => {
       const secondaryEntityCacheMock =
         mock<ISecondaryEntityCache<SimpleTestFields, TestLoadParams>>();
       when(
-        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything())
+        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything()),
       ).thenResolve(new Map());
       const secondaryEntityCache = instance(secondaryEntityCacheMock);
 
       const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(
         secondaryEntityCache,
-        SimpleTestEntity.loader(vc1)
+        SimpleTestEntity.loader(vc1),
       );
 
       await secondaryCacheLoader.loadManyAsync([loadParams]);
 
       verify(
-        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything())
+        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything()),
       ).once();
     });
 
@@ -63,7 +63,7 @@ describe(EntitySecondaryCacheLoader, () => {
       const secondaryEntityCacheMock =
         mock<ISecondaryEntityCache<SimpleTestFields, TestLoadParams>>();
       when(
-        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything())
+        secondaryEntityCacheMock.loadManyThroughAsync(deepEqual([loadParams]), anything()),
       ).thenResolve(new Map([[loadParams, createdEntity.getAllFields()]]));
       const secondaryEntityCache = instance(secondaryEntityCacheMock);
 
@@ -80,8 +80,8 @@ describe(EntitySecondaryCacheLoader, () => {
           anyOfClass(EntityNonTransactionalQueryContext),
           anything(),
           anything(),
-          anything()
-        )
+          anything(),
+        ),
       ).once();
     });
   });