@expo/entity 0.44.0 → 0.46.0

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

@@ -1,10 +1,12 @@
-import Entity from '../../Entity';
+import { describe, expect, test } from '@jest/globals';
+
+import { Entity } from '../../Entity';
 import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
-import EntityConfiguration from '../../EntityConfiguration';
+import { EntityConfiguration } from '../../EntityConfiguration';
 import { StringField, 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';
 import { createUnitTestEntityCompanionProvider } from '../../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe('Two entities backed by the same table', () => {

package/src/__tests__/entityUtils-test.ts

@@ -1,4 +1,5 @@
 import { result } from '@expo/results';
+import { describe, expect, it } from '@jest/globals';
 
 import {
   enforceResultsAsync,
@@ -105,7 +106,7 @@ describe(partitionArray, () => {
     type B = false;
     const arr: (A | B)[] = [true, false, true, true, false];
     const [as, bs] = partitionArray<A, B>(arr, (val: A | B): val is A => val === true);
-    expect(as).toMatchObject([true, true, true]);
-    expect(bs).toMatchObject([false, false]);
+    expect(as).toStrictEqual([true, true, true]);
+    expect(bs).toStrictEqual([false, false]);
   });
 });

package/src/errors/EntityCacheAdapterError.ts

@@ -1,6 +1,6 @@
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
 
-export default abstract class EntityCacheAdapterError extends EntityError {}
+export abstract class EntityCacheAdapterError extends EntityError {}
 
 export class EntityCacheAdapterTransientError extends EntityCacheAdapterError {
   public readonly state = EntityErrorState.TRANSIENT;

package/src/errors/EntityDatabaseAdapterError.ts

@@ -1,6 +1,6 @@
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
 
-export default abstract class EntityDatabaseAdapterError extends EntityError {}
+export abstract class EntityDatabaseAdapterError extends EntityError {}
 
 export class EntityDatabaseAdapterTransientError extends EntityDatabaseAdapterError {
   public readonly state = EntityErrorState.TRANSIENT;

package/src/errors/EntityError.ts

@@ -20,7 +20,7 @@ export enum EntityErrorCode {
   ERR_ENTITY_CACHE_ADAPTER_TRANSIENT = 'ERR_ENTITY_CACHE_ADAPTER_TRANSIENT',
 }
 
-export default abstract class EntityError extends ES6Error {
+export abstract class EntityError extends ES6Error {
   public abstract readonly state: EntityErrorState;
   public abstract readonly code: EntityErrorCode;
 

package/src/errors/EntityInvalidFieldValueError.ts

@@ -1,10 +1,10 @@
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { IEntityClass } from '../Entity';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
-import ReadonlyEntity from '../ReadonlyEntity';
-import ViewerContext from '../ViewerContext';
+import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
 
-export default class EntityInvalidFieldValueError<
+export class EntityInvalidFieldValueError<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,

package/src/errors/EntityNotAuthorizedError.ts

@@ -1,9 +1,9 @@
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { EntityAuthorizationAction } from '../EntityPrivacyPolicy';
-import ReadonlyEntity from '../ReadonlyEntity';
-import ViewerContext from '../ViewerContext';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
 
-export default class EntityNotAuthorizedError<
+export class EntityNotAuthorizedError<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,

package/src/errors/EntityNotFoundError.ts

@@ -1,10 +1,37 @@
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { IEntityClass } from '../Entity';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
-import ReadonlyEntity from '../ReadonlyEntity';
-import ViewerContext from '../ViewerContext';
+import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
+import { ReadonlyEntity } from '../ReadonlyEntity';
+import { ViewerContext } from '../ViewerContext';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
 
-export default class EntityNotFoundError<
+type EntityNotFoundOptions<
+  TFields extends Record<string, any>,
+  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
+  >,
+  N extends keyof TFields,
+  TSelectedFields extends keyof TFields = keyof TFields,
+> = {
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >;
+  fieldName: N;
+  fieldValue: TFields[N];
+};
+
+export class EntityNotFoundError<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
@@ -22,18 +49,38 @@ export default class EntityNotFoundError<
   public readonly state = EntityErrorState.PERMANENT;
   public readonly code = EntityErrorCode.ERR_ENTITY_NOT_FOUND;
 
+  constructor(message: string);
   constructor(
-    entityClass: IEntityClass<
+    options: EntityNotFoundOptions<
       TFields,
       TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
+      N,
       TSelectedFields
     >,
-    fieldName: N,
-    fieldValue: TFields[N],
+  );
+
+  constructor(
+    messageOrOptions:
+      | string
+      | EntityNotFoundOptions<
+          TFields,
+          TIDField,
+          TViewerContext,
+          TEntity,
+          TPrivacyPolicy,
+          N,
+          TSelectedFields
+        >,
   ) {
-    super(`Entity not found: ${entityClass.name} (${String(fieldName)} = ${fieldValue})`);
+    if (typeof messageOrOptions === 'string') {
+      super(messageOrOptions);
+    } else {
+      super(
+        `Entity not found: ${messageOrOptions.entityClass.name} (${String(messageOrOptions.fieldName)} = ${messageOrOptions.fieldValue})`,
+      );
+    }
   }
 }

package/src/errors/__tests__/EntityDatabaseAdapterError-test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from '@jest/globals';
+
+import {
+  EntityDatabaseAdapterCheckConstraintError,
+  EntityDatabaseAdapterError,
+  EntityDatabaseAdapterExclusionConstraintError,
+  EntityDatabaseAdapterForeignKeyConstraintError,
+  EntityDatabaseAdapterNotNullConstraintError,
+  EntityDatabaseAdapterTransientError,
+  EntityDatabaseAdapterUniqueConstraintError,
+  EntityDatabaseAdapterUnknownError,
+} from '../EntityDatabaseAdapterError';
+
+describe(EntityDatabaseAdapterError, () => {
+  // necessary for coverage within the entity package since these errors are
+  // currently only ever instantiated by database adapter implementations
+  it('instantiates all errors successfully', () => {
+    const errors = [
+      new EntityDatabaseAdapterTransientError('test'),
+      new EntityDatabaseAdapterUnknownError('test'),
+      new EntityDatabaseAdapterCheckConstraintError('test'),
+      new EntityDatabaseAdapterExclusionConstraintError('test'),
+      new EntityDatabaseAdapterForeignKeyConstraintError('test'),
+      new EntityDatabaseAdapterNotNullConstraintError('test'),
+      new EntityDatabaseAdapterUniqueConstraintError('test'),
+    ];
+    expect(errors).not.toBeFalsy();
+  });
+});

package/src/index.ts

@@ -4,87 +4,73 @@
  * @module @expo/entity
  */
 
-export { default as AuthorizationResultBasedEntityAssociationLoader } from './AuthorizationResultBasedEntityAssociationLoader';
 export * from './AuthorizationResultBasedEntityAssociationLoader';
-export { default as AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
+export * from './AuthorizationResultBasedEntityLoader';
 export * from './AuthorizationResultBasedEntityMutator';
-export { default as ComposedEntityCacheAdapter } from './ComposedEntityCacheAdapter';
-export { default as ComposedSecondaryEntityCache } from './ComposedSecondaryEntityCache';
-export { default as EnforcingEntityAssociationLoader } from './EnforcingEntityAssociationLoader';
-export { default as EnforcingEntityCreator } from './EnforcingEntityCreator';
-export { default as EnforcingEntityDeleter } from './EnforcingEntityDeleter';
-export { default as EnforcingEntityLoader } from './EnforcingEntityLoader';
-export { default as EnforcingEntityUpdater } from './EnforcingEntityUpdater';
-export { default as Entity } from './Entity';
+export * from './ComposedEntityCacheAdapter';
+export * from './ComposedSecondaryEntityCache';
+export * from './EnforcingEntityAssociationLoader';
+export * from './EnforcingEntityCreator';
+export * from './EnforcingEntityDeleter';
+export * from './EnforcingEntityLoader';
+export * from './EnforcingEntityUpdater';
 export * from './Entity';
-export { default as EntityAssociationLoader } from './EntityAssociationLoader';
-export { default as EntityCompanion } from './EntityCompanion';
+export * from './EntityAssociationLoader';
 export * from './EntityCompanion';
-export { default as EntityCompanionProvider } from './EntityCompanionProvider';
 export * from './EntityCompanionProvider';
-export { default as EntityConfiguration } from './EntityConfiguration';
 export * from './EntityConfiguration';
-export { default as EntityCreator } from './EntityCreator';
-export { default as EntityDatabaseAdapter } from './EntityDatabaseAdapter';
+export * from './EntityCreator';
 export * from './EntityDatabaseAdapter';
-export { default as EntityDeleter } from './EntityDeleter';
+export * from './EntityDeleter';
 export * from './EntityFieldDefinition';
 export * from './EntityFields';
-export { default as EntityLoader } from './EntityLoader';
-export { default as EntityLoaderFactory } from './EntityLoaderFactory';
-export { default as EntityLoaderUtils } from './EntityLoaderUtils';
+export * from './EntityLoader';
+export * from './EntityLoaderFactory';
+export * from './EntityLoaderUtils';
 export * from './EntityMutationInfo';
-export { type default as EntityMutationTriggerConfiguration } from './EntityMutationTriggerConfiguration';
 export * from './EntityMutationTriggerConfiguration';
-export { default as EntityMutationValidator } from './EntityMutationValidator';
-export { default as EntityMutatorFactory } from './EntityMutatorFactory';
-export { default as EntityPrivacyPolicy } from './EntityPrivacyPolicy';
+export * from './EntityMutationValidator';
+export * from './EntityMutatorFactory';
 export * from './EntityPrivacyPolicy';
 export * from './EntityQueryContext';
-export { default as EntityQueryContextProvider } from './EntityQueryContextProvider';
-export { default as EntitySecondaryCacheLoader } from './EntitySecondaryCacheLoader';
+export * from './EntityQueryContextProvider';
 export * from './EntitySecondaryCacheLoader';
-export { default as EntityUpdater } from './EntityUpdater';
+export * from './EntityUpdater';
 export * from './entityUtils';
-export { default as GenericEntityCacheAdapter } from './GenericEntityCacheAdapter';
-export { default as GenericSecondaryEntityCache } from './GenericSecondaryEntityCache';
-export { type default as IEntityCacheAdapter } from './IEntityCacheAdapter';
-export { type default as IEntityCacheAdapterProvider } from './IEntityCacheAdapterProvider';
-export { type default as IEntityDatabaseAdapterProvider } from './IEntityDatabaseAdapterProvider';
-export { type default as IEntityGenericCacher } from './IEntityGenericCacher';
-export { default as ReadonlyEntity } from './ReadonlyEntity';
-export { default as ViewerContext } from './ViewerContext';
-export { default as ViewerScopedEntityCompanion } from './ViewerScopedEntityCompanion';
-export { default as ViewerScopedEntityCompanionProvider } from './ViewerScopedEntityCompanionProvider';
-export { default as ViewerScopedEntityLoaderFactory } from './ViewerScopedEntityLoaderFactory';
-export { default as ViewerScopedEntityMutatorFactory } from './ViewerScopedEntityMutatorFactory';
-export { default as EntityCacheAdapterError } from './errors/EntityCacheAdapterError';
+export * from './GenericEntityCacheAdapter';
+export * from './GenericSecondaryEntityCache';
+export * from './IEntityCacheAdapter';
+export * from './IEntityCacheAdapterProvider';
+export * from './IEntityDatabaseAdapterProvider';
+export * from './IEntityGenericCacher';
+export * from './ReadonlyEntity';
+export * from './ViewerContext';
+export * from './ViewerScopedEntityCompanion';
+export * from './ViewerScopedEntityCompanionProvider';
+export * from './ViewerScopedEntityLoaderFactory';
+export * from './ViewerScopedEntityMutatorFactory';
 export * from './errors/EntityCacheAdapterError';
-export { default as EntityDatabaseAdapterError } from './errors/EntityDatabaseAdapterError';
 export * from './errors/EntityDatabaseAdapterError';
-export { default as EntityError } from './errors/EntityError';
 export * from './errors/EntityError';
-export { default as EntityInvalidFieldValueError } from './errors/EntityInvalidFieldValueError';
-export { default as EntityNotAuthorizedError } from './errors/EntityNotAuthorizedError';
-export { default as EntityNotFoundError } from './errors/EntityNotFoundError';
+export * from './errors/EntityInvalidFieldValueError';
+export * from './errors/EntityNotAuthorizedError';
+export * from './errors/EntityNotFoundError';
 export * from './internal/CompositeFieldHolder';
 export * from './internal/CompositeFieldValueMap';
-export { default as EntityDataManager } from './internal/EntityDataManager';
+export * from './internal/EntityDataManager';
 export * from './internal/EntityFieldTransformationUtils';
 export * from './internal/EntityLoadInterfaces';
-export { default as EntityTableDataCoordinator } from './internal/EntityTableDataCoordinator';
-export { default as ReadThroughEntityCache } from './internal/ReadThroughEntityCache';
+export * from './internal/EntityTableDataCoordinator';
 export * from './internal/ReadThroughEntityCache';
 export * from './internal/SingleFieldHolder';
 export * from './metrics/EntityMetricsUtils';
-export { type default as IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
 export * from './metrics/IEntityMetricsAdapter';
-export { default as NoOpEntityMetricsAdapter } from './metrics/NoOpEntityMetricsAdapter';
-export { default as AlwaysAllowPrivacyPolicyRule } from './rules/AlwaysAllowPrivacyPolicyRule';
-export { default as AlwaysDenyPrivacyPolicyRule } from './rules/AlwaysDenyPrivacyPolicyRule';
-export { default as AlwaysSkipPrivacyPolicyRule } from './rules/AlwaysSkipPrivacyPolicyRule';
-export { default as PrivacyPolicyRule } from './rules/PrivacyPolicyRule';
+export * from './metrics/NoOpEntityMetricsAdapter';
+export * from './rules/AlwaysAllowPrivacyPolicyRule';
+export * from './rules/AlwaysDenyPrivacyPolicyRule';
+export * from './rules/AlwaysSkipPrivacyPolicyRule';
 export * from './rules/PrivacyPolicyRule';
+export * from './utils/EntityCreationUtils';
 export * from './utils/EntityPrivacyUtils';
 export * from './utils/mergeEntityMutationTriggerConfigurations';
 export * from './utils/collections/maps';

package/src/internal/CompositeFieldHolder.ts

@@ -1,8 +1,9 @@
 import invariant from 'invariant';
 
-import EntityConfiguration, {
+import {
   EntityCompositeField,
   EntityCompositeFieldValue,
+  EntityConfiguration,
 } from '../EntityConfiguration';
 import { pick } from '../entityUtils';
 import { getDatabaseFieldForEntityField } from './EntityFieldTransformationUtils';

package/src/internal/EntityDataManager.ts

@@ -1,8 +1,8 @@
 import DataLoader from 'dataloader';
 import invariant from 'invariant';
 
-import ReadThroughEntityCache from './ReadThroughEntityCache';
-import EntityDatabaseAdapter, {
+import {
+  EntityDatabaseAdapter,
   FieldEqualityCondition,
   QuerySelectionModifiers,
   QuerySelectionModifiersWithOrderByRaw,
@@ -12,15 +12,17 @@ import {
   EntityTransactionalQueryContext,
   TransactionalDataLoaderMode,
 } from '../EntityQueryContext';
-import EntityQueryContextProvider from '../EntityQueryContextProvider';
+import { EntityQueryContextProvider } from '../EntityQueryContextProvider';
 import { partitionErrors } from '../entityUtils';
 import { IEntityLoadKey, IEntityLoadValue, LoadPair } from './EntityLoadInterfaces';
+import { ReadThroughEntityCache } from './ReadThroughEntityCache';
 import {
   timeAndLogLoadEventAsync,
   timeAndLogLoadMapEventAsync,
 } from '../metrics/EntityMetricsUtils';
-import IEntityMetricsAdapter, {
+import {
   EntityMetricsLoadType,
+  IEntityMetricsAdapter,
   IncrementLoadCountEventType,
 } from '../metrics/IEntityMetricsAdapter';
 import { computeIfAbsent } from '../utils/collections/maps';
@@ -38,7 +40,7 @@ type DataLoaderMap<TFields extends Record<string, any>> = Map<
  *
  * @internal
  */
-export default class EntityDataManager<
+export class EntityDataManager<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
 > {

package/src/internal/EntityFieldTransformationUtils.ts

@@ -1,7 +1,7 @@
 import invariant from 'invariant';
 import nullthrows from 'nullthrows';
 
-import EntityConfiguration from '../EntityConfiguration';
+import { EntityConfiguration } from '../EntityConfiguration';
 
 /**
  * @internal

package/src/internal/EntityLoadInterfaces.ts

@@ -1,4 +1,4 @@
-import EntityConfiguration from '../EntityConfiguration';
+import { EntityConfiguration } from '../EntityConfiguration';
 import { ISerializable, SerializableKeyMap } from '../utils/collections/SerializableKeyMap';
 
 /**

package/src/internal/EntityTableDataCoordinator.ts

@@ -1,12 +1,12 @@
-import EntityDataManager from './EntityDataManager';
-import ReadThroughEntityCache from './ReadThroughEntityCache';
-import EntityConfiguration from '../EntityConfiguration';
-import EntityDatabaseAdapter from '../EntityDatabaseAdapter';
-import EntityQueryContextProvider from '../EntityQueryContextProvider';
-import IEntityCacheAdapter from '../IEntityCacheAdapter';
-import IEntityCacheAdapterProvider from '../IEntityCacheAdapterProvider';
-import IEntityDatabaseAdapterProvider from '../IEntityDatabaseAdapterProvider';
-import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
+import { EntityConfiguration } from '../EntityConfiguration';
+import { EntityDatabaseAdapter } from '../EntityDatabaseAdapter';
+import { EntityQueryContextProvider } from '../EntityQueryContextProvider';
+import { IEntityCacheAdapter } from '../IEntityCacheAdapter';
+import { IEntityCacheAdapterProvider } from '../IEntityCacheAdapterProvider';
+import { IEntityDatabaseAdapterProvider } from '../IEntityDatabaseAdapterProvider';
+import { EntityDataManager } from './EntityDataManager';
+import { ReadThroughEntityCache } from './ReadThroughEntityCache';
+import { IEntityMetricsAdapter } from '../metrics/IEntityMetricsAdapter';
 
 /**
  * Responsible for orchestrating fetching and caching of entity data from a
@@ -15,7 +15,7 @@ import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
  *
  * @internal
  */
-export default class EntityTableDataCoordinator<
+export class EntityTableDataCoordinator<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
 > {

package/src/internal/ReadThroughEntityCache.ts

@@ -1,7 +1,7 @@
 import invariant from 'invariant';
 
-import EntityConfiguration from '../EntityConfiguration';
-import IEntityCacheAdapter from '../IEntityCacheAdapter';
+import { EntityConfiguration } from '../EntityConfiguration';
+import { IEntityCacheAdapter } from '../IEntityCacheAdapter';
 import { IEntityLoadKey, IEntityLoadValue } from './EntityLoadInterfaces';
 import { filterMap } from '../utils/collections/maps';
 
@@ -35,7 +35,7 @@ export type CacheLoadResult<TFields extends Record<string, any>> =
  *
  * @internal
  */
-export default class ReadThroughEntityCache<
+export class ReadThroughEntityCache<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
 > {

package/src/internal/SingleFieldHolder.ts

@@ -1,6 +1,6 @@
 import invariant from 'invariant';
 
-import EntityConfiguration from '../EntityConfiguration';
+import { EntityConfiguration } from '../EntityConfiguration';
 import { getDatabaseFieldForEntityField } from './EntityFieldTransformationUtils';
 import {
   EntityLoadMethodType,

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

@@ -1,3 +1,5 @@
+import { describe, expect, it } from '@jest/globals';
+
 import { CompositeFieldHolder, CompositeFieldValueHolder } from '../CompositeFieldHolder';
 
 describe(CompositeFieldHolder, () => {

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

@@ -1,3 +1,5 @@
+import { describe, expect, it } from '@jest/globals';
+
 import { EntityCompositeFieldValue } from '../../EntityConfiguration';
 import { CompositeFieldValueHolder } from '../CompositeFieldHolder';
 import { CompositeFieldValueMap } from '../CompositeFieldValueMap';

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

@@ -1,37 +1,40 @@
+import { describe, expect, it, jest } from '@jest/globals';
 import {
-  mock,
-  instance,
-  when,
-  anything,
-  verify,
-  spy,
+  anyNumber,
   anyString,
-  resetCalls,
+  anything,
   deepEqual,
-  anyNumber,
+  instance,
+  mock,
+  resetCalls,
+  spy,
+  verify,
+  when,
 } from 'ts-mockito';
 
-import EntityDatabaseAdapter from '../../EntityDatabaseAdapter';
+import { EntityDatabaseAdapter } from '../../EntityDatabaseAdapter';
 import { TransactionalDataLoaderMode } from '../../EntityQueryContext';
-import IEntityMetricsAdapter, {
+import {
   EntityMetricsLoadType,
+  IEntityMetricsAdapter,
   IncrementLoadCountEventType,
 } from '../../metrics/IEntityMetricsAdapter';
-import NoOpEntityMetricsAdapter from '../../metrics/NoOpEntityMetricsAdapter';
+import { NoOpEntityMetricsAdapter } from '../../metrics/NoOpEntityMetricsAdapter';
 import {
-  NoCacheStubCacheAdapterProvider,
   InMemoryFullCacheStubCacheAdapterProvider,
+  NoCacheStubCacheAdapterProvider,
 } from '../../utils/__testfixtures__/StubCacheAdapter';
-import StubDatabaseAdapter from '../../utils/__testfixtures__/StubDatabaseAdapter';
-import StubQueryContextProvider from '../../utils/__testfixtures__/StubQueryContextProvider';
-import TestEntity, {
+import { StubDatabaseAdapter } from '../../utils/__testfixtures__/StubDatabaseAdapter';
+import { StubQueryContextProvider } from '../../utils/__testfixtures__/StubQueryContextProvider';
+import {
+  TestEntity,
   testEntityConfiguration,
   TestFields,
 } from '../../utils/__testfixtures__/TestEntity';
 import { CompositeFieldHolder, CompositeFieldValueHolder } from '../CompositeFieldHolder';
-import EntityDataManager from '../EntityDataManager';
+import { EntityDataManager } from '../EntityDataManager';
 import { EntityLoadMethodType } from '../EntityLoadInterfaces';
-import ReadThroughEntityCache from '../ReadThroughEntityCache';
+import { ReadThroughEntityCache } from '../ReadThroughEntityCache';
 import { SingleFieldHolder, SingleFieldValueHolder } from '../SingleFieldHolder';
 
 const getObjects = (): Map<string, TestFields[]> =>
@@ -303,7 +306,7 @@ describe(EntityDataManager, () => {
     expect(dbSpy).toHaveBeenCalledTimes(1);
     expect(cacheSpy).toHaveBeenCalledTimes(1);
 
-    expect(entityData).toMatchObject(entityData2);
+    expect(entityData).toEqual(entityData2);
     expect(entityData.get(new SingleFieldValueHolder('hello'))).toHaveLength(2);
     expect(entityData.get(new SingleFieldValueHolder('world'))).toHaveLength(1);
 
@@ -378,9 +381,9 @@ describe(EntityDataManager, () => {
     expect(dbSpy).toHaveBeenCalledTimes(3);
     expect(cacheSpy).toHaveBeenCalledTimes(0);
 
-    expect(entityData).toMatchObject(entityData2);
-    expect(entityData2).toMatchObject(entityData3);
-    expect(entityData3).toMatchObject(entityData4);
+    expect(entityData).toEqual(entityData2);
+    expect(entityData2).toEqual(entityData3);
+    expect(entityData3).toEqual(entityData4);
     expect(entityData.get(new SingleFieldValueHolder('hello'))).toHaveLength(2);
     expect(entityData.get(new SingleFieldValueHolder('world'))).toHaveLength(1);
 
@@ -453,9 +456,9 @@ describe(EntityDataManager, () => {
     expect(dbSpy).toHaveBeenCalledTimes(3);
     expect(cacheSpy).toHaveBeenCalledTimes(0);
 
-    expect(entityData).toMatchObject(entityData2);
-    expect(entityData2).toMatchObject(entityData3);
-    expect(entityData3).toMatchObject(entityData4);
+    expect(entityData).toEqual(entityData2);
+    expect(entityData2).toEqual(entityData3);
+    expect(entityData3).toEqual(entityData4);
     expect(entityData.get(new SingleFieldValueHolder('hello'))).toHaveLength(2);
     expect(entityData.get(new SingleFieldValueHolder('world'))).toHaveLength(1);
 
@@ -532,9 +535,9 @@ describe(EntityDataManager, () => {
     expect(dbSpy).toHaveBeenCalledTimes(4);
     expect(cacheSpy).toHaveBeenCalledTimes(0);
 
-    expect(entityData).toMatchObject(entityData2);
-    expect(entityData2).toMatchObject(entityData3);
-    expect(entityData3).toMatchObject(entityData4);
+    expect(entityData).toEqual(entityData2);
+    expect(entityData2).toEqual(entityData3);
+    expect(entityData3).toEqual(entityData4);
     expect(entityData.get(new SingleFieldValueHolder('hello'))).toHaveLength(2);
     expect(entityData.get(new SingleFieldValueHolder('world'))).toHaveLength(1);
 
@@ -1273,7 +1276,7 @@ describe(EntityDataManager, () => {
         new SingleFieldHolder('nullableField'),
         [new SingleFieldValueHolder(null as any)],
       ),
-    ).rejects.toThrowError('Invalid load: TestEntity (nullableField = null)');
+    ).rejects.toThrow('Invalid load: TestEntity (nullableField = null)');
 
     await expect(
       entityDataManager.loadManyEqualingAsync(
@@ -1281,7 +1284,7 @@ describe(EntityDataManager, () => {
         new SingleFieldHolder('nullableField'),
         [new SingleFieldValueHolder(undefined as any)],
       ),
-    ).rejects.toThrowError('Invalid load: TestEntity (nullableField = undefined)');
+    ).rejects.toThrow('Invalid load: TestEntity (nullableField = undefined)');
   });
 
   it('throws when a composite value load-by value is null or undefined', async () => {
@@ -1320,7 +1323,7 @@ describe(EntityDataManager, () => {
           }),
         ],
       ),
-    ).rejects.toThrowError(
+    ).rejects.toThrow(
       'Invalid load: TestEntity (nullableField,testIndexedField = CompositeFieldValue(nullableField=null,testIndexedField=unique1))',
     );
 
@@ -1338,7 +1341,7 @@ describe(EntityDataManager, () => {
           }),
         ],
       ),
-    ).rejects.toThrowError(
+    ).rejects.toThrow(
       'Invalid load: TestEntity (nullableField,testIndexedField = CompositeFieldValue(nullableField=undefined,testIndexedField=unique1))',
     );
   });