@expo/entity 0.40.0 → 0.41.0

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';
@@ -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

@@ -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,
     );

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

@@ -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',

package/src/utils/__tests__/EntityPrivacyUtils-test.ts

@@ -50,9 +50,7 @@ describe(canViewerUpdateAsync, () => {
   it('appropriately executes update privacy policy', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyDeleteEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyDeleteEntity.creator(viewerContext).createAsync();
     const canViewerUpdate = await canViewerUpdateAsync(SimpleTestDenyDeleteEntity, testEntity);
     expect(canViewerUpdate).toBe(true);
     const canViewerUpdateResult = await getCanViewerUpdateResultAsync(
@@ -65,9 +63,7 @@ describe(canViewerUpdateAsync, () => {
   it('denies when policy denies', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext).createAsync();
     const canViewerUpdate = await canViewerUpdateAsync(SimpleTestDenyUpdateEntity, testEntity);
     expect(canViewerUpdate).toBe(false);
     const canViewerUpdateResult = await getCanViewerUpdateResultAsync(
@@ -83,9 +79,7 @@ describe(canViewerUpdateAsync, () => {
   it('rethrows non-authorization errors', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestThrowOtherErrorEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestThrowOtherErrorEntity.creator(viewerContext).createAsync();
     await expect(canViewerUpdateAsync(SimpleTestThrowOtherErrorEntity, testEntity)).rejects.toThrow(
       'update error',
     );
@@ -99,9 +93,7 @@ describe(canViewerDeleteAsync, () => {
   it('appropriately executes update privacy policy', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext).createAsync();
     const canViewerDelete = await canViewerDeleteAsync(SimpleTestDenyUpdateEntity, testEntity);
     expect(canViewerDelete).toBe(true);
     const canViewerDeleteResult = await getCanViewerDeleteResultAsync(
@@ -114,9 +106,7 @@ describe(canViewerDeleteAsync, () => {
   it('denies when policy denies', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyDeleteEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyDeleteEntity.creator(viewerContext).createAsync();
     const canViewerDelete = await canViewerDeleteAsync(SimpleTestDenyDeleteEntity, testEntity);
     expect(canViewerDelete).toBe(false);
     const canViewerDeleteResult = await getCanViewerDeleteResultAsync(
@@ -132,12 +122,9 @@ describe(canViewerDeleteAsync, () => {
   it('denies when recursive policy denies for CASCADE_DELETE', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext).createAsync();
     // add another entity referencing testEntity that would cascade deletion to itself when testEntity is deleted
     const leafEntity = await LeafDenyDeleteEntity.creator(viewerContext)
-      .enforcing()
       .setField('simple_test_deny_update_cascade_delete_id', testEntity.getID())
       .createAsync();
     const canViewerDelete = await canViewerDeleteAsync(SimpleTestDenyUpdateEntity, testEntity);
@@ -155,12 +142,9 @@ describe(canViewerDeleteAsync, () => {
   it('denies when recursive policy denies for SET_NULL', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext).createAsync();
     // add another entity referencing testEntity that would set null to its column when testEntity is deleted
     const leafEntity = await LeafDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
       .setField('simple_test_deny_update_set_null_id', testEntity.getID())
       .createAsync();
     const canViewerDelete = await canViewerDeleteAsync(SimpleTestDenyUpdateEntity, testEntity);
@@ -178,17 +162,13 @@ describe(canViewerDeleteAsync, () => {
   it('allows when recursive policy allows for CASCADE_DELETE and SET_NULL', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext).createAsync();
     // add another entity referencing testEntity that would cascade deletion to itself when testEntity is deleted
     await LeafDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
       .setField('simple_test_deny_update_cascade_delete_id', testEntity.getID())
       .createAsync();
     // add another entity referencing testEntity that would set null to its column when testEntity is deleted
     await LeafDenyDeleteEntity.creator(viewerContext)
-      .enforcing()
       .setField('simple_test_deny_update_set_null_id', testEntity.getID())
       .createAsync();
 
@@ -204,9 +184,7 @@ describe(canViewerDeleteAsync, () => {
   it('rethrows non-authorization errors', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestThrowOtherErrorEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestThrowOtherErrorEntity.creator(viewerContext).createAsync();
     await expect(
       canViewerDeleteAsync(SimpleTestThrowOtherErrorEntity, testEntity),
     ).rejects.toThrowError('delete error');
@@ -218,11 +196,8 @@ describe(canViewerDeleteAsync, () => {
   it('returns false when edge cannot be read', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext).createAsync();
     const leafEntity = await LeafDenyReadEntity.creator(viewerContext)
-      .enforcing()
       .setField('simple_test_id', testEntity.getID())
       .createAsync();
     const canViewerDelete = await canViewerDeleteAsync(SimpleTestDenyUpdateEntity, testEntity);
@@ -240,11 +215,8 @@ describe(canViewerDeleteAsync, () => {
   it('rethrows non-authorization edge read errors', async () => {
     const companionProvider = createUnitTestEntityCompanionProvider();
     const viewerContext = new ViewerContext(companionProvider);
-    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext)
-      .enforcing()
-      .createAsync();
+    const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext).createAsync();
     await SimpleTestThrowOtherErrorEntity.creator(viewerContext)
-      .enforcing()
       .setField('simple_test_id', testEntity.getID())
       .createAsync();
     await expect(canViewerDeleteAsync(SimpleTestDenyUpdateEntity, testEntity)).rejects.toThrowError(
@@ -261,11 +233,11 @@ describe(canViewerDeleteAsync, () => {
     const canViewerDelete = await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
       'postgres',
       async (queryContext) => {
-        const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext, queryContext)
-          .enforcing()
-          .createAsync();
+        const testEntity = await SimpleTestDenyUpdateEntity.creator(
+          viewerContext,
+          queryContext,
+        ).createAsync();
         await LeafDenyReadEntity.creator(viewerContext, queryContext)
-          .enforcing()
           .setField('simple_test_id', testEntity.getID())
           .createAsync();
         // this would fail if transactions weren't supported or correctly passed through
@@ -277,11 +249,11 @@ describe(canViewerDeleteAsync, () => {
     const canViewerDeleteResult = await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
       'postgres',
       async (queryContext) => {
-        const testEntity = await SimpleTestDenyUpdateEntity.creator(viewerContext, queryContext)
-          .enforcing()
-          .createAsync();
+        const testEntity = await SimpleTestDenyUpdateEntity.creator(
+          viewerContext,
+          queryContext,
+        ).createAsync();
         await LeafDenyReadEntity.creator(viewerContext, queryContext)
-          .enforcing()
           .setField('simple_test_id', testEntity.getID())
           .createAsync();
         // this would fail if transactions weren't supported or correctly passed through

package/src/utils/__tests__/canViewerDeleteAsync-edgeDeletionPermissionInferenceBehavior-test.ts

@@ -21,20 +21,18 @@ describe(canViewerDeleteAsync, () => {
       const viewerContext = new ViewerContext(companionProvider);
 
       // create root
-      const testEntity = await TestEntity.creator(viewerContext).enforcing().createAsync();
+      const testEntity = await TestEntity.creator(viewerContext).createAsync();
 
       // create a bunch of leaves referencing root with
       // edgeDeletionPermissionInferenceBehavior = EntityEdgeDeletionPermissionInferenceBehavior.ONE_IMPLIES_ALL
       for (let i = 0; i < 10; i++) {
         await TestLeafEntity.creator(viewerContext)
-          .enforcing()
           .setField('test_entity_id', testEntity.getID())
           .createAsync();
       }
 
       for (let i = 0; i < 10; i++) {
         await TestLeafLookupByFieldEntity.creator(viewerContext)
-          .enforcing()
           .setField('test_entity_id', testEntity.getID())
           .createAsync();
       }
@@ -65,12 +63,11 @@ describe(canViewerDeleteAsync, () => {
       const viewerContext = new ViewerContext(companionProvider);
 
       // create root
-      const testEntity = await TestEntity.creator(viewerContext).enforcing().createAsync();
+      const testEntity = await TestEntity.creator(viewerContext).createAsync();
 
       // create a bunch of leaves with no edgeDeletionPermissionInferenceBehavior
       for (let i = 0; i < 10; i++) {
         await TestLeafNoInferenceEntity.creator(viewerContext)
-          .enforcing()
           .setField('test_entity_id', testEntity.getID())
           .createAsync();
       }