@expo/entity 0.35.0 → 0.37.0

package/src/__tests__/EntitySelfReferentialEdges-test.ts

@@ -96,25 +96,33 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
     await CategoryEntity.enforceDeleteAsync(parentCategory);
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.toBeNull();
   });
 
@@ -135,10 +143,10 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     await CategoryEntity.enforceDeleteAsync(categoryA);
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryB.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryB.getID()),
     ).resolves.toBeNull();
   });
 });
@@ -159,19 +167,25 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
     await CategoryEntity.enforceDeleteAsync(parentCategory);
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
 
     const loadedSubCategory = await CategoryEntity.loader(viewerContext)
@@ -211,7 +225,7 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
 describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
   it('invalidates the cache', async () => {
     const { CategoryEntity } = makeEntityClass(
-      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY
+      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY,
     );
 
     const companionProvider = createUnitTestEntityCompanionProvider();
@@ -226,21 +240,23 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
       .enforceCreateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
       CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', parentCategory.getID())
+        .loadByFieldEqualingAsync('parent_category_id', parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
       CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', subCategory.getID())
+        .loadByFieldEqualingAsync('parent_category_id', subCategory.getID()),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
-      CategoryEntity
+      CategoryEntity,
     )['entityCompanion']['tableDataCoordinator'][
       'cacheAdapter'
     ] as InMemoryFullCacheStubCacheAdapter<CategoryFields>;
@@ -251,7 +267,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
 
     const subSubCategoryCachedBefore = await categoryCacheAdapter.loadManyAsync(
       'parent_category_id',
-      [subCategory.getID()]
+      [subCategory.getID()],
     );
     expect(subSubCategoryCachedBefore.get(subCategory.getID())?.status).toEqual(CacheStatus.HIT);
 
@@ -264,24 +280,28 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
 
     const subSubCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync(
       'parent_category_id',
-      [subCategory.getID()]
+      [subCategory.getID()],
     );
     expect(subSubCategoryCachedAfter.get(subCategory.getID())?.status).toEqual(CacheStatus.MISS);
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(parentCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID())
+      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subSubCategory.getID())
+      CategoryEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
   });
 
   it('handles cycles', async () => {
     const { CategoryEntity } = makeEntityClass(
-      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY
+      EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE_ONLY,
     );
 
     const companionProvider = createUnitTestEntityCompanionProvider();
@@ -298,16 +318,16 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     await expect(
       CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryA.getID())
+        .loadByFieldEqualingAsync('parent_category_id', categoryA.getID()),
     ).resolves.not.toBeNull();
     await expect(
       CategoryEntity.loader(viewerContext)
         .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryB.getID())
+        .loadByFieldEqualingAsync('parent_category_id', categoryB.getID()),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
-      CategoryEntity
+      CategoryEntity,
     )['entityCompanion']['tableDataCoordinator'][
       'cacheAdapter'
     ] as InMemoryFullCacheStubCacheAdapter<CategoryFields>;

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -20,7 +20,7 @@ describe(GenericEntityCacheAdapter, () => {
           ['id.wat', { status: CacheStatus.HIT, item: { id: 'wat' } }],
           ['id.who', { status: CacheStatus.NEGATIVE }],
           ['id.why', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
@@ -55,7 +55,7 @@ describe(GenericEntityCacheAdapter, () => {
       await cacheAdapter.cacheManyAsync('id', new Map([['wat', { id: 'wat' }]]));
 
       verify(
-        mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]])))
+        mockGenericCacher.cacheManyAsync(deepEqual(new Map([['id.wat', { id: 'wat' }]]))),
       ).once();
     });
   });

package/src/__tests__/ViewerContext-test.ts

@@ -22,7 +22,7 @@ describe(ViewerContext, () => {
           'postgres',
           async (queryContext) => {
             return queryContext.isInTransaction();
-          }
+          },
         );
       expect(didCreateTransaction).toBe(true);
     });

package/src/__tests__/ViewerScopedEntityCompanion-test.ts

@@ -23,10 +23,10 @@ describe(ViewerScopedEntityCompanion, () => {
       >();
     const viewerScopedEntityCompanion = new ViewerScopedEntityCompanion(entityCompanion, vc);
     expect(viewerScopedEntityCompanion.getLoaderFactory()).toBeInstanceOf(
-      ViewerScopedEntityLoaderFactory
+      ViewerScopedEntityLoaderFactory,
     );
     expect(viewerScopedEntityCompanion.getMutatorFactory()).toBeInstanceOf(
-      ViewerScopedEntityMutatorFactory
+      ViewerScopedEntityMutatorFactory,
     );
   });
 });

package/src/__tests__/ViewerScopedEntityCompanionProvider-test.ts

@@ -12,10 +12,10 @@ describe(ViewerScopedEntityCompanionProvider, () => {
     const entityCompanionProvider = instance(mock(EntityCompanionProvider));
     const viewerScopedEntityCompanionProvider = new ViewerScopedEntityCompanionProvider(
       entityCompanionProvider,
-      vc
+      vc,
     );
     expect(
-      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(TestEntity)
+      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(TestEntity),
     ).toBeInstanceOf(ViewerScopedEntityCompanion);
   });
 });

package/src/__tests__/ViewerScopedEntityLoaderFactory-test.ts

@@ -9,7 +9,8 @@ import ViewerScopedEntityLoaderFactory from '../ViewerScopedEntityLoaderFactory'
 describe(ViewerScopedEntityLoaderFactory, () => {
   it('correctly scopes viewer to entity loads', async () => {
     const viewerContext = instance(mock(ViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const privacyPolicyEvaluationContext =
+      instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>());
     const queryContext = instance(mock(EntityQueryContext));
     const baseLoader = mock<EntityLoaderFactory<any, any, any, any, any, any>>(EntityLoaderFactory);
     const baseLoaderInstance = instance(baseLoader);

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

@@ -1,7 +1,7 @@
 import Entity from '../../Entity';
 import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
-import { UUIDField, EnumField, StringField } from '../../EntityFields';
+import { UUIDField, StringField, StrictEnumField } from '../../EntityFields';
 import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
 import ViewerContext from '../../ViewerContext';
 import { successfulResults, failedResults } from '../../entityUtils';
@@ -28,17 +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).enforcing().loadByIDAsync(one.getID()),
     ).rejects.toThrowError('TwoTestEntity must be instantiated with two data');
 
     await expect(
-      OneTestEntity.loader(viewerContext).enforcing().loadByIDAsync(two.getID())
+      OneTestEntity.loader(viewerContext).enforcing().loadByIDAsync(two.getID()),
     ).rejects.toThrowError('OneTestEntity must be instantiated with one data');
 
-    const manyResults = await OneTestEntity.loader(viewerContext).loadManyByFieldEqualingAsync(
-      'common_other_field',
-      'wat'
-    );
+    const manyResults = await OneTestEntity.loader(viewerContext)
+      .withAuthorizationResults()
+      .loadManyByFieldEqualingAsync('common_other_field', 'wat');
     const successfulManyResults = successfulResults(manyResults);
     const failedManyResults = failedResults(manyResults);
 
@@ -47,22 +46,22 @@ describe('Two entities backed by the same table', () => {
 
     expect(successfulManyResults[0]!.enforceValue().getID()).toEqual(one.getID());
     expect(failedManyResults[0]!.enforceError().message).toEqual(
-      'OneTestEntity must be instantiated with one data'
+      'OneTestEntity must be instantiated with one data',
     );
 
-    const fieldEqualityConjunctionResults = await OneTestEntity.loader(
-      viewerContext
-    ).loadManyByFieldEqualityConjunctionAsync([
-      {
-        fieldName: 'common_other_field',
-        fieldValue: 'wat',
-      },
-    ]);
+    const fieldEqualityConjunctionResults = await OneTestEntity.loader(viewerContext)
+      .withAuthorizationResults()
+      .loadManyByFieldEqualityConjunctionAsync([
+        {
+          fieldName: 'common_other_field',
+          fieldValue: 'wat',
+        },
+      ]);
     const successfulfieldEqualityConjunctionResultsResults = successfulResults(
-      fieldEqualityConjunctionResults
+      fieldEqualityConjunctionResults,
     );
     const failedfieldEqualityConjunctionResultsResults = failedResults(
-      fieldEqualityConjunctionResults
+      fieldEqualityConjunctionResults,
     );
     expect(successfulfieldEqualityConjunctionResultsResults).toHaveLength(1);
     expect(failedfieldEqualityConjunctionResultsResults).toHaveLength(1);
@@ -98,8 +97,9 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
     common_other_field: new StringField({
       columnName: 'common_other_field',
     }),
-    entity_type: new EnumField({
+    entity_type: new StrictEnumField({
       columnName: 'entity_type',
+      enum: EntityType,
     }),
   },
   databaseAdapterFlavor: 'postgres',

package/src/__tests__/entityUtils-test.ts

@@ -52,7 +52,7 @@ describe(successfulResultsFilterMap, () => {
         a: result1,
         b: result2,
         c: result3,
-      })
+      }),
     );
 
     const resultingMap = successfulResultsFilterMap(allResults);
@@ -73,7 +73,7 @@ describe(failedResultsFilterMap, () => {
         a: result1,
         b: result2,
         c: result3,
-      })
+      }),
     );
 
     const resultingMap = failedResultsFilterMap(allResults);

package/src/entityUtils.ts

@@ -5,7 +5,7 @@ import { Result, Success, Failure } from '@expo/results';
  * @param resultsPromise - promise returning an array of results to enforce
  */
 export const enforceResultsAsync = async <T>(
-  resultsPromise: Promise<readonly Result<T>[]>
+  resultsPromise: Promise<readonly Result<T>[]>,
 ): Promise<readonly T[]> => {
   const results = await resultsPromise;
   return results.map((result) => result.enforceValue());
@@ -44,7 +44,7 @@ export const failedResults = <T>(results: readonly Result<T>[]): readonly Failur
  * @param results - map of results to filter.
  */
 export const successfulResultsFilterMap = <K, T>(
-  results: ReadonlyMap<K, Result<T>>
+  results: ReadonlyMap<K, Result<T>>,
 ): ReadonlyMap<K, Success<T>> => {
   const ret: Map<K, Success<T>> = new Map();
   for (const [k, result] of results) {
@@ -60,7 +60,7 @@ export const successfulResultsFilterMap = <K, T>(
  * @param results - map of results to filter.
  */
 export const failedResultsFilterMap = <K, T>(
-  results: ReadonlyMap<K, Result<T>>
+  results: ReadonlyMap<K, Result<T>>,
 ): ReadonlyMap<K, Failure<T>> => {
   const ret: Map<K, Failure<T>> = new Map();
   for (const [k, result] of results) {
@@ -97,6 +97,6 @@ const isError = <T>(value: T | Error): value is Error => {
 export const pick = <T extends object, U extends keyof T>(object: T, props: U[]): Pick<T, U> => {
   const propsSet = new Set(props);
   return Object.fromEntries(
-    Object.entries(object).filter((entry) => propsSet.has(entry[0] as any))
+    Object.entries(object).filter((entry) => propsSet.has(entry[0] as any)),
   ) as any;
 };

package/src/errors/EntityError.ts

@@ -24,7 +24,10 @@ export default abstract class EntityError extends ES6Error {
   public abstract readonly state: EntityErrorState;
   public abstract readonly code: EntityErrorCode;
 
-  constructor(message: string, public readonly cause?: Error) {
+  constructor(
+    message: string,
+    public override readonly cause?: Error,
+  ) {
     super(message);
   }
 }

package/src/errors/EntityInvalidFieldValueError.ts

@@ -17,7 +17,7 @@ export default class EntityInvalidFieldValueError<
     TSelectedFields
   >,
   N extends keyof TFields,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
   public readonly state = EntityErrorState.PERMANENT;
   public readonly code = EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE;
@@ -32,7 +32,7 @@ export default class EntityInvalidFieldValueError<
       TSelectedFields
     >,
     fieldName: N,
-    fieldValue?: TFields[N]
+    fieldValue?: TFields[N],
   ) {
     super(`Entity field not valid: ${entityClass.name} (${String(fieldName)} = ${fieldValue})`);
   }

package/src/errors/EntityNotAuthorizedError.ts

@@ -8,7 +8,7 @@ export default class EntityNotAuthorizedError<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
   public readonly state = EntityErrorState.PERMANENT;
   public readonly code = EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED;
@@ -19,10 +19,10 @@ export default class EntityNotAuthorizedError<
     entity: TEntity,
     viewerContext: TViewerContext,
     action: EntityAuthorizationAction,
-    ruleIndex: number
+    ruleIndex: number,
   ) {
     super(
-      `Entity not authorized: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${ruleIndex})`
+      `Entity not authorized: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${ruleIndex})`,
     );
     this.entityClassName = entity.constructor.name;
   }

package/src/errors/EntityNotFoundError.ts

@@ -17,7 +17,7 @@ export default class EntityNotFoundError<
     TSelectedFields
   >,
   N extends keyof TFields,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
   public readonly state = EntityErrorState.PERMANENT;
   public readonly code = EntityErrorCode.ERR_ENTITY_NOT_FOUND;
@@ -32,7 +32,7 @@ export default class EntityNotFoundError<
       TSelectedFields
     >,
     fieldName: N,
-    fieldValue: TFields[N]
+    fieldValue: TFields[N],
   ) {
     super(`Entity not found: ${entityClass.name} (${String(fieldName)} = ${fieldValue})`);
   }

package/src/index.ts

@@ -4,16 +4,14 @@
  * @module @expo/entity
  */
 
+export { default as AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
 export { default as ComposedEntityCacheAdapter } from './ComposedEntityCacheAdapter';
 export { default as ComposedSecondaryEntityCache } from './ComposedSecondaryEntityCache';
-export { default as GenericSecondaryEntityCache } from './GenericSecondaryEntityCache';
 export { default as EnforcingEntityLoader } from './EnforcingEntityLoader';
 export { default as Entity } from './Entity';
 export * from './Entity';
 export { default as EntityAssociationLoader } from './EntityAssociationLoader';
 export * from './EntityAssociationLoader';
-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';
@@ -21,32 +19,28 @@ export * from './EntityCompanionProvider';
 export { default as EntityConfiguration } from './EntityConfiguration';
 export { default as EntityDatabaseAdapter } from './EntityDatabaseAdapter';
 export * from './EntityDatabaseAdapter';
-export { default as EntityDatabaseAdapterError } from './errors/EntityDatabaseAdapterError';
-export * from './errors/EntityDatabaseAdapterError';
-export { default as EntityCacheAdapterError } from './errors/EntityCacheAdapterError';
-export * from './errors/EntityCacheAdapterError';
-export * from './errors/EntityError';
-export { default as EntityError } from './errors/EntityError';
-export { default as EntityNotAuthorizedError } from './errors/EntityNotAuthorizedError';
-export { default as EntityNotFoundError } from './errors/EntityNotFoundError';
-export * from './EntityFields';
 export * from './EntityFieldDefinition';
+export * from './EntityFields';
 export { default as EntityLoader } from './EntityLoader';
 export { default as EntityLoaderFactory } from './EntityLoaderFactory';
-export { default as EntitySecondaryCacheLoader } from './EntitySecondaryCacheLoader';
-export * from './EntitySecondaryCacheLoader';
-export * from './EntityMutator';
-export { default as EntityMutationValidator } from './EntityMutationValidator';
+export { default as EntityLoaderUtils } from './EntityLoaderUtils';
 export * from './EntityMutationInfo';
-export * from './EntityMutationTriggerConfiguration';
 export { default as EntityMutationTriggerConfiguration } from './EntityMutationTriggerConfiguration';
+export * from './EntityMutationTriggerConfiguration';
+export { default as EntityMutationValidator } from './EntityMutationValidator';
+export * from './EntityMutator';
 export { default as EntityMutatorFactory } from './EntityMutatorFactory';
 export { default as EntityPrivacyPolicy } from './EntityPrivacyPolicy';
 export * from './EntityPrivacyPolicy';
 export * from './EntityQueryContext';
+export { default as EntityQueryContextProvider } from './EntityQueryContextProvider';
+export { default as EntitySecondaryCacheLoader } from './EntitySecondaryCacheLoader';
+export * from './EntitySecondaryCacheLoader';
+export { default as GenericEntityCacheAdapter } from './GenericEntityCacheAdapter';
+export { default as GenericSecondaryEntityCache } from './GenericSecondaryEntityCache';
+export { default as IEntityCacheAdapter } from './IEntityCacheAdapter';
 export { default as IEntityCacheAdapterProvider } from './IEntityCacheAdapterProvider';
 export { default as IEntityDatabaseAdapterProvider } from './IEntityDatabaseAdapterProvider';
-export { default as EntityQueryContextProvider } from './EntityQueryContextProvider';
 export { default as IEntityGenericCacher } from './IEntityGenericCacher';
 export { default as ReadonlyEntity } from './ReadonlyEntity';
 export { default as ViewerContext } from './ViewerContext';
@@ -55,8 +49,18 @@ export { default as ViewerScopedEntityCompanionProvider } from './ViewerScopedEn
 export { default as ViewerScopedEntityLoaderFactory } from './ViewerScopedEntityLoaderFactory';
 export { default as ViewerScopedEntityMutatorFactory } from './ViewerScopedEntityMutatorFactory';
 export * from './entityUtils';
+export { default as EntityCacheAdapterError } from './errors/EntityCacheAdapterError';
+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 { default as EntityDataManager } from './internal/EntityDataManager';
 export * from './internal/EntityFieldTransformationUtils';
+export { default as EntityTableDataCoordinator } from './internal/EntityTableDataCoordinator';
 export { default as ReadThroughEntityCache } from './internal/ReadThroughEntityCache';
 export * from './internal/ReadThroughEntityCache';
 export * from './metrics/EntityMetricsUtils';
@@ -68,11 +72,13 @@ export { default as AlwaysDenyPrivacyPolicyRule } from './rules/AlwaysDenyPrivac
 export { default as AlwaysSkipPrivacyPolicyRule } from './rules/AlwaysSkipPrivacyPolicyRule';
 export { default as PrivacyPolicyRule } from './rules/PrivacyPolicyRule';
 export * from './rules/PrivacyPolicyRule';
+export * from './utils/EntityPrivacyUtils';
+export * from './utils/mergeEntityMutationTriggerConfigurations';
+export * from './utils/collections/maps';
 export * from './utils/testing/PrivacyPolicyRuleTestUtils';
 export * from './utils/testing/StubCacheAdapter';
-export { default as describeFieldTestCase } from './utils/testing/describeFieldTestCase';
 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/testing/createUnitTestEntityCompanionProvider';
-export * from './utils/collections/maps';
+export { default as describeFieldTestCase } from './utils/testing/describeFieldTestCase';