@expo/entity 0.45.0 → 0.47.0

package/src/__tests__/EntityFields-test.ts

@@ -1,19 +1,21 @@
+import { describe, expect, it, test } from '@jest/globals';
 import { v1 as uuidv1, v3 as uuidv3, v4 as uuidv4, v5 as uuidv5 } from 'uuid';
 
 import { EntityFieldDefinition } from '../EntityFieldDefinition';
 import {
-  StringField,
-  UUIDField,
-  DateField,
   BooleanField,
-  IntField,
+  BufferField,
+  DateField,
+  EnumField,
   FloatField,
-  StringArrayField,
+  IntField,
   JSONObjectField,
-  EnumField,
   StrictEnumField,
+  StringArrayField,
+  StringField,
+  UUIDField,
 } from '../EntityFields';
-import describeFieldTestCase from '../utils/__testfixtures__/describeFieldTestCase';
+import { describeFieldTestCase } from '../utils/__testfixtures__/describeFieldTestCase';
 
 class TestFieldDefinition extends EntityFieldDefinition<string, false> {
   protected validateInputValueInternal(value: string): boolean {
@@ -87,3 +89,9 @@ describeFieldTestCase(
   [TestEnum.HELLO, TestEnum.WHO, 'world'],
   ['what', 1, true],
 );
+
+describeFieldTestCase(
+  new BufferField({ columnName: 'wat' }),
+  [Buffer.from('hello')],
+  ['hello', 1, true],
+);

package/src/__tests__/EntityLoader-test.ts

@@ -1,9 +1,11 @@
-import AuthorizationResultBasedEntityLoader from '../AuthorizationResultBasedEntityLoader';
-import EnforcingEntityLoader from '../EnforcingEntityLoader';
-import EntityLoader from '../EntityLoader';
-import EntityLoaderUtils from '../EntityLoaderUtils';
-import ViewerContext from '../ViewerContext';
-import SimpleTestEntity from '../utils/__testfixtures__/SimpleTestEntity';
+import { describe, expect, it } from '@jest/globals';
+
+import { AuthorizationResultBasedEntityLoader } from '../AuthorizationResultBasedEntityLoader';
+import { EnforcingEntityLoader } from '../EnforcingEntityLoader';
+import { EntityLoader } from '../EntityLoader';
+import { EntityLoaderUtils } from '../EntityLoaderUtils';
+import { ViewerContext } from '../ViewerContext';
+import { SimpleTestEntity } from '../utils/__testfixtures__/SimpleTestEntity';
 import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(EntityLoader, () => {

package/src/__tests__/EntityMutator-MutationCacheConsistency-test.ts

@@ -1,13 +1,15 @@
-import Entity from '../Entity';
+import { describe, test } from '@jest/globals';
+
+import { Entity } from '../Entity';
 import { EntityCompanionDefinition } from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
+import { EntityConfiguration } from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
 import { EntityMutationType, EntityTriggerMutationInfo } from '../EntityMutationInfo';
 import { EntityNonTransactionalMutationTrigger } from '../EntityMutationTriggerConfiguration';
-import EntityMutatorFactory from '../EntityMutatorFactory';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
-import ViewerContext from '../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
+import { EntityMutatorFactory } from '../EntityMutatorFactory';
+import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
+import { ViewerContext } from '../ViewerContext';
+import { AlwaysAllowPrivacyPolicyRule } from '../rules/AlwaysAllowPrivacyPolicyRule';
 import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 type BlahFields = {

package/src/__tests__/EntityMutator-SingleCompositeFieldCacheConsistency-test.ts

@@ -1,6 +1,8 @@
-import EntityMutatorFactory from '../EntityMutatorFactory';
-import ViewerContext from '../ViewerContext';
-import TestEntity from '../utils/__testfixtures__/TestEntity';
+import { describe, expect, test } from '@jest/globals';
+
+import { EntityMutatorFactory } from '../EntityMutatorFactory';
+import { ViewerContext } from '../ViewerContext';
+import { TestEntity } from '../utils/__testfixtures__/TestEntity';
 import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(EntityMutatorFactory, () => {

package/src/__tests__/EntityMutator-test.ts

@@ -1,55 +1,60 @@
 import { enforceAsyncResult } from '@expo/results';
+import { describe, expect, it } from '@jest/globals';
 import {
+  anyOfClass,
+  anything,
+  deepEqual,
+  instance,
   mock,
+  objectContaining,
   spy,
   verify,
-  anyOfClass,
-  instance,
   when,
-  anything,
-  objectContaining,
-  deepEqual,
 } from 'ts-mockito';
 import { v4 as uuidv4 } from 'uuid';
 
-import AuthorizationResultBasedEntityLoader from '../AuthorizationResultBasedEntityLoader';
-import EntityCompanionProvider from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
-import EntityDatabaseAdapter from '../EntityDatabaseAdapter';
-import EntityLoaderFactory from '../EntityLoaderFactory';
-import EntityLoaderUtils from '../EntityLoaderUtils';
+import { AuthorizationResultBasedEntityLoader } from '../AuthorizationResultBasedEntityLoader';
+import { EntityCompanionProvider } from '../EntityCompanionProvider';
+import { EntityConfiguration } from '../EntityConfiguration';
+import { EntityDatabaseAdapter } from '../EntityDatabaseAdapter';
+import { EntityLoaderFactory } from '../EntityLoaderFactory';
+import { EntityLoaderUtils } from '../EntityLoaderUtils';
 import {
+  EntityCascadingDeletionInfo,
   EntityMutationType,
   EntityTriggerMutationInfo,
   EntityValidatorMutationInfo,
 } from '../EntityMutationInfo';
-import EntityMutationTriggerConfiguration, {
+import {
   EntityMutationTrigger,
+  EntityMutationTriggerConfiguration,
   EntityNonTransactionalMutationTrigger,
 } from '../EntityMutationTriggerConfiguration';
-import EntityMutationValidator from '../EntityMutationValidator';
-import EntityMutatorFactory from '../EntityMutatorFactory';
+import { EntityMutationValidator } from '../EntityMutationValidator';
+import { EntityMutatorFactory } from '../EntityMutatorFactory';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
-import { EntityTransactionalQueryContext, EntityQueryContext } from '../EntityQueryContext';
-import IEntityDatabaseAdapterProvider from '../IEntityDatabaseAdapterProvider';
-import ViewerContext from '../ViewerContext';
+import { EntityQueryContext, EntityTransactionalQueryContext } from '../EntityQueryContext';
+import { IEntityDatabaseAdapterProvider } from '../IEntityDatabaseAdapterProvider';
+import { ViewerContext } from '../ViewerContext';
 import { enforceResultsAsync } from '../entityUtils';
-import EntityDataManager from '../internal/EntityDataManager';
-import ReadThroughEntityCache from '../internal/ReadThroughEntityCache';
-import IEntityMetricsAdapter, { EntityMetricsMutationType } from '../metrics/IEntityMetricsAdapter';
-import NoOpEntityMetricsAdapter from '../metrics/NoOpEntityMetricsAdapter';
-import SimpleTestEntity, {
+import { EntityDataManager } from '../internal/EntityDataManager';
+import { ReadThroughEntityCache } from '../internal/ReadThroughEntityCache';
+import { EntityMetricsMutationType, IEntityMetricsAdapter } from '../metrics/IEntityMetricsAdapter';
+import { NoOpEntityMetricsAdapter } from '../metrics/NoOpEntityMetricsAdapter';
+import {
+  SimpleTestEntity,
   simpleTestEntityConfiguration,
   SimpleTestEntityPrivacyPolicy,
   SimpleTestFields,
 } from '../utils/__testfixtures__/SimpleTestEntity';
 import { NoCacheStubCacheAdapterProvider } from '../utils/__testfixtures__/StubCacheAdapter';
-import StubDatabaseAdapter from '../utils/__testfixtures__/StubDatabaseAdapter';
-import StubQueryContextProvider from '../utils/__testfixtures__/StubQueryContextProvider';
-import TestEntity, {
-  TestFields,
-  TestEntityPrivacyPolicy,
+import { StubDatabaseAdapter } from '../utils/__testfixtures__/StubDatabaseAdapter';
+import { StubQueryContextProvider } from '../utils/__testfixtures__/StubQueryContextProvider';
+import {
+  TestEntity,
   testEntityConfiguration,
+  TestEntityPrivacyPolicy,
+  TestFields,
 } from '../utils/__testfixtures__/TestEntity';
 
 class TestMutationTrigger extends EntityMutationTrigger<
@@ -592,7 +597,7 @@ describe(EntityMutatorFactory, () => {
 
       const updatedEntity = await enforceAsyncResult(
         entityMutatorFactory
-          .forUpdate(existingEntity, queryContext)
+          .forUpdate(existingEntity, queryContext, /* cascadingDeleteCause */ null)
           .setField('stringField', 'huh2')
           .updateAsync(),
       );
@@ -645,7 +650,7 @@ describe(EntityMutatorFactory, () => {
 
       await enforceAsyncResult(
         entityMutatorFactory
-          .forUpdate(existingEntity, queryContext)
+          .forUpdate(existingEntity, queryContext, /* cascadingDeleteCause */ null)
           .setField('stringField', 'huh2')
           .updateAsync(),
       );
@@ -719,7 +724,7 @@ describe(EntityMutatorFactory, () => {
 
       await enforceAsyncResult(
         entityMutatorFactory
-          .forUpdate(existingEntity, queryContext)
+          .forUpdate(existingEntity, queryContext, /* cascadingDeleteCause */ null)
           .setField('stringField', 'huh2')
           .updateAsync(),
       );
@@ -791,7 +796,7 @@ describe(EntityMutatorFactory, () => {
 
       await enforceAsyncResult(
         entityMutatorFactory
-          .forUpdate(existingEntity, queryContext)
+          .forUpdate(existingEntity, queryContext, /* cascadingDeleteCause */ null)
           .setField('stringField', 'huh2')
           .updateAsync(),
       );
@@ -803,6 +808,116 @@ describe(EntityMutatorFactory, () => {
       });
     });
 
+    it('passes manaully-specified cascading delete cause to privacy policy and validators and triggers', async () => {
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              'customIdField',
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = new StubQueryContextProvider().getQueryContext();
+
+      const id1 = uuidv4();
+      const id2 = uuidv4();
+      const {
+        privacyPolicy,
+        mutationTriggers,
+        mutationValidators,
+        entityMutatorFactory,
+        entityLoaderFactory,
+      } = createEntityMutatorFactory([
+        {
+          customIdField: id1,
+          stringField: 'huh',
+          testIndexedField: '3',
+          intField: 3,
+          dateField: new Date(),
+          nullableField: null,
+        },
+        {
+          customIdField: id2,
+          stringField: 'huh',
+          testIndexedField: '4',
+          intField: 3,
+          dateField: new Date(),
+          nullableField: null,
+        },
+      ]);
+
+      const spiedPrivacyPolicy = spy(privacyPolicy);
+      const triggerSpies = setUpMutationTriggerSpies(mutationTriggers);
+      const validatorSpies = setUpMutationValidatorSpies(mutationValidators);
+
+      const existingEntity = await enforceAsyncResult(
+        entityLoaderFactory
+          .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+          .loadByIDAsync(id2),
+      );
+
+      const cascadingDeleteCause: EntityCascadingDeletionInfo = {
+        entity: 'blah' as any,
+        cascadingDeleteCause: null,
+      };
+
+      await enforceAsyncResult(
+        entityMutatorFactory
+          .forUpdate(existingEntity, queryContext, cascadingDeleteCause)
+          .setField('stringField', 'huh2')
+          .updateAsync(),
+      );
+
+      verify(
+        spiedPrivacyPolicy.authorizeUpdateAsync(
+          viewerContext,
+          anyOfClass(EntityTransactionalQueryContext),
+          deepEqual({ previousValue: existingEntity, cascadingDeleteCause }),
+          anyOfClass(TestEntity),
+          anything(),
+        ),
+      ).once();
+
+      verify(
+        spiedPrivacyPolicy.authorizeReadAsync(
+          viewerContext,
+          anyOfClass(EntityTransactionalQueryContext),
+          deepEqual({ previousValue: existingEntity, cascadingDeleteCause }),
+          anyOfClass(TestEntity),
+          anything(),
+        ),
+      ).once();
+
+      verifyValidatorCounts(viewerContext, validatorSpies, 1, {
+        type: EntityMutationType.UPDATE,
+        previousValue: existingEntity,
+        cascadingDeleteCause,
+      });
+
+      verifyTriggerCounts(
+        viewerContext,
+        triggerSpies,
+        {
+          beforeCreate: false,
+          afterCreate: false,
+          beforeUpdate: true,
+          afterUpdate: true,
+          beforeDelete: false,
+          afterDelete: false,
+        },
+        {
+          type: EntityMutationType.UPDATE,
+          previousValue: existingEntity,
+          cascadingDeleteCause,
+        },
+      );
+    });
+
     it('throws when id field is updated', async () => {
       const viewerContext = mock<ViewerContext>();
       const privacyPolicyEvaluationContext =
@@ -840,7 +955,7 @@ describe(EntityMutatorFactory, () => {
       await expect(
         enforceAsyncResult(
           entityMutatorFactory
-            .forUpdate(existingEntity, queryContext)
+            .forUpdate(existingEntity, queryContext, /* cascadingDeleteCause */ null)
             .setField('customIdField', uuidv4())
             .updateAsync(),
         ),
@@ -892,7 +1007,9 @@ describe(EntityMutatorFactory, () => {
       expect(existingEntity).toBeTruthy();
 
       await enforceAsyncResult(
-        entityMutatorFactory.forDelete(existingEntity, queryContext).deleteAsync(),
+        entityMutatorFactory
+          .forDelete(existingEntity, queryContext, /* cascadingDeleteCause */ null)
+          .deleteAsync(),
       );
 
       await expect(
@@ -942,7 +1059,9 @@ describe(EntityMutatorFactory, () => {
       );
 
       await enforceAsyncResult(
-        entityMutatorFactory.forDelete(existingEntity, queryContext).deleteAsync(),
+        entityMutatorFactory
+          .forDelete(existingEntity, queryContext, /* cascadingDeleteCause */ null)
+          .deleteAsync(),
       );
 
       verify(
@@ -994,7 +1113,9 @@ describe(EntityMutatorFactory, () => {
       );
 
       await enforceAsyncResult(
-        entityMutatorFactory.forDelete(existingEntity, queryContext).deleteAsync(),
+        entityMutatorFactory
+          .forDelete(existingEntity, queryContext, /* cascadingDeleteCause */ null)
+          .deleteAsync(),
       );
 
       verifyTriggerCounts(
@@ -1050,13 +1171,89 @@ describe(EntityMutatorFactory, () => {
       );
 
       await enforceAsyncResult(
-        entityMutatorFactory.forDelete(existingEntity, queryContext).deleteAsync(),
+        entityMutatorFactory
+          .forDelete(existingEntity, queryContext, /* cascadingDeleteCause */ null)
+          .deleteAsync(),
       );
 
       verifyValidatorCounts(viewerContext, validatorSpies, 0, {
         type: EntityMutationType.DELETE as any,
       });
     });
+
+    it('passes manaully-specified cascading delete cause to privacy policy and triggers', async () => {
+      const viewerContext = mock<ViewerContext>();
+      const privacyPolicyEvaluationContext =
+        instance(
+          mock<
+            EntityPrivacyPolicyEvaluationContext<
+              TestFields,
+              'customIdField',
+              ViewerContext,
+              TestEntity,
+              keyof TestFields
+            >
+          >(),
+        );
+      const queryContext = new StubQueryContextProvider().getQueryContext();
+
+      const id1 = uuidv4();
+      const { mutationTriggers, privacyPolicy, entityMutatorFactory, entityLoaderFactory } =
+        createEntityMutatorFactory([
+          {
+            customIdField: id1,
+            stringField: 'huh',
+            testIndexedField: '3',
+            intField: 3,
+            dateField: new Date(),
+            nullableField: null,
+          },
+        ]);
+
+      const spiedPrivacyPolicy = spy(privacyPolicy);
+      const triggerSpies = setUpMutationTriggerSpies(mutationTriggers);
+
+      const existingEntity = await enforceAsyncResult(
+        entityLoaderFactory
+          .forLoad(viewerContext, queryContext, privacyPolicyEvaluationContext)
+          .loadByIDAsync(id1),
+      );
+
+      const cascadingDeleteCause: EntityCascadingDeletionInfo = {
+        entity: 'blah' as any,
+        cascadingDeleteCause: null,
+      };
+
+      await enforceAsyncResult(
+        entityMutatorFactory
+          .forDelete(existingEntity, queryContext, cascadingDeleteCause)
+          .deleteAsync(),
+      );
+
+      verify(
+        spiedPrivacyPolicy.authorizeDeleteAsync(
+          viewerContext,
+          anyOfClass(EntityTransactionalQueryContext),
+          deepEqual({ previousValue: null, cascadingDeleteCause }),
+          anyOfClass(TestEntity),
+          anything(),
+        ),
+      ).once();
+
+      verifyTriggerCounts(
+        viewerContext,
+        triggerSpies,
+        {
+          beforeCreate: false,
+          afterCreate: false,
+          beforeUpdate: false,
+          afterUpdate: false,
+          beforeDelete: true,
+          afterDelete: true,
+        },
+        { type: EntityMutationType.DELETE, cascadingDeleteCause },
+      );
+    });
   });
 
   it('invalidates cache for fields upon create', async () => {
@@ -1148,7 +1345,7 @@ describe(EntityMutatorFactory, () => {
         .forCreate(viewerContext, queryContext)
         .setField('stringField', 10 as any)
         .createAsync(),
-    ).rejects.toThrowError('Entity field not valid: TestEntity (stringField = 10)');
+    ).rejects.toThrow('Entity field not valid: TestEntity (stringField = 10)');
 
     const createdEntity = await enforceAsyncResult(
       entityMutatorFactory
@@ -1159,10 +1356,10 @@ describe(EntityMutatorFactory, () => {
 
     await expect(
       entityMutatorFactory
-        .forUpdate(createdEntity, queryContext)
+        .forUpdate(createdEntity, queryContext, /* cascadingDeleteCause */ null)
         .setField('stringField', 10 as any)
         .updateAsync(),
-    ).rejects.toThrowError('Entity field not valid: TestEntity (stringField = 10)');
+    ).rejects.toThrow('Entity field not valid: TestEntity (stringField = 10)');
   });
 
   it('returns error result when not authorized to create', async () => {
@@ -1280,14 +1477,14 @@ describe(EntityMutatorFactory, () => {
     expect(entityCreateResult.value).toBe(undefined);
 
     const entityUpdateResult = await entityMutatorFactory
-      .forUpdate(fakeEntity, queryContext)
+      .forUpdate(fakeEntity, queryContext, /* cascadingDeleteCause */ null)
       .updateAsync();
     expect(entityUpdateResult.ok).toBe(false);
     expect(entityUpdateResult.reason).toEqual(rejectionError);
     expect(entityUpdateResult.value).toBe(undefined);
 
     const entityDeleteResult = await entityMutatorFactory
-      .forDelete(fakeEntity, queryContext)
+      .forDelete(fakeEntity, queryContext, /* cascadingDeleteCause */ null)
       .deleteAsync();
     expect(entityDeleteResult.ok).toBe(false);
     expect(entityDeleteResult.reason).toEqual(rejectionError);
@@ -1402,10 +1599,14 @@ describe(EntityMutatorFactory, () => {
       entityMutatorFactory.forCreate(viewerContext, queryContext).createAsync(),
     ).rejects.toEqual(rejectionError);
     await expect(
-      entityMutatorFactory.forUpdate(fakeEntity, queryContext).updateAsync(),
+      entityMutatorFactory
+        .forUpdate(fakeEntity, queryContext, /* cascadingDeleteCause */ null)
+        .updateAsync(),
     ).rejects.toEqual(rejectionError);
     await expect(
-      entityMutatorFactory.forDelete(fakeEntity, queryContext).deleteAsync(),
+      entityMutatorFactory
+        .forDelete(fakeEntity, queryContext, /* cascadingDeleteCause */ null)
+        .deleteAsync(),
     ).rejects.toEqual(rejectionError);
   });
 
@@ -1424,12 +1625,16 @@ describe(EntityMutatorFactory, () => {
 
     await enforceAsyncResult(
       entityMutatorFactory
-        .forUpdate(newEntity, queryContext)
+        .forUpdate(newEntity, queryContext, /* cascadingDeleteCause */ null)
         .setField('stringField', 'wat')
         .updateAsync(),
     );
 
-    await enforceAsyncResult(entityMutatorFactory.forDelete(newEntity, queryContext).deleteAsync());
+    await enforceAsyncResult(
+      entityMutatorFactory
+        .forDelete(newEntity, queryContext, /* cascadingDeleteCause */ null)
+        .deleteAsync(),
+    );
 
     verify(
       spiedMetricsAdapter.logMutatorMutationEvent(

package/src/__tests__/EntityPrivacyPolicy-test.ts

@@ -1,25 +1,28 @@
-import { mock, instance, spy, verify, anyOfClass, anything, objectContaining } from 'ts-mockito';
+import { describe, expect, it } from '@jest/globals';
+import { anyOfClass, anything, instance, mock, objectContaining, spy, verify } from 'ts-mockito';
 
-import Entity from '../Entity';
+import { Entity } from '../Entity';
 import { EntityCompanionDefinition } from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
+import { EntityConfiguration } from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
-import EntityPrivacyPolicy, {
-  EntityPrivacyPolicyEvaluator,
+import {
   EntityAuthorizationAction,
-  EntityPrivacyPolicyEvaluationMode,
+  EntityPrivacyPolicy,
   EntityPrivacyPolicyEvaluationContext,
+  EntityPrivacyPolicyEvaluationMode,
+  EntityPrivacyPolicyEvaluator,
 } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
-import ViewerContext from '../ViewerContext';
-import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
-import IEntityMetricsAdapter, {
+import { ViewerContext } from '../ViewerContext';
+import { EntityNotAuthorizedError } from '../errors/EntityNotAuthorizedError';
+import {
   EntityMetricsAuthorizationResult,
+  IEntityMetricsAdapter,
 } from '../metrics/IEntityMetricsAdapter';
-import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
-import AlwaysDenyPrivacyPolicyRule from '../rules/AlwaysDenyPrivacyPolicyRule';
-import AlwaysSkipPrivacyPolicyRule from '../rules/AlwaysSkipPrivacyPolicyRule';
-import PrivacyPolicyRule, { RuleEvaluationResult } from '../rules/PrivacyPolicyRule';
+import { AlwaysAllowPrivacyPolicyRule } from '../rules/AlwaysAllowPrivacyPolicyRule';
+import { AlwaysDenyPrivacyPolicyRule } from '../rules/AlwaysDenyPrivacyPolicyRule';
+import { AlwaysSkipPrivacyPolicyRule } from '../rules/AlwaysSkipPrivacyPolicyRule';
+import { PrivacyPolicyRule, RuleEvaluationResult } from '../rules/PrivacyPolicyRule';
 
 type BlahFields = {
   id: string;
@@ -470,7 +473,7 @@ describe(EntityPrivacyPolicy, () => {
           entity,
           metricsAdapter,
         ),
-      ).rejects.toThrowError('WooHoo!');
+      ).rejects.toThrow('WooHoo!');
       verify(metricsAdapterMock.logAuthorizationEvent(anything())).never();
     });
   });
@@ -587,7 +590,7 @@ describe(EntityPrivacyPolicy, () => {
           entity,
           metricsAdapter,
         ),
-      ).rejects.toThrowError('WooHoo!');
+      ).rejects.toThrow('WooHoo!');
 
       verify(policySpy.denyHandler(anyOfClass(EntityNotAuthorizedError))).never();
 
@@ -708,7 +711,7 @@ describe(EntityPrivacyPolicy, () => {
           entity,
           metricsAdapter,
         ),
-      ).rejects.toThrowError('WooHoo!');
+      ).rejects.toThrow('WooHoo!');
 
       verify(policySpy.denyHandler(anyOfClass(EntityNotAuthorizedError))).never();
 

package/src/__tests__/EntityQueryContext-test.ts

@@ -1,18 +1,19 @@
+import { describe, expect, it, jest } from '@jest/globals';
 import assert from 'assert';
 import invariant from 'invariant';
 
-import EntityCompanionProvider from '../EntityCompanionProvider';
+import { EntityCompanionProvider } from '../EntityCompanionProvider';
 import {
   EntityQueryContext,
   TransactionalDataLoaderMode,
   TransactionConfig,
   TransactionIsolationLevel,
 } from '../EntityQueryContext';
-import EntityQueryContextProvider from '../EntityQueryContextProvider';
-import ViewerContext from '../ViewerContext';
-import NoOpEntityMetricsAdapter from '../metrics/NoOpEntityMetricsAdapter';
+import { EntityQueryContextProvider } from '../EntityQueryContextProvider';
+import { ViewerContext } from '../ViewerContext';
+import { NoOpEntityMetricsAdapter } from '../metrics/NoOpEntityMetricsAdapter';
 import { InMemoryFullCacheStubCacheAdapterProvider } from '../utils/__testfixtures__/StubCacheAdapter';
-import StubDatabaseAdapterProvider from '../utils/__testfixtures__/StubDatabaseAdapterProvider';
+import { StubDatabaseAdapterProvider } from '../utils/__testfixtures__/StubDatabaseAdapterProvider';
 import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(EntityQueryContext, () => {
@@ -83,7 +84,7 @@ describe(EntityQueryContext, () => {
             queryContext.appendPreCommitCallback(preCommitCallback, 0);
           },
         ),
-      ).rejects.toThrowError('wat');
+      ).rejects.toThrow('wat');
 
       expect(preCommitCallback).toHaveBeenCalledTimes(1);
       expect(postCommitCallback).toHaveBeenCalledTimes(0);

package/src/__tests__/EntitySecondaryCacheLoader-test.ts

@@ -1,9 +1,11 @@
+import { describe, expect, it } from '@jest/globals';
 import { anyOfClass, anything, deepEqual, instance, mock, spy, verify, when } from 'ts-mockito';
 
 import { EntityNonTransactionalQueryContext } from '../EntityQueryContext';
-import EntitySecondaryCacheLoader, { ISecondaryEntityCache } from '../EntitySecondaryCacheLoader';
-import ViewerContext from '../ViewerContext';
-import SimpleTestEntity, {
+import { EntitySecondaryCacheLoader, ISecondaryEntityCache } from '../EntitySecondaryCacheLoader';
+import { ViewerContext } from '../ViewerContext';
+import {
+  SimpleTestEntity,
   SimpleTestEntityPrivacyPolicy,
   SimpleTestFields,
 } from '../utils/__testfixtures__/SimpleTestEntity';