@expo/entity 0.41.0 → 0.43.0

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -1,8 +1,14 @@
-import { mock, when, instance, anything, verify, anyString, deepEqual } from 'ts-mockito';
+import { mock, when, instance, anything, verify, deepEqual } from 'ts-mockito';
 
 import GenericEntityCacheAdapter from '../GenericEntityCacheAdapter';
 import IEntityGenericCacher from '../IEntityGenericCacher';
 import { CacheStatus } from '../internal/ReadThroughEntityCache';
+import {
+  SingleFieldHolder,
+  SingleFieldValueHolder,
+  SingleFieldValueHolderMap,
+} from '../internal/SingleFieldHolder';
+import { deepEqualEntityAware } from '../utils/__testfixtures__/TSMockitoExtensions';
 
 type BlahFields = {
   id: string;
@@ -11,9 +17,14 @@ type BlahFields = {
 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}`;
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeyForStorage(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
       when(mockGenericCacher.loadManyAsync(deepEqual(['id.wat', 'id.who', 'id.why']))).thenResolve(
         new Map([
@@ -25,34 +36,56 @@ describe(GenericEntityCacheAdapter, () => {
 
       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 });
+      const results = await cacheAdapter.loadManyAsync(new SingleFieldHolder('id'), [
+        new SingleFieldValueHolder('wat'),
+        new SingleFieldValueHolder('who'),
+        new SingleFieldValueHolder('why'),
+      ]);
+      expect(results.get(new SingleFieldValueHolder('wat'))).toMatchObject({
+        status: CacheStatus.HIT,
+        item: { id: 'wat' },
+      });
+      expect(results.get(new SingleFieldValueHolder('who'))).toMatchObject({
+        status: CacheStatus.NEGATIVE,
+      });
+      expect(results.get(new SingleFieldValueHolder('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>>();
+    it('returns empty map when passed empty array of load values', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
       when(mockGenericCacher.loadManyAsync(deepEqual([]))).thenResolve(new Map([]));
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      const results = await cacheAdapter.loadManyAsync('id', []);
-      expect(results).toEqual(new Map());
+      const results = await cacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [] as SingleFieldValueHolder<BlahFields, 'id'>[],
+      );
+      expect(results).toEqual(new SingleFieldValueHolderMap(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 mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeyForStorage(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.cacheManyAsync('id', new Map([['wat', { id: 'wat' }]]));
+      await cacheAdapter.cacheManyAsync(
+        new SingleFieldHolder('id'),
+        new Map([[new SingleFieldValueHolder('wat'), { id: 'wat' }]]),
+      );
 
       verify(
         mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]]))),
@@ -62,13 +95,20 @@ describe(GenericEntityCacheAdapter, () => {
 
   describe('cacheDBMissesAsync', () => {
     it('correctly caches misses', async () => {
-      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
-      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
-        return `${fieldName}.${fieldValue}`;
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeyForStorage(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.cacheDBMissesAsync('id', ['wat']);
+      await cacheAdapter.cacheDBMissesAsync(new SingleFieldHolder('id'), [
+        new SingleFieldValueHolder('wat'),
+      ]);
 
       verify(mockGenericCacher.cacheDBMissesAsync(deepEqual(['id.wat']))).once();
     });
@@ -76,25 +116,40 @@ describe(GenericEntityCacheAdapter, () => {
 
   describe('invalidateManyAsync', () => {
     it('invalidates correctly', async () => {
-      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields>>();
-      when(mockGenericCacher.makeCacheKey('id', anyString())).thenCall((fieldName, fieldValue) => {
-        return `${fieldName}.${fieldValue}`;
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeysForInvalidation(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.invalidateManyAsync('id', ['wat']);
+      await cacheAdapter.invalidateManyAsync(new SingleFieldHolder('id'), [
+        new SingleFieldValueHolder('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 mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeysForInvalidation(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.invalidateManyAsync('id', []);
+      await cacheAdapter.invalidateManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [] as SingleFieldValueHolder<BlahFields, 'id'>[],
+      );
 
       verify(mockGenericCacher.invalidateManyAsync(deepEqual([]))).once();
     });

package/src/__tests__/ReadonlyEntity-test.ts

@@ -7,9 +7,9 @@ import EnforcingEntityLoader from '../EnforcingEntityLoader';
 import EntityLoaderUtils from '../EntityLoaderUtils';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
-import TestEntity from '../testfixtures/TestEntity';
-import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+import SimpleTestEntity from '../utils/__testfixtures__/SimpleTestEntity';
+import TestEntity from '../utils/__testfixtures__/TestEntity';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(ReadonlyEntity, () => {
   describe('getID', () => {

package/src/__tests__/ViewerContext-test.ts

@@ -1,6 +1,6 @@
 import { EntityQueryContext } from '../EntityQueryContext';
 import ViewerContext from '../ViewerContext';
-import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(ViewerContext, () => {
   describe('getQueryContextForDatabaseAdaptorFlavor', () => {

package/src/__tests__/ViewerScopedEntityCompanion-test.ts

@@ -5,7 +5,10 @@ import ViewerContext from '../ViewerContext';
 import ViewerScopedEntityCompanion from '../ViewerScopedEntityCompanion';
 import ViewerScopedEntityLoaderFactory from '../ViewerScopedEntityLoaderFactory';
 import ViewerScopedEntityMutatorFactory from '../ViewerScopedEntityMutatorFactory';
-import TestEntity, { TestFields, TestEntityPrivacyPolicy } from '../testfixtures/TestEntity';
+import TestEntity, {
+  TestFields,
+  TestEntityPrivacyPolicy,
+} from '../utils/__testfixtures__/TestEntity';
 
 describe(ViewerScopedEntityCompanion, () => {
   it('returns viewer scoped loader and mutator factory', () => {
@@ -14,7 +17,7 @@ describe(ViewerScopedEntityCompanion, () => {
       mock<
         EntityCompanion<
           TestFields,
-          string,
+          'customIdField',
           ViewerContext,
           TestEntity,
           TestEntityPrivacyPolicy,

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 from '../testfixtures/TestEntity';
+import TestEntity from '../utils/__testfixtures__/TestEntity';
 
 describe(ViewerScopedEntityCompanionProvider, () => {
   it('returns viewer scoped entity companion', () => {

package/src/__tests__/ViewerScopedEntityMutatorFactory-test.ts

@@ -4,7 +4,10 @@ import EntityMutatorFactory from '../EntityMutatorFactory';
 import { EntityQueryContext } from '../EntityQueryContext';
 import ViewerContext from '../ViewerContext';
 import ViewerScopedEntityMutatorFactory from '../ViewerScopedEntityMutatorFactory';
-import TestEntity, { TestFields, TestEntityPrivacyPolicy } from '../testfixtures/TestEntity';
+import TestEntity, {
+  TestFields,
+  TestEntityPrivacyPolicy,
+} from '../utils/__testfixtures__/TestEntity';
 
 describe(ViewerScopedEntityMutatorFactory, () => {
   it('correctly scopes viewer to entity mutations', async () => {
@@ -12,13 +15,19 @@ describe(ViewerScopedEntityMutatorFactory, () => {
     const queryContext = instance(mock(EntityQueryContext));
     const baseMutatorFactory =
       mock<
-        EntityMutatorFactory<TestFields, string, ViewerContext, TestEntity, TestEntityPrivacyPolicy>
+        EntityMutatorFactory<
+          TestFields,
+          'customIdField',
+          ViewerContext,
+          TestEntity,
+          TestEntityPrivacyPolicy
+        >
       >(EntityMutatorFactory);
     const baseMutatorFactoryInstance = instance(baseMutatorFactory);
 
     const viewerScopedEntityLoader = new ViewerScopedEntityMutatorFactory<
       TestFields,
-      string,
+      'customIdField',
       ViewerContext,
       TestEntity,
       TestEntityPrivacyPolicy,

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

@@ -1,12 +1,12 @@
 import Entity from '../../Entity';
 import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
-import { UUIDField, StringField, StrictEnumField } from '../../EntityFields';
+import { StringField, StrictEnumField, UUIDField } from '../../EntityFields';
 import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
 import ViewerContext from '../../ViewerContext';
 import { successfulResults, failedResults } from '../../entityUtils';
 import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
-import { createUnitTestEntityCompanionProvider } from '../../utils/testing/createUnitTestEntityCompanionProvider';
+import { createUnitTestEntityCompanionProvider } from '../../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe('Two entities backed by the same table', () => {
   test('load by different types', async () => {
@@ -83,7 +83,7 @@ interface TestFields {
 type OneTestFields = 'id' | 'entity_type' | 'common_other_field';
 type TwoTestFields = 'id' | 'other_field' | 'entity_type' | 'common_other_field';
 
-const testEntityConfiguration = new EntityConfiguration<TestFields>({
+const testEntityConfiguration = new EntityConfiguration<TestFields, 'id'>({
   idField: 'id',
   tableName: 'entities',
   schema: {
@@ -106,22 +106,22 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
   cacheAdapterFlavor: 'redis',
 });
 
-class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
+class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, 'id', ViewerContext, any, any> {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, 'id', ViewerContext, any, any>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, 'id', ViewerContext, any, any>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, 'id', ViewerContext, any, any>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, 'id', ViewerContext, any, any>(),
   ];
 }
 
-class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
+class OneTestEntity extends Entity<TestFields, 'id', ViewerContext, OneTestFields> {
   constructor(constructorParams: {
     viewerContext: ViewerContext;
     id: string;
@@ -136,7 +136,7 @@ class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFie
 
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
-    string,
+    'id',
     ViewerContext,
     OneTestEntity,
     TestEntityPrivacyPolicy,
@@ -151,7 +151,7 @@ class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFie
   }
 }
 
-class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
+class TwoTestEntity extends Entity<TestFields, 'id', ViewerContext, TwoTestFields> {
   constructor(constructorParams: {
     viewerContext: ViewerContext;
     id: string;
@@ -166,7 +166,7 @@ class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFie
 
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
-    string,
+    'id',
     ViewerContext,
     TwoTestEntity,
     TestEntityPrivacyPolicy,

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

@@ -1,11 +1,11 @@
 import Entity from '../../Entity';
 import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
-import { UUIDField, StringField } from '../../EntityFields';
+import { StringField, UUIDField } from '../../EntityFields';
 import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
 import ViewerContext from '../../ViewerContext';
 import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
-import { createUnitTestEntityCompanionProvider } from '../../utils/testing/createUnitTestEntityCompanionProvider';
+import { createUnitTestEntityCompanionProvider } from '../../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe('Two entities backed by the same table', () => {
   test('mutate through different types and keep consistent cache and dataloader', async () => {
@@ -90,7 +90,7 @@ interface TestFields {
 type OneTestFields = 'id' | 'fake_field';
 type TwoTestFields = 'id' | 'other_field' | 'fake_field';
 
-const testEntityConfiguration = new EntityConfiguration<TestFields>({
+const testEntityConfiguration = new EntityConfiguration<TestFields, 'id'>({
   idField: 'id',
   tableName: 'entities',
   schema: {
@@ -111,25 +111,25 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
   cacheAdapterFlavor: 'redis',
 });
 
-class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
+class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, 'id', ViewerContext, any, any> {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, 'id', ViewerContext, any, any>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, 'id', ViewerContext, any, any>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, 'id', ViewerContext, any, any>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+    new AlwaysAllowPrivacyPolicyRule<any, 'id', ViewerContext, any, any>(),
   ];
 }
 
-class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
+class OneTestEntity extends Entity<TestFields, 'id', ViewerContext, OneTestFields> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
-    string,
+    'id',
     ViewerContext,
     OneTestEntity,
     TestEntityPrivacyPolicy,
@@ -144,10 +144,10 @@ class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFie
   }
 }
 
-class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
+class TwoTestEntity extends Entity<TestFields, 'id', ViewerContext, TwoTestFields> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
-    string,
+    'id',
     ViewerContext,
     TwoTestEntity,
     TestEntityPrivacyPolicy,

package/src/entityUtils.ts

@@ -109,7 +109,10 @@ const isError = <T>(value: T | Error): value is Error => {
   return value instanceof Error;
 };
 
-export const pick = <T extends object, U extends keyof T>(object: T, props: U[]): Pick<T, U> => {
+export const pick = <T extends object, U extends keyof T>(
+  object: T,
+  props: readonly U[],
+): Pick<T, U> => {
   const propsSet = new Set(props);
   return Object.fromEntries(
     Object.entries(object).filter((entry) => propsSet.has(entry[0] as any)),

package/src/errors/EntityInvalidFieldValueError.ts

@@ -5,13 +5,13 @@ import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
 
 export default class EntityInvalidFieldValueError<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -25,7 +25,7 @@ export default class EntityInvalidFieldValueError<
   constructor(
     entityClass: IEntityClass<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,

package/src/errors/EntityNotAuthorizedError.ts

@@ -4,10 +4,10 @@ import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
 
 export default class EntityNotAuthorizedError<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
   public readonly state = EntityErrorState.PERMANENT;

package/src/errors/EntityNotFoundError.ts

@@ -5,13 +5,13 @@ import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
 
 export default class EntityNotFoundError<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -25,7 +25,7 @@ export default class EntityNotFoundError<
   constructor(
     entityClass: IEntityClass<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,

package/src/index.ts

@@ -23,6 +23,7 @@ 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 './EntityDatabaseAdapter';
@@ -66,11 +67,15 @@ 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 './internal/CompositeFieldHolder';
+export * from './internal/CompositeFieldValueMap';
 export { default as EntityDataManager } 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/ReadThroughEntityCache';
+export * from './internal/SingleFieldHolder';
 export * from './metrics/EntityMetricsUtils';
 export { type default as IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
 export * from './metrics/IEntityMetricsAdapter';
@@ -83,10 +88,5 @@ export * from './rules/PrivacyPolicyRule';
 export * from './utils/EntityPrivacyUtils';
 export * from './utils/mergeEntityMutationTriggerConfigurations';
 export * from './utils/collections/maps';
-export * from './utils/testing/createUnitTestEntityCompanionProvider';
-export { default as describeFieldTestCase } from './utils/testing/describeFieldTestCase';
-export * from './utils/testing/PrivacyPolicyRuleTestUtils';
-export * from './utils/testing/StubCacheAdapter';
-export { default as StubDatabaseAdapter } from './utils/testing/StubDatabaseAdapter';
-export { default as StubDatabaseAdapterProvider } from './utils/testing/StubDatabaseAdapterProvider';
-export { default as StubQueryContextProvider } from './utils/testing/StubQueryContextProvider';
+export * from './utils/collections/SerializableKeyMap';
+export * from './utils/collections/sets';