@expo/entity 0.40.0 → 0.42.0

package/src/__tests__/ReadonlyEntity-test.ts

@@ -1,12 +1,15 @@
 import { instance, mock } from 'ts-mockito';
 
-import EntityAssociationLoader from '../EntityAssociationLoader';
-import EntityLoader from '../EntityLoader';
+import AuthorizationResultBasedEntityAssociationLoader from '../AuthorizationResultBasedEntityAssociationLoader';
+import AuthorizationResultBasedEntityLoader from '../AuthorizationResultBasedEntityLoader';
+import EnforcingEntityAssociationLoader from '../EnforcingEntityAssociationLoader';
+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', () => {
@@ -157,7 +160,7 @@ describe(ReadonlyEntity, () => {
   });
 
   describe('associationLoader', () => {
-    it('returns a new association loader', () => {
+    it('returns a new EnforcingEntityAssociationLoader', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
       const data = {
@@ -169,15 +172,52 @@ describe(ReadonlyEntity, () => {
         databaseFields: data,
         selectedFields: data,
       });
-      expect(testEntity.associationLoader()).toBeInstanceOf(EntityAssociationLoader);
+      expect(testEntity.associationLoader()).toBeInstanceOf(EnforcingEntityAssociationLoader);
+    });
+  });
+
+  describe('associationLoaderWithAuthorizationResults', () => {
+    it('returns a new AuthorizationResultBasedEntityAssociationLoader', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const data = {
+        id: 'what',
+      };
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      expect(testEntity.associationLoaderWithAuthorizationResults()).toBeInstanceOf(
+        AuthorizationResultBasedEntityAssociationLoader,
+      );
     });
   });
 
   describe('loader', () => {
-    it('creates a new EntityLoader', async () => {
+    it('creates a new EnforcingEntityLoader', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(SimpleTestEntity.loader(viewerContext)).toBeInstanceOf(EnforcingEntityLoader);
+    });
+  });
+
+  describe('loaderWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedEntityLoader', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(SimpleTestEntity.loaderWithAuthorizationResults(viewerContext)).toBeInstanceOf(
+        AuthorizationResultBasedEntityLoader,
+      );
+    });
+  });
+
+  describe('loaderUtils', () => {
+    it('creates a new EntityLoaderUtils', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      expect(SimpleTestEntity.loader(viewerContext)).toBeInstanceOf(EntityLoader);
+      expect(SimpleTestEntity.loaderUtils(viewerContext)).toBeInstanceOf(EntityLoaderUtils);
     });
   });
 });

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 () => {
@@ -14,13 +14,11 @@ describe('Two entities backed by the same table', () => {
     const viewerContext = new ViewerContext(companionProvider);
 
     const one = await OneTestEntity.creator(viewerContext)
-      .enforcing()
       .setField('entity_type', EntityType.ONE)
       .setField('common_other_field', 'wat')
       .createAsync();
 
     const two = await TwoTestEntity.creator(viewerContext)
-      .enforcing()
       .setField('entity_type', EntityType.TWO)
       .setField('other_field', 'blah')
       .setField('common_other_field', 'wat')
@@ -30,16 +28,16 @@ describe('Two entities backed by the same table', () => {
     expect(two).toBeInstanceOf(TwoTestEntity);
 
     await expect(
-      TwoTestEntity.loader(viewerContext).enforcing().loadByIDAsync(one.getID()),
+      TwoTestEntity.loader(viewerContext).loadByIDAsync(one.getID()),
     ).rejects.toThrowError('TwoTestEntity must be instantiated with two data');
 
     await expect(
-      OneTestEntity.loader(viewerContext).enforcing().loadByIDAsync(two.getID()),
+      OneTestEntity.loader(viewerContext).loadByIDAsync(two.getID()),
     ).rejects.toThrowError('OneTestEntity must be instantiated with one data');
 
-    const manyResults = await OneTestEntity.loader(viewerContext)
-      .withAuthorizationResults()
-      .loadManyByFieldEqualingAsync('common_other_field', 'wat');
+    const manyResults = await OneTestEntity.loaderWithAuthorizationResults(
+      viewerContext,
+    ).loadManyByFieldEqualingAsync('common_other_field', 'wat');
     const successfulManyResults = successfulResults(manyResults);
     const failedManyResults = failedResults(manyResults);
 
@@ -51,14 +49,14 @@ describe('Two entities backed by the same table', () => {
       'OneTestEntity must be instantiated with one data',
     );
 
-    const fieldEqualityConjunctionResults = await OneTestEntity.loader(viewerContext)
-      .withAuthorizationResults()
-      .loadManyByFieldEqualityConjunctionAsync([
-        {
-          fieldName: 'common_other_field',
-          fieldValue: 'wat',
-        },
-      ]);
+    const fieldEqualityConjunctionResults = await OneTestEntity.loaderWithAuthorizationResults(
+      viewerContext,
+    ).loadManyByFieldEqualityConjunctionAsync([
+      {
+        fieldName: 'common_other_field',
+        fieldValue: 'wat',
+      },
+    ]);
     const successfulfieldEqualityConjunctionResultsResults = successfulResults(
       fieldEqualityConjunctionResults,
     );
@@ -85,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: {
@@ -108,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;
@@ -138,7 +136,7 @@ class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFie
 
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
-    string,
+    'id',
     ViewerContext,
     OneTestEntity,
     TestEntityPrivacyPolicy,
@@ -153,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;
@@ -168,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 () => {
@@ -13,18 +13,14 @@ describe('Two entities backed by the same table', () => {
     const viewerContext = new ViewerContext(companionProvider);
 
     const entity1 = await OneTestEntity.creator(viewerContext)
-      .enforcing()
       .setField('fake_field', 'hello')
       .createAsync();
     expect(entity1).toBeInstanceOf(OneTestEntity);
 
-    const entity2 = await TwoTestEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(entity1.getID());
+    const entity2 = await TwoTestEntity.loader(viewerContext).loadByIDAsync(entity1.getID());
     expect(entity2).toBeInstanceOf(TwoTestEntity);
 
     const updated2 = await TwoTestEntity.updater(entity2)
-      .enforcing()
       .setField('fake_field', 'world')
       .setField('other_field', 'wat')
       .updateAsync();
@@ -34,9 +30,7 @@ describe('Two entities backed by the same table', () => {
       fake_field: 'world',
     });
 
-    const loaded1 = await OneTestEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(entity1.getID());
+    const loaded1 = await OneTestEntity.loader(viewerContext).loadByIDAsync(entity1.getID());
     expect(loaded1.getAllFields()).toMatchObject({
       id: updated2.getID(),
       fake_field: 'world',
@@ -48,37 +42,37 @@ describe('Two entities backed by the same table', () => {
     const viewerContext = new ViewerContext(companionProvider);
 
     const entity = await TwoTestEntity.creator(viewerContext)
-      .enforcing()
       .setField('fake_field', 'hello')
       .setField('other_field', 'huh')
       .createAsync();
 
-    const loadedEntity = await TwoTestEntity.loader(viewerContext)
-      .enforcing()
-      .loadByFieldEqualingAsync('other_field', 'huh');
+    const loadedEntity = await TwoTestEntity.loader(viewerContext).loadByFieldEqualingAsync(
+      'other_field',
+      'huh',
+    );
     expect(loadedEntity?.getAllFields()).toMatchObject({
       id: entity.getID(),
       fake_field: 'hello',
       other_field: 'huh',
     });
 
-    const loaded1 = await OneTestEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(entity.getID());
-    await OneTestEntity.updater(loaded1).enforcing().setField('fake_field', 'world').updateAsync();
+    const loaded1 = await OneTestEntity.loader(viewerContext).loadByIDAsync(entity.getID());
+    await OneTestEntity.updater(loaded1).setField('fake_field', 'world').updateAsync();
 
-    const loaded2 = await TwoTestEntity.loader(viewerContext)
-      .enforcing()
-      .loadByFieldEqualingAsync('other_field', 'huh');
+    const loaded2 = await TwoTestEntity.loader(viewerContext).loadByFieldEqualingAsync(
+      'other_field',
+      'huh',
+    );
     expect(loaded2?.getAllFields()).toMatchObject({
       id: entity.getID(),
       fake_field: 'world',
       other_field: 'huh',
     });
 
-    const loaded22 = await TwoTestEntity.loader(viewerContext)
-      .enforcing()
-      .loadByFieldEqualingAsync('fake_field', 'world');
+    const loaded22 = await TwoTestEntity.loader(viewerContext).loadByFieldEqualingAsync(
+      'fake_field',
+      'world',
+    );
     expect(loaded22?.getAllFields()).toMatchObject({
       id: entity.getID(),
       fake_field: 'world',
@@ -96,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: {
@@ -117,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,
@@ -150,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';