@expo/entity 0.39.0 → 0.41.0

package/src/__tests__/EntitySelfReferentialEdges-test.ts

@@ -87,42 +87,34 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', parentCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', subCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory);
+    await CategoryEntity.deleter(parentCategory).deleteAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.toBeNull();
   });
 
@@ -132,21 +124,21 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', categoryA.getID())
-      .enforceCreateAsync();
+      .createAsync();
     await CategoryEntity.updater(categoryA)
       .setField('parent_category_id', categoryB.getID())
-      .enforceUpdateAsync();
+      .updateAsync();
 
-    await CategoryEntity.enforceDeleteAsync(categoryA);
+    await CategoryEntity.deleter(categoryA).deleteAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryA.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(categoryA.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(categoryB.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(categoryB.getID()),
     ).resolves.toBeNull();
   });
 });
@@ -158,44 +150,38 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', parentCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', subCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory);
+    await CategoryEntity.deleter(parentCategory).deleteAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
 
-    const loadedSubCategory = await CategoryEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(subCategory.getID());
+    const loadedSubCategory = await CategoryEntity.loader(viewerContext).loadByIDAsync(
+      subCategory.getID(),
+    );
     expect(loadedSubCategory.getField('parent_category_id')).toBeNull();
 
-    const loadedSubSubCategory = await CategoryEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(subSubCategory.getID());
+    const loadedSubSubCategory = await CategoryEntity.loader(viewerContext).loadByIDAsync(
+      subSubCategory.getID(),
+    );
     expect(loadedSubSubCategory.getField('parent_category_id')).not.toBeNull();
   });
 
@@ -205,19 +191,19 @@ describe('EntityEdgeDeletionBehavior.SET_NULL', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', categoryA.getID())
-      .enforceCreateAsync();
+      .createAsync();
     await CategoryEntity.updater(categoryA)
       .setField('parent_category_id', categoryB.getID())
-      .enforceUpdateAsync();
+      .updateAsync();
 
-    await CategoryEntity.enforceDeleteAsync(categoryA);
+    await CategoryEntity.deleter(categoryA).deleteAsync();
 
-    const loadedCategoryB = await CategoryEntity.loader(viewerContext)
-      .enforcing()
-      .loadByIDAsync(categoryB.getID());
+    const loadedCategoryB = await CategoryEntity.loader(viewerContext).loadByIDAsync(
+      categoryB.getID(),
+    );
     expect(loadedCategoryB.getField('parent_category_id')).toBeNull();
   });
 });
@@ -231,28 +217,28 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const parentCategory = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const parentCategory = await CategoryEntity.creator(viewerContext).createAsync();
     const subCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', parentCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
     const subSubCategory = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', subCategory.getID())
-      .enforceCreateAsync();
+      .createAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
+        'parent_category_id',
+        parentCategory.getID(),
+      ),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
+        'parent_category_id',
+        subCategory.getID(),
+      ),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
@@ -271,7 +257,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     );
     expect(subSubCategoryCachedBefore.get(subCategory.getID())?.status).toEqual(CacheStatus.HIT);
 
-    await CategoryEntity.enforceDeleteAsync(parentCategory);
+    await CategoryEntity.deleter(parentCategory).deleteAsync();
 
     const subCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
       parentCategory.getID(),
@@ -285,17 +271,13 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     expect(subSubCategoryCachedAfter.get(subCategory.getID())?.status).toEqual(CacheStatus.MISS);
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(parentCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(parentCategory.getID()),
     ).resolves.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext).enforcing().loadByIDNullableAsync(subCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subCategory.getID()),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByIDNullableAsync(subSubCategory.getID()),
+      CategoryEntity.loader(viewerContext).loadByIDNullableAsync(subSubCategory.getID()),
     ).resolves.not.toBeNull();
   });
 
@@ -307,23 +289,25 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new TestViewerContext(companionProvider);
 
-    const categoryA = await CategoryEntity.creator(viewerContext).enforceCreateAsync();
+    const categoryA = await CategoryEntity.creator(viewerContext).createAsync();
     const categoryB = await CategoryEntity.creator(viewerContext)
       .setField('parent_category_id', categoryA.getID())
-      .enforceCreateAsync();
+      .createAsync();
     await CategoryEntity.updater(categoryA)
       .setField('parent_category_id', categoryB.getID())
-      .enforceUpdateAsync();
+      .updateAsync();
 
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryA.getID()),
+      CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
+        'parent_category_id',
+        categoryA.getID(),
+      ),
     ).resolves.not.toBeNull();
     await expect(
-      CategoryEntity.loader(viewerContext)
-        .enforcing()
-        .loadByFieldEqualingAsync('parent_category_id', categoryB.getID()),
+      CategoryEntity.loader(viewerContext).loadByFieldEqualingAsync(
+        'parent_category_id',
+        categoryB.getID(),
+      ),
     ).resolves.not.toBeNull();
 
     const categoryCacheAdapter = viewerContext.getViewerScopedEntityCompanionForClass(
@@ -338,7 +322,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     expect(categoriesCachedBefore.get(categoryA.getID())?.status).toEqual(CacheStatus.HIT);
     expect(categoriesCachedBefore.get(categoryB.getID())?.status).toEqual(CacheStatus.HIT);
 
-    await CategoryEntity.enforceDeleteAsync(categoryA);
+    await CategoryEntity.deleter(categoryA).deleteAsync();
 
     const categoriesCachedAfter = await categoryCacheAdapter.loadManyAsync('parent_category_id', [
       categoryA.getID(),

package/src/__tests__/ReadonlyEntity-test.ts

@@ -1,7 +1,10 @@
 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';
@@ -127,7 +130,7 @@ describe(ReadonlyEntity, () => {
     }).toThrow();
   });
 
-  it('returns correct viewerCo}ntext from instantiation', () => {
+  it('returns correct viewerContext from instantiation', () => {
     const viewerContext = instance(mock(ViewerContext));
     const data = {
       id: 'what',
@@ -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__/cases/TwoEntitySameTableDisjointRows-test.ts

@@ -16,28 +16,28 @@ describe('Two entities backed by the same table', () => {
     const one = await OneTestEntity.creator(viewerContext)
       .setField('entity_type', EntityType.ONE)
       .setField('common_other_field', 'wat')
-      .enforceCreateAsync();
+      .createAsync();
 
     const two = await TwoTestEntity.creator(viewerContext)
       .setField('entity_type', EntityType.TWO)
       .setField('other_field', 'blah')
       .setField('common_other_field', 'wat')
-      .enforceCreateAsync();
+      .createAsync();
 
     expect(one).toBeInstanceOf(OneTestEntity);
     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);
 
@@ -49,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,
     );

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

@@ -14,27 +14,23 @@ describe('Two entities backed by the same table', () => {
 
     const entity1 = await OneTestEntity.creator(viewerContext)
       .setField('fake_field', 'hello')
-      .enforceCreateAsync();
+      .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)
       .setField('fake_field', 'world')
       .setField('other_field', 'wat')
-      .enforceUpdateAsync();
+      .updateAsync();
     expect(updated2.getAllFields()).toMatchObject({
       id: updated2.getID(),
       other_field: 'wat',
       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,34 +44,35 @@ describe('Two entities backed by the same table', () => {
     const entity = await TwoTestEntity.creator(viewerContext)
       .setField('fake_field', 'hello')
       .setField('other_field', 'huh')
-      .enforceCreateAsync();
+      .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).setField('fake_field', 'world').enforceUpdateAsync();
+    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',

package/src/index.ts

@@ -4,31 +4,38 @@
  * @module @expo/entity
  */
 
+export { default as AuthorizationResultBasedEntityAssociationLoader } from './AuthorizationResultBasedEntityAssociationLoader';
+export * from './AuthorizationResultBasedEntityAssociationLoader';
 export { default as AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
+export * from './AuthorizationResultBasedEntityMutator';
 export { default as ComposedEntityCacheAdapter } from './ComposedEntityCacheAdapter';
 export { default as ComposedSecondaryEntityCache } from './ComposedSecondaryEntityCache';
+export { default as EnforcingEntityAssociationLoader } from './EnforcingEntityAssociationLoader';
+export { default as EnforcingEntityCreator } from './EnforcingEntityCreator';
+export { default as EnforcingEntityDeleter } from './EnforcingEntityDeleter';
 export { default as EnforcingEntityLoader } from './EnforcingEntityLoader';
+export { default as EnforcingEntityUpdater } from './EnforcingEntityUpdater';
 export { default as Entity } from './Entity';
 export * from './Entity';
 export { default as EntityAssociationLoader } from './EntityAssociationLoader';
-export * from './EntityAssociationLoader';
 export { default as EntityCompanion } from './EntityCompanion';
 export * from './EntityCompanion';
 export { default as EntityCompanionProvider } from './EntityCompanionProvider';
 export * from './EntityCompanionProvider';
 export { default as EntityConfiguration } from './EntityConfiguration';
+export { default as EntityCreator } from './EntityCreator';
 export { default as EntityDatabaseAdapter } from './EntityDatabaseAdapter';
 export * from './EntityDatabaseAdapter';
+export { default as EntityDeleter } from './EntityDeleter';
 export * from './EntityFieldDefinition';
 export * from './EntityFields';
 export { default as EntityLoader } from './EntityLoader';
 export { default as EntityLoaderFactory } from './EntityLoaderFactory';
 export { default as EntityLoaderUtils } from './EntityLoaderUtils';
 export * from './EntityMutationInfo';
-export { default as EntityMutationTriggerConfiguration } from './EntityMutationTriggerConfiguration';
+export { type 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';
@@ -36,19 +43,20 @@ export * from './EntityQueryContext';
 export { default as EntityQueryContextProvider } from './EntityQueryContextProvider';
 export { default as EntitySecondaryCacheLoader } from './EntitySecondaryCacheLoader';
 export * from './EntitySecondaryCacheLoader';
+export { default as EntityUpdater } from './EntityUpdater';
+export * from './entityUtils';
 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 IEntityGenericCacher } from './IEntityGenericCacher';
+export { type default as IEntityCacheAdapter } from './IEntityCacheAdapter';
+export { type default as IEntityCacheAdapterProvider } from './IEntityCacheAdapterProvider';
+export { type default as IEntityDatabaseAdapterProvider } from './IEntityDatabaseAdapterProvider';
+export { type default as IEntityGenericCacher } from './IEntityGenericCacher';
 export { default as ReadonlyEntity } from './ReadonlyEntity';
 export { default as ViewerContext } from './ViewerContext';
 export { default as ViewerScopedEntityCompanion } from './ViewerScopedEntityCompanion';
 export { default as ViewerScopedEntityCompanionProvider } from './ViewerScopedEntityCompanionProvider';
 export { default as ViewerScopedEntityLoaderFactory } from './ViewerScopedEntityLoaderFactory';
 export { default as ViewerScopedEntityMutatorFactory } from './ViewerScopedEntityMutatorFactory';
-export * from './entityUtils';
 export { default as EntityCacheAdapterError } from './errors/EntityCacheAdapterError';
 export * from './errors/EntityCacheAdapterError';
 export { default as EntityDatabaseAdapterError } from './errors/EntityDatabaseAdapterError';
@@ -64,7 +72,7 @@ export { default as EntityTableDataCoordinator } from './internal/EntityTableDat
 export { default as ReadThroughEntityCache } from './internal/ReadThroughEntityCache';
 export * from './internal/ReadThroughEntityCache';
 export * from './metrics/EntityMetricsUtils';
-export { default as IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
+export { type default as IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
 export * from './metrics/IEntityMetricsAdapter';
 export { default as NoOpEntityMetricsAdapter } from './metrics/NoOpEntityMetricsAdapter';
 export { default as AlwaysAllowPrivacyPolicyRule } from './rules/AlwaysAllowPrivacyPolicyRule';
@@ -75,10 +83,10 @@ 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/testing/createUnitTestEntityCompanionProvider';
-export { default as describeFieldTestCase } from './utils/testing/describeFieldTestCase';