@expo/entity 0.44.0 → 0.46.0

package/src/internal/__tests__/EntityFieldTransformationUtils-test.ts

@@ -1,11 +1,13 @@
-import EntityConfiguration from '../../EntityConfiguration';
+import { describe, expect, it } from '@jest/globals';
+
+import { EntityConfiguration } from '../../EntityConfiguration';
 import { StringField, UUIDField } from '../../EntityFields';
 import {
   getDatabaseFieldForEntityField,
-  transformDatabaseObjectToFields,
-  transformFieldsToDatabaseObject,
   transformCacheObjectToFields,
+  transformDatabaseObjectToFields,
   transformFieldsToCacheObject,
+  transformFieldsToDatabaseObject,
 } from '../EntityFieldTransformationUtils';
 
 type BlahT = {

package/src/internal/__tests__/ReadThroughEntityCache-test.ts

@@ -1,13 +1,14 @@
-import { verify, mock, instance, when, anything } from 'ts-mockito';
+import { describe, expect, it, jest } from '@jest/globals';
+import { anything, instance, mock, verify, when } from 'ts-mockito';
 
-import EntityConfiguration from '../../EntityConfiguration';
+import { EntityConfiguration } from '../../EntityConfiguration';
 import { UUIDField } from '../../EntityFields';
-import IEntityCacheAdapter from '../../IEntityCacheAdapter';
+import { IEntityCacheAdapter } from '../../IEntityCacheAdapter';
 import {
   deepEqualEntityAware,
   isEqualWithEntityAware,
 } from '../../utils/__testfixtures__/TSMockitoExtensions';
-import ReadThroughEntityCache, { CacheStatus } from '../ReadThroughEntityCache';
+import { CacheStatus, ReadThroughEntityCache } from '../ReadThroughEntityCache';
 import {
   SingleFieldHolder,
   SingleFieldValueHolder,

package/src/metrics/EntityMetricsUtils.ts

@@ -1,8 +1,9 @@
-import IEntityMetricsAdapter, {
+import { EntityQueryContext } from '../EntityQueryContext';
+import {
   EntityMetricsLoadType,
   EntityMetricsMutationType,
+  IEntityMetricsAdapter,
 } from './IEntityMetricsAdapter';
-import { EntityQueryContext } from '../EntityQueryContext';
 import { IEntityLoadValue } from '../internal/EntityLoadInterfaces';
 import { reduceMap } from '../utils/collections/maps';
 

package/src/metrics/IEntityMetricsAdapter.ts

@@ -150,7 +150,7 @@ export interface EntityMetricsAuthorizationEvent {
  * An interface for gathering metrics about the Entity framework. Information about
  * entity load and mutation operations is piped to an instance of this adapter.
  */
-export default interface IEntityMetricsAdapter {
+export interface IEntityMetricsAdapter {
   /**
    * Called when a EntityPrivacyPolicy authorization succeeds or fails.
    * @param authorizationEvent - info about the authorization event

package/src/metrics/NoOpEntityMetricsAdapter.ts

@@ -1,11 +1,12 @@
-import IEntityMetricsAdapter, {
+import {
   EntityMetricsAuthorizationEvent,
   EntityMetricsLoadEvent,
   EntityMetricsMutationEvent,
+  IEntityMetricsAdapter,
   IncrementLoadCountEvent,
 } from './IEntityMetricsAdapter';
 
-export default class NoOpEntityMetricsAdapter implements IEntityMetricsAdapter {
+export class NoOpEntityMetricsAdapter implements IEntityMetricsAdapter {
   logAuthorizationEvent(_authorizationEvent: EntityMetricsAuthorizationEvent): void {}
   logDataManagerLoadEvent(_loadEvent: EntityMetricsLoadEvent): void {}
   logMutatorMutationEvent(_mutationEvent: EntityMetricsMutationEvent): void {}

package/src/rules/AlwaysAllowPrivacyPolicyRule.ts

@@ -1,13 +1,13 @@
-import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
-import ReadonlyEntity from '../ReadonlyEntity';
-import ViewerContext from '../ViewerContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule';
 
 /**
  * Privacy policy rule that always allows.
  */
-export default class AlwaysAllowPrivacyPolicyRule<
+export class AlwaysAllowPrivacyPolicyRule<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,

package/src/rules/AlwaysDenyPrivacyPolicyRule.ts

@@ -1,13 +1,13 @@
-import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
-import ReadonlyEntity from '../ReadonlyEntity';
-import ViewerContext from '../ViewerContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule';
 
 /**
  * Privacy policy rule that always denies.
  */
-export default class AlwaysDenyPrivacyPolicyRule<
+export class AlwaysDenyPrivacyPolicyRule<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,

package/src/rules/AlwaysSkipPrivacyPolicyRule.ts

@@ -1,13 +1,13 @@
-import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
-import ReadonlyEntity from '../ReadonlyEntity';
-import ViewerContext from '../ViewerContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { PrivacyPolicyRule, RuleEvaluationResult } from './PrivacyPolicyRule';
 
 /**
  * A no-op policy rule that always skips.
  */
-export default class AlwaysSkipPrivacyPolicyRule<
+export class AlwaysSkipPrivacyPolicyRule<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,

package/src/rules/PrivacyPolicyRule.ts

@@ -1,7 +1,7 @@
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
-import ReadonlyEntity from '../ReadonlyEntity';
-import ViewerContext from '../ViewerContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
 
 export enum RuleEvaluationResult {
   /**
@@ -36,7 +36,7 @@ export enum RuleEvaluationResult {
  * - Blocking. For example, a user blocks another user from seeing their posts, and the rule
  *   would be named something like `DenyIfViewerHasBeenBlockedPrivacyPolicyRule`.
  */
-export default abstract class PrivacyPolicyRule<
+export abstract class PrivacyPolicyRule<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,

package/src/rules/__tests__/AlwaysAllowPrivacyPolicyRule-test.ts

@@ -1,10 +1,10 @@
-import { mock, instance, anything } from 'ts-mockito';
+import { anything, instance, mock } from 'ts-mockito';
 
 import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
-import ViewerContext from '../../ViewerContext';
+import { ViewerContext } from '../../ViewerContext';
 import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
-import AlwaysAllowPrivacyPolicyRule from '../AlwaysAllowPrivacyPolicyRule';
+import { AlwaysAllowPrivacyPolicyRule } from '../AlwaysAllowPrivacyPolicyRule';
 
 describePrivacyPolicyRule(new AlwaysAllowPrivacyPolicyRule(), {
   allowCases: [

package/src/rules/__tests__/AlwaysDenyPrivacyPolicyRule-test.ts

@@ -1,10 +1,10 @@
-import { mock, instance, anything } from 'ts-mockito';
+import { anything, instance, mock } from 'ts-mockito';
 
 import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
-import ViewerContext from '../../ViewerContext';
+import { ViewerContext } from '../../ViewerContext';
 import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
-import AlwaysDenyPrivacyPolicyRule from '../AlwaysDenyPrivacyPolicyRule';
+import { AlwaysDenyPrivacyPolicyRule } from '../AlwaysDenyPrivacyPolicyRule';
 
 describePrivacyPolicyRule(new AlwaysDenyPrivacyPolicyRule(), {
   denyCases: [

package/src/rules/__tests__/AlwaysSkipPrivacyPolicyRule-test.ts

@@ -1,10 +1,10 @@
-import { mock, instance, anything } from 'ts-mockito';
+import { anything, instance, mock } from 'ts-mockito';
 
 import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
-import ViewerContext from '../../ViewerContext';
+import { ViewerContext } from '../../ViewerContext';
 import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
-import AlwaysSkipPrivacyPolicyRule from '../AlwaysSkipPrivacyPolicyRule';
+import { AlwaysSkipPrivacyPolicyRule } from '../AlwaysSkipPrivacyPolicyRule';
 
 describePrivacyPolicyRule(new AlwaysSkipPrivacyPolicyRule(), {
   skipCases: [

package/src/utils/EntityCreationUtils.ts

@@ -0,0 +1,143 @@
+import { IEntityClass } from '../Entity';
+import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
+import { EntityTransactionalQueryContext } from '../EntityQueryContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { EntityDatabaseAdapterUniqueConstraintError } from '../errors/EntityDatabaseAdapterError';
+import { EntityNotFoundError } from '../errors/EntityNotFoundError';
+
+/**
+ * Create an entity if it doesn't exist, or get the existing entity if it does.
+ */
+export async function createOrGetExistingAsync<
+  TFields extends object,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
+  TGetArgs,
+  TCreateArgs,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  viewerContext: TViewerContext,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
+  getAsync: (
+    viewerContext: TViewerContext,
+    getArgs: TGetArgs,
+    queryContext?: EntityTransactionalQueryContext,
+  ) => Promise<TEntity | null>,
+  getArgs: TGetArgs,
+  createAsync: (
+    viewerContext: TViewerContext,
+    createArgs: TCreateArgs,
+    queryContext?: EntityTransactionalQueryContext,
+  ) => Promise<TEntity>,
+  createArgs: TCreateArgs,
+  queryContext?: EntityTransactionalQueryContext,
+): Promise<TEntity> {
+  if (!queryContext) {
+    const maybeEntity = await getAsync(viewerContext, getArgs);
+    if (maybeEntity) {
+      return maybeEntity;
+    }
+  } else {
+    // This is done in a nested transaction since entity may negatively cache load results per-transaction (when configured).
+    // Without it, it would
+    // 1. load the entity in the current query context, negatively cache it
+    // 2. then try to create it in the nested transaction, which may fail due to a unique constraint error
+    // 3. then try to load the entity again in the current query context, which would return null due to negative cache
+    const maybeEntity = await queryContext.runInNestedTransactionAsync((nestedQueryContext) =>
+      getAsync(viewerContext, getArgs, nestedQueryContext),
+    );
+    if (maybeEntity) {
+      return maybeEntity;
+    }
+  }
+  return await createWithUniqueConstraintRecoveryAsync(
+    viewerContext,
+    entityClass,
+    getAsync,
+    getArgs,
+    createAsync,
+    createArgs,
+    queryContext,
+  );
+}
+
+/**
+ * Account for concurrent requests that may try to create the same entity.
+ * Return the existing entity if we get a Unique Constraint error.
+ */
+export async function createWithUniqueConstraintRecoveryAsync<
+  TFields extends object,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
+  TGetArgs,
+  TCreateArgs,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  viewerContext: TViewerContext,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
+  getAsync: (
+    viewerContext: TViewerContext,
+    getArgs: TGetArgs,
+    queryContext?: EntityTransactionalQueryContext,
+  ) => Promise<TEntity | null>,
+  getArgs: TGetArgs,
+  createAsync: (
+    viewerContext: TViewerContext,
+    createArgs: TCreateArgs,
+    queryContext?: EntityTransactionalQueryContext,
+  ) => Promise<TEntity>,
+  createArgs: TCreateArgs,
+  queryContext?: EntityTransactionalQueryContext,
+): Promise<TEntity> {
+  try {
+    if (!queryContext) {
+      return await createAsync(viewerContext, createArgs);
+    }
+    return await queryContext.runInNestedTransactionAsync((nestedQueryContext) =>
+      createAsync(viewerContext, createArgs, nestedQueryContext),
+    );
+  } catch (e) {
+    if (e instanceof EntityDatabaseAdapterUniqueConstraintError) {
+      const entity = await getAsync(viewerContext, getArgs, queryContext);
+      if (!entity) {
+        throw new EntityNotFoundError(
+          `Expected entity to exist after unique constraint error: ${entityClass.name}`,
+        );
+      }
+      return entity;
+    } else {
+      throw e;
+    }
+  }
+}

package/src/utils/EntityPrivacyUtils.ts

@@ -1,16 +1,16 @@
 import { Result, asyncResult } from '@expo/results';
 
-import Entity, { IEntityClass } from '../Entity';
+import { Entity, IEntityClass } from '../Entity';
 import {
-  EntityEdgeDeletionBehavior,
   EntityEdgeDeletionAuthorizationInferenceBehavior,
+  EntityEdgeDeletionBehavior,
 } from '../EntityFieldDefinition';
 import { EntityCascadingDeletionInfo } from '../EntityMutationInfo';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
-import ViewerContext from '../ViewerContext';
+import { ViewerContext } from '../ViewerContext';
 import { failedResults, partitionArray } from '../entityUtils';
-import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
+import { EntityNotAuthorizedError } from '../errors/EntityNotAuthorizedError';
 
 export type EntityPrivacyEvaluationResultSuccess = {
   allowed: true;

package/src/utils/__testfixtures__/PrivacyPolicyRuleTestUtils.ts

@@ -1,8 +1,10 @@
+import { describe, expect, test } from '@jest/globals';
+
 import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
-import ReadonlyEntity from '../../ReadonlyEntity';
-import ViewerContext from '../../ViewerContext';
-import PrivacyPolicyRule, { RuleEvaluationResult } from '../../rules/PrivacyPolicyRule';
+import { ReadonlyEntity } from '../../ReadonlyEntity';
+import { ViewerContext } from '../../ViewerContext';
+import { PrivacyPolicyRule, RuleEvaluationResult } from '../../rules/PrivacyPolicyRule';
 
 export interface Case<
   TFields extends Record<string, any>,

package/src/utils/__testfixtures__/SimpleTestEntity.ts

@@ -1,10 +1,10 @@
-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 from '../../EntityPrivacyPolicy';
-import ViewerContext from '../../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
+import { EntityPrivacyPolicy } from '../../EntityPrivacyPolicy';
+import { ViewerContext } from '../../ViewerContext';
+import { AlwaysAllowPrivacyPolicyRule } from '../../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type SimpleTestFields = {
   id: string;
@@ -70,7 +70,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   ];
 }
 
-export default class SimpleTestEntity extends Entity<
+export class SimpleTestEntity extends Entity<
   SimpleTestFields,
   'id',
   ViewerContext,

package/src/utils/__testfixtures__/StubCacheAdapter.ts

@@ -1,10 +1,10 @@
 import invariant from 'invariant';
 
-import EntityConfiguration from '../../EntityConfiguration';
-import IEntityCacheAdapter from '../../IEntityCacheAdapter';
-import IEntityCacheAdapterProvider from '../../IEntityCacheAdapterProvider';
+import { EntityConfiguration } from '../../EntityConfiguration';
+import { IEntityCacheAdapter } from '../../IEntityCacheAdapter';
+import { IEntityCacheAdapterProvider } from '../../IEntityCacheAdapterProvider';
 import { IEntityLoadKey, IEntityLoadValue } from '../../internal/EntityLoadInterfaces';
-import { CacheStatus, CacheLoadResult } from '../../internal/ReadThroughEntityCache';
+import { CacheLoadResult, CacheStatus } from '../../internal/ReadThroughEntityCache';
 
 export class NoCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvider {
   getCacheAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(

package/src/utils/__testfixtures__/StubDatabaseAdapter.ts

@@ -1,22 +1,23 @@
 import invariant from 'invariant';
 import { uuidv7 } from 'uuidv7';
 
-import EntityConfiguration from '../../EntityConfiguration';
-import EntityDatabaseAdapter, {
-  TableFieldSingleValueEqualityCondition,
+import { EntityConfiguration } from '../../EntityConfiguration';
+import {
+  EntityDatabaseAdapter,
+  OrderByOrdering,
   TableFieldMultiValueEqualityCondition,
+  TableFieldSingleValueEqualityCondition,
   TableQuerySelectionModifiers,
-  OrderByOrdering,
 } from '../../EntityDatabaseAdapter';
-import { StringField, IntField } from '../../EntityFields';
+import { IntField, StringField } from '../../EntityFields';
 import {
-  getDatabaseFieldForEntityField,
   FieldTransformerMap,
+  getDatabaseFieldForEntityField,
   transformFieldsToDatabaseObject,
 } from '../../internal/EntityFieldTransformationUtils';
 import { computeIfAbsent, mapMap } from '../collections/maps';
 
-export default class StubDatabaseAdapter<
+export class StubDatabaseAdapter<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
 > extends EntityDatabaseAdapter<TFields, TIDField> {

package/src/utils/__testfixtures__/StubDatabaseAdapterProvider.ts

@@ -1,9 +1,9 @@
-import EntityConfiguration from '../../EntityConfiguration';
-import EntityDatabaseAdapter from '../../EntityDatabaseAdapter';
-import IEntityDatabaseAdapterProvider from '../../IEntityDatabaseAdapterProvider';
-import StubDatabaseAdapter from '../__testfixtures__/StubDatabaseAdapter';
+import { EntityConfiguration } from '../../EntityConfiguration';
+import { EntityDatabaseAdapter } from '../../EntityDatabaseAdapter';
+import { IEntityDatabaseAdapterProvider } from '../../IEntityDatabaseAdapterProvider';
+import { StubDatabaseAdapter } from '../__testfixtures__/StubDatabaseAdapter';
 
-export default class StubDatabaseAdapterProvider implements IEntityDatabaseAdapterProvider {
+export class StubDatabaseAdapterProvider implements IEntityDatabaseAdapterProvider {
   private readonly objectCollection = new Map();
 
   getDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(

package/src/utils/__testfixtures__/StubQueryContextProvider.ts

@@ -1,7 +1,7 @@
 import { TransactionConfig } from '../../EntityQueryContext';
-import EntityQueryContextProvider from '../../EntityQueryContextProvider';
+import { EntityQueryContextProvider } from '../../EntityQueryContextProvider';
 
-export default class StubQueryContextProvider extends EntityQueryContextProvider {
+export class StubQueryContextProvider extends EntityQueryContextProvider {
   protected getQueryInterface(): any {
     return {};
   }

package/src/utils/__testfixtures__/TestEntity.ts

@@ -1,12 +1,12 @@
 import { result, Result } from '@expo/results';
 
-import Entity from '../../Entity';
+import { Entity } from '../../Entity';
 import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
-import EntityConfiguration from '../../EntityConfiguration';
-import { StringField, DateField, IntField, UUIDField } from '../../EntityFields';
-import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
-import ViewerContext from '../../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
+import { EntityConfiguration } from '../../EntityConfiguration';
+import { DateField, IntField, StringField, UUIDField } from '../../EntityFields';
+import { EntityPrivacyPolicy } from '../../EntityPrivacyPolicy';
+import { ViewerContext } from '../../ViewerContext';
+import { AlwaysAllowPrivacyPolicyRule } from '../../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type TestFields = {
   customIdField: string;
@@ -71,7 +71,7 @@ export class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   ];
 }
 
-export default class TestEntity extends Entity<TestFields, 'customIdField', ViewerContext> {
+export class TestEntity extends Entity<TestFields, 'customIdField', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     'customIdField',

package/src/utils/__testfixtures__/TestEntity2.ts

@@ -1,10 +1,10 @@
-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 from '../../EntityPrivacyPolicy';
-import ViewerContext from '../../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
+import { EntityPrivacyPolicy } from '../../EntityPrivacyPolicy';
+import { ViewerContext } from '../../ViewerContext';
+import { AlwaysAllowPrivacyPolicyRule } from '../../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type Test2Fields = {
   id: string;
@@ -47,7 +47,7 @@ export class TestEntity2PrivacyPolicy extends EntityPrivacyPolicy<
   ];
 }
 
-export default class TestEntity2 extends Entity<Test2Fields, 'id', ViewerContext> {
+export class TestEntity2 extends Entity<Test2Fields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     Test2Fields,
     'id',

package/src/utils/__testfixtures__/TestEntityWithMutationTriggers.ts

@@ -1,16 +1,16 @@
-import Entity from '../../Entity';
+import { Entity } from '../../Entity';
 import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
-import EntityConfiguration from '../../EntityConfiguration';
+import { EntityConfiguration } from '../../EntityConfiguration';
 import { StringField, UUIDField } from '../../EntityFields';
 import { EntityTriggerMutationInfo } from '../../EntityMutationInfo';
 import {
   EntityMutationTrigger,
   EntityNonTransactionalMutationTrigger,
 } from '../../EntityMutationTriggerConfiguration';
-import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
+import { EntityPrivacyPolicy } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
-import ViewerContext from '../../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
+import { ViewerContext } from '../../ViewerContext';
+import { AlwaysAllowPrivacyPolicyRule } from '../../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type TestMTFields = {
   id: string;
@@ -131,11 +131,7 @@ export class NonTransactionalTestMutationTrigger extends EntityNonTransactionalM
 /**
  * A test Entity that has one afterCreate and one afterAll trigger
  */
-export default class TestEntityWithMutationTriggers extends Entity<
-  TestMTFields,
-  'id',
-  ViewerContext
-> {
+export class TestEntityWithMutationTriggers extends Entity<TestMTFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestMTFields,
     'id',

package/src/utils/__testfixtures__/TestViewerContext.ts

@@ -1,3 +1,3 @@
-import ViewerContext from '../../ViewerContext';
+import { ViewerContext } from '../../ViewerContext';
 
-export default class TestViewerContext extends ViewerContext {}
+export class TestViewerContext extends ViewerContext {}

package/src/utils/__testfixtures__/createUnitTestEntityCompanionProvider.ts

@@ -1,9 +1,9 @@
 import { InMemoryFullCacheStubCacheAdapterProvider } from './StubCacheAdapter';
-import StubDatabaseAdapterProvider from './StubDatabaseAdapterProvider';
-import StubQueryContextProvider from './StubQueryContextProvider';
-import EntityCompanionProvider from '../../EntityCompanionProvider';
-import IEntityMetricsAdapter from '../../metrics/IEntityMetricsAdapter';
-import NoOpEntityMetricsAdapter from '../../metrics/NoOpEntityMetricsAdapter';
+import { StubDatabaseAdapterProvider } from './StubDatabaseAdapterProvider';
+import { StubQueryContextProvider } from './StubQueryContextProvider';
+import { EntityCompanionProvider } from '../../EntityCompanionProvider';
+import { IEntityMetricsAdapter } from '../../metrics/IEntityMetricsAdapter';
+import { NoOpEntityMetricsAdapter } from '../../metrics/NoOpEntityMetricsAdapter';
 
 const queryContextProvider = new StubQueryContextProvider();
 

package/src/utils/__testfixtures__/describeFieldTestCase.ts

@@ -1,6 +1,8 @@
+import { describe, expect, test } from '@jest/globals';
+
 import { EntityFieldDefinition } from '../../EntityFieldDefinition';
 
-export default function describeFieldTestCase<T>(
+export function describeFieldTestCase<T>(
   fieldDefinition: EntityFieldDefinition<T, any>,
   validValues: T[],
   invalidValues: any[],