@expo/entity 0.31.1 → 0.33.0

package/src/__tests__/EntitySelfReferentialEdges-test.ts

@@ -39,21 +39,25 @@ class CategoryPrivacyPolicy extends EntityPrivacyPolicy<
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 const makeEntityClass = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) => {
   class CategoryEntity extends Entity<CategoryFields, string, TestViewerContext> {
-    static getCompanionDefinition(): EntityCompanionDefinition<
+    static defineCompanionDefinition(): EntityCompanionDefinition<
       CategoryFields,
       string,
       TestViewerContext,
       CategoryEntity,
       CategoryPrivacyPolicy
     > {
-      return categoryEntityCompanion;
+      return {
+        entityClass: CategoryEntity,
+        entityConfiguration: categoryEntityConfiguration,
+        privacyPolicyClass: CategoryPrivacyPolicy,
+      };
     }
   }
 
   const categoryEntityConfiguration = new EntityConfiguration<CategoryFields>({
     idField: 'id',
     tableName: 'categories',
-    getInboundEdges: () => [CategoryEntity],
+    inboundEdges: [CategoryEntity],
     schema: {
       id: new UUIDField({
         columnName: 'id',
@@ -63,7 +67,7 @@ const makeEntityClass = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) => {
         columnName: 'parent_category_id',
         cache: true,
         association: {
-          getAssociatedEntityClass: () => CategoryEntity,
+          associatedEntityClass: CategoryEntity,
           edgeDeletionBehavior,
         },
       }),
@@ -72,12 +76,6 @@ const makeEntityClass = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) => {
     cacheAdapterFlavor: 'redis',
   });
 
-  const categoryEntityCompanion = new EntityCompanionDefinition({
-    entityClass: CategoryEntity,
-    entityConfiguration: categoryEntityConfiguration,
-    privacyPolicyClass: CategoryPrivacyPolicy,
-  });
-
   return {
     CategoryEntity,
   };

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -0,0 +1,102 @@
+import { mock, when, instance, anything, verify, anyString, deepEqual } from 'ts-mockito';
+
+import GenericEntityCacheAdapter from '../GenericEntityCacheAdapter';
+import IEntityGenericCacher from '../IEntityGenericCacher';
+import { CacheStatus } from '../internal/ReadThroughEntityCache';
+
+type BlahFields = {
+  id: string;
+};
+
+describe(GenericEntityCacheAdapter, () => {
+  describe('loadManyAsync', () => {
+    it('returns appropriate cache results', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
+      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
+        return `${fieldName}.${fieldValue}`;
+      });
+      when(mockGenericCacher.loadManyAsync(deepEqual(['id.wat', 'id.who', 'id.why']))).thenResolve(
+        new Map([
+          ['id.wat', { status: CacheStatus.HIT, item: { id: 'wat' } }],
+          ['id.who', { status: CacheStatus.NEGATIVE }],
+          ['id.why', { status: CacheStatus.MISS }],
+        ])
+      );
+
+      const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
+
+      const results = await cacheAdapter.loadManyAsync('id', ['wat', 'who', 'why']);
+      expect(results.get('wat')).toMatchObject({ status: CacheStatus.HIT, item: { id: 'wat' } });
+      expect(results.get('who')).toMatchObject({ status: CacheStatus.NEGATIVE });
+      expect(results.get('why')).toMatchObject({ status: CacheStatus.MISS });
+      expect(results.size).toBe(3);
+
+      verify(mockGenericCacher.loadManyAsync(anything())).once();
+    });
+
+    it('returns empty map when passed empty array of fieldValues', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
+      when(mockGenericCacher.loadManyAsync(deepEqual([]))).thenResolve(new Map([]));
+
+      const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
+      const results = await cacheAdapter.loadManyAsync('id', []);
+      expect(results).toEqual(new Map());
+    });
+  });
+
+  describe('cacheManyAsync', () => {
+    it('correctly caches all objects', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
+      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
+        return `${fieldName}.${fieldValue}`;
+      });
+
+      const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
+      await cacheAdapter.cacheManyAsync('id', new Map([['wat', { id: 'wat' }]]));
+
+      verify(
+        mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]])))
+      ).once();
+    });
+  });
+
+  describe('cacheDBMissesAsync', () => {
+    it('correctly caches misses', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
+      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
+        return `${fieldName}.${fieldValue}`;
+      });
+
+      const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
+      await cacheAdapter.cacheDBMissesAsync('id', ['wat']);
+
+      verify(mockGenericCacher.cacheDBMissesAsync(deepEqual(['id.wat']))).once();
+    });
+  });
+
+  describe('invalidateManyAsync', () => {
+    it('invalidates correctly', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
+      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
+        return `${fieldName}.${fieldValue}`;
+      });
+
+      const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
+      await cacheAdapter.invalidateManyAsync('id', ['wat']);
+
+      verify(mockGenericCacher.invalidateManyAsync(deepEqual(['id.wat']))).once();
+    });
+
+    it('returns when passed empty array of fieldValues', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
+      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
+        return `${fieldName}.${fieldValue}`;
+      });
+
+      const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
+      await cacheAdapter.invalidateManyAsync('id', []);
+
+      verify(mockGenericCacher.invalidateManyAsync(deepEqual([]))).once();
+    });
+  });
+});

package/src/__tests__/ReadonlyEntity-test.ts

@@ -15,7 +15,12 @@ describe(ReadonlyEntity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(testEntity.getID()).toEqual('what');
     });
   });
@@ -26,7 +31,12 @@ describe(ReadonlyEntity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(testEntity.toString()).toEqual('SimpleTestEntity[what]');
     });
   });
@@ -34,11 +44,25 @@ describe(ReadonlyEntity, () => {
   describe('getUniqueIdentifier', () => {
     it('returns a different value for two different entities of the same type', () => {
       const viewerContext = instance(mock(ViewerContext));
-      const testEntity = new SimpleTestEntity(viewerContext, {
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
         id: '1',
+        databaseFields: {
+          id: '1',
+        },
+        selectedFields: {
+          id: '1',
+        },
       });
-      const testEntity2 = new SimpleTestEntity(viewerContext, {
+      const testEntity2 = new SimpleTestEntity({
+        viewerContext,
         id: '2',
+        databaseFields: {
+          id: '2',
+        },
+        selectedFields: {
+          id: '2',
+        },
       });
       expect(testEntity.getUniqueIdentifier()).not.toEqual(testEntity2.getUniqueIdentifier());
     });
@@ -47,22 +71,43 @@ describe(ReadonlyEntity, () => {
       const viewerContext = instance(mock(ViewerContext));
       const viewerContext2 = instance(mock(ViewerContext));
       const data = { id: '1' };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
-      const testEntity2 = new SimpleTestEntity(viewerContext2, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: '1',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      const testEntity2 = new SimpleTestEntity({
+        viewerContext: viewerContext2,
+        id: '1',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(testEntity.getUniqueIdentifier()).toEqual(testEntity2.getUniqueIdentifier());
     });
 
     it('returns a different value for different entities even if same ID', () => {
       const viewerContext = instance(mock(ViewerContext));
       const data = { id: '1' };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
-      const testEntity2 = new TestEntity(viewerContext, {
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      const data2 = {
         customIdField: '1',
         testIndexedField: '2',
         stringField: '3',
         intField: 4,
         dateField: new Date(),
         nullableField: null,
+      };
+      const testEntity2 = new TestEntity({
+        viewerContext,
+        id: '1',
+        databaseFields: data2,
+        selectedFields: data2,
       });
       expect(testEntity.getUniqueIdentifier()).not.toEqual(testEntity2.getUniqueIdentifier());
     });
@@ -72,16 +117,27 @@ describe(ReadonlyEntity, () => {
     const viewerContext = instance(mock(ViewerContext));
     const dataWithoutID = {};
     expect(() => {
-      new SimpleTestEntity(viewerContext, dataWithoutID as any); // eslint-disable-line no-new
+      // eslint-disable-next-line no-new
+      new SimpleTestEntity({
+        viewerContext,
+        id: undefined as any,
+        databaseFields: dataWithoutID as any,
+        selectedFields: dataWithoutID as any,
+      });
     }).toThrow();
   });
 
-  it('returns correct viewerContext from instantiation', () => {
+  it('returns correct viewerCo}ntext from instantiation', () => {
     const viewerContext = instance(mock(ViewerContext));
     const data = {
       id: 'what',
     };
-    const testEntity = new SimpleTestEntity(viewerContext, data);
+    const testEntity = new SimpleTestEntity({
+      viewerContext,
+      id: 'what',
+      databaseFields: data,
+      selectedFields: data,
+    });
     expect(testEntity.getViewerContext()).toBe(viewerContext);
   });
 
@@ -90,7 +146,12 @@ describe(ReadonlyEntity, () => {
     const data = {
       id: 'what',
     };
-    const testEntity = new SimpleTestEntity(viewerContext, data);
+    const testEntity = new SimpleTestEntity({
+      viewerContext,
+      id: 'what',
+      databaseFields: data,
+      selectedFields: data,
+    });
     expect(testEntity.getField('id')).toEqual('what');
     expect(testEntity.getAllFields()).toEqual(data);
   });
@@ -102,7 +163,12 @@ describe(ReadonlyEntity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(testEntity.associationLoader()).toBeInstanceOf(EntityAssociationLoader);
     });
   });

package/src/__tests__/ViewerScopedEntityCompanionProvider-test.ts

@@ -4,7 +4,7 @@ import EntityCompanionProvider from '../EntityCompanionProvider';
 import ViewerContext from '../ViewerContext';
 import ViewerScopedEntityCompanion from '../ViewerScopedEntityCompanion';
 import ViewerScopedEntityCompanionProvider from '../ViewerScopedEntityCompanionProvider';
-import TestEntity, { testEntityCompanion } from '../testfixtures/TestEntity';
+import TestEntity from '../testfixtures/TestEntity';
 
 describe(ViewerScopedEntityCompanionProvider, () => {
   it('returns viewer scoped entity companion', () => {
@@ -15,10 +15,7 @@ describe(ViewerScopedEntityCompanionProvider, () => {
       vc
     );
     expect(
-      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(
-        TestEntity,
-        testEntityCompanion
-      )
+      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(TestEntity)
     ).toBeInstanceOf(ViewerScopedEntityCompanion);
   });
 });

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

@@ -122,14 +122,19 @@ class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerCon
 }
 
 class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
-  constructor(viewerContext: ViewerContext, rawFields: Readonly<TestFields>) {
-    if (rawFields.entity_type !== EntityType.ONE) {
+  constructor(constructorParams: {
+    viewerContext: ViewerContext;
+    id: string;
+    databaseFields: Readonly<TestFields>;
+    selectedFields: Readonly<Pick<TestFields, OneTestFields>>;
+  }) {
+    if (constructorParams.selectedFields.entity_type !== EntityType.ONE) {
       throw new Error('OneTestEntity must be instantiated with one data');
     }
-    super(viewerContext, rawFields);
+    super(constructorParams);
   }
 
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -137,19 +142,29 @@ class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFie
     TestEntityPrivacyPolicy,
     OneTestFields
   > {
-    return oneTestEntityCompanion;
+    return {
+      entityClass: OneTestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+      entitySelectedFields: ['id', 'entity_type', 'common_other_field'],
+    };
   }
 }
 
 class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
-  constructor(viewerContext: ViewerContext, rawFields: Readonly<TestFields>) {
-    if (rawFields.entity_type !== EntityType.TWO) {
+  constructor(constructorParams: {
+    viewerContext: ViewerContext;
+    id: string;
+    databaseFields: Readonly<TestFields>;
+    selectedFields: Readonly<Pick<TestFields, TwoTestFields>>;
+  }) {
+    if (constructorParams.selectedFields.entity_type !== EntityType.TWO) {
       throw new Error('TwoTestEntity must be instantiated with two data');
     }
-    super(viewerContext, rawFields);
+    super(constructorParams);
   }
 
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -157,20 +172,11 @@ class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFie
     TestEntityPrivacyPolicy,
     TwoTestFields
   > {
-    return twoTestEntityCompanion;
+    return {
+      entityClass: TwoTestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+      entitySelectedFields: ['id', 'other_field', 'common_other_field', 'entity_type'],
+    };
   }
 }
-
-const oneTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: OneTestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-  entitySelectedFields: ['id', 'entity_type', 'common_other_field'],
-});
-
-const twoTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: TwoTestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-  entitySelectedFields: ['id', 'other_field', 'common_other_field', 'entity_type'],
-});

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

@@ -130,7 +130,7 @@ class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerCon
 }
 
 class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -138,12 +138,17 @@ class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFie
     TestEntityPrivacyPolicy,
     OneTestFields
   > {
-    return oneTestEntityCompanion;
+    return {
+      entityClass: OneTestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+      entitySelectedFields: ['id', 'fake_field'],
+    };
   }
 }
 
 class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -151,20 +156,11 @@ class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFie
     TestEntityPrivacyPolicy,
     TwoTestFields
   > {
-    return twoTestEntityCompanion;
+    return {
+      entityClass: TwoTestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+      entitySelectedFields: ['id', 'other_field', 'fake_field'],
+    };
   }
 }
-
-const oneTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: OneTestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-  entitySelectedFields: ['id', 'fake_field'],
-});
-
-const twoTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: TwoTestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-  entitySelectedFields: ['id', 'other_field', 'fake_field'],
-});

package/src/errors/EntityInvalidFieldValueError.ts

@@ -1,11 +1,11 @@
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { IEntityClass } from '../Entity';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 
 export default class EntityInvalidFieldValueError<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/errors/EntityNotAuthorizedError.ts

@@ -1,10 +1,10 @@
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { EntityAuthorizationAction } from '../EntityPrivacyPolicy';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 
 export default class EntityNotAuthorizedError<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/errors/EntityNotFoundError.ts

@@ -1,11 +1,11 @@
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { IEntityClass } from '../Entity';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 
 export default class EntityNotFoundError<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/index.ts

@@ -12,7 +12,8 @@ export { default as Entity } from './Entity';
 export * from './Entity';
 export { default as EntityAssociationLoader } from './EntityAssociationLoader';
 export * from './EntityAssociationLoader';
-export { default as EntityCacheAdapter } from './EntityCacheAdapter';
+export { default as IEntityCacheAdapter } from './IEntityCacheAdapter';
+export { default as GenericEntityCacheAdapter } from './GenericEntityCacheAdapter';
 export { default as EntityCompanion } from './EntityCompanion';
 export * from './EntityCompanion';
 export { default as EntityCompanionProvider } from './EntityCompanionProvider';

package/src/internal/EntityDataManager.ts

@@ -1,5 +1,6 @@
 import DataLoader from 'dataloader';
 
+import ReadThroughEntityCache from './ReadThroughEntityCache';
 import EntityDatabaseAdapter, {
   FieldEqualityCondition,
   QuerySelectionModifiers,
@@ -17,7 +18,6 @@ import IEntityMetricsAdapter, {
   IncrementLoadCountEventType,
 } from '../metrics/IEntityMetricsAdapter';
 import { computeIfAbsent, zipToMap } from '../utils/collections/maps';
-import ReadThroughEntityCache from './ReadThroughEntityCache';
 
 /**
  * A data manager is responsible for orchestrating multiple sources of entity

package/src/internal/EntityTableDataCoordinator.ts

@@ -1,12 +1,12 @@
-import EntityCacheAdapter from '../EntityCacheAdapter';
+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 EntityDataManager from './EntityDataManager';
-import ReadThroughEntityCache from './ReadThroughEntityCache';
 
 /**
  * Responsible for orchestrating fetching and caching of entity data from a
@@ -15,7 +15,7 @@ import ReadThroughEntityCache from './ReadThroughEntityCache';
  */
 export default class EntityTableDataCoordinator<TFields> {
   readonly databaseAdapter: EntityDatabaseAdapter<TFields>;
-  readonly cacheAdapter: EntityCacheAdapter<TFields>;
+  readonly cacheAdapter: IEntityCacheAdapter<TFields>;
   readonly dataManager: EntityDataManager<TFields>;
 
   constructor(

package/src/internal/ReadThroughEntityCache.ts

@@ -1,7 +1,7 @@
 import invariant from 'invariant';
 
-import EntityCacheAdapter from '../EntityCacheAdapter';
 import EntityConfiguration from '../EntityConfiguration';
+import IEntityCacheAdapter from '../IEntityCacheAdapter';
 import { filterMap } from '../utils/collections/maps';
 
 export enum CacheStatus {
@@ -29,7 +29,7 @@ export type CacheLoadResult<TFields> =
 export default class ReadThroughEntityCache<TFields> {
   constructor(
     private readonly entityConfiguration: EntityConfiguration<TFields>,
-    private readonly entityCacheAdapter: EntityCacheAdapter<TFields>
+    private readonly entityCacheAdapter: IEntityCacheAdapter<TFields>
   ) {}
 
   private isFieldCacheable<N extends keyof TFields>(fieldName: N): boolean {

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

@@ -385,7 +385,8 @@ describe(EntityDataManager, () => {
         return await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', [
           '1',
         ]);
-      }
+      },
+      {}
     );
 
     expect(entityDatas.get('1')).toHaveLength(1);