@expo/entity 0.34.0 → 0.35.0

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -14,24 +14,20 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
+        TestEntity.creator(viewerContext).createAsync()
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+        TestEntity.creator(viewerContext)
           .setField('stringField', testOtherEntity.getID())
           .createAsync()
       );
       const loadedOther = await enforceAsyncResult(
-        testEntity
-          .associationLoader()
-          .loadAssociatedEntityAsync('stringField', TestEntity, viewerContext.getQueryContext())
+        testEntity.associationLoader().loadAssociatedEntityAsync('stringField', TestEntity)
       );
       expect(loadedOther.getID()).toEqual(testOtherEntity.getID());
 
       const loadedOther2 = await enforceAsyncResult(
-        testEntity
-          .associationLoader()
-          .loadAssociatedEntityAsync('nullableField', TestEntity, viewerContext.getQueryContext())
+        testEntity.associationLoader().loadAssociatedEntityAsync('nullableField', TestEntity)
       );
       expect(loadedOther2).toBeNull();
     });
@@ -41,27 +37,15 @@ describe(EntityAssociationLoader, () => {
     it('loads many associated entities referencing this entity', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
-      );
+      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', testEntity.getID())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', testEntity.getID())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
       );
       const loaded = await enforceResultsAsync(
-        testEntity
-          .associationLoader()
-          .loadManyAssociatedEntitiesAsync(
-            TestEntity,
-            'stringField',
-            viewerContext.getQueryContext()
-          )
+        testEntity.associationLoader().loadManyAssociatedEntitiesAsync(TestEntity, 'stringField')
       );
       expect(loaded).toHaveLength(2);
       expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
@@ -74,21 +58,16 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
+        TestEntity.creator(viewerContext).createAsync()
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+        TestEntity.creator(viewerContext)
           .setField('stringField', testOtherEntity.getID())
           .createAsync()
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync(
-          'stringField',
-          TestEntity,
-          'customIdField',
-          viewerContext.getQueryContext()
-        );
+        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
       expect(loadedOtherResult?.enforceValue().getID()).toEqual(testOtherEntity.getID());
     });
 
@@ -96,18 +75,11 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', uuidv4())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', uuidv4()).createAsync()
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync(
-          'stringField',
-          TestEntity,
-          'customIdField',
-          viewerContext.getQueryContext()
-        );
+        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
       expect(loadedOtherResult).toBeNull();
     });
 
@@ -115,18 +87,11 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', 'blah')
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', 'blah').createAsync()
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync(
-          'nullableField',
-          TestEntity,
-          'customIdField',
-          viewerContext.getQueryContext()
-        );
+        .loadAssociatedEntityByFieldEqualingAsync('nullableField', TestEntity, 'customIdField');
       expect(loadedOtherResult).toBeNull();
     });
   });
@@ -135,18 +100,12 @@ describe(EntityAssociationLoader, () => {
     it('loads many associated entities by field equaling', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
-      );
+      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', testEntity.getID())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', testEntity.getID())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
       );
       const loaded = await enforceResultsAsync(
         testEntity
@@ -154,8 +113,7 @@ describe(EntityAssociationLoader, () => {
           .loadManyAssociatedEntitiesByFieldEqualingAsync(
             'customIdField',
             TestEntity,
-            'stringField',
-            viewerContext.getQueryContext()
+            'stringField'
           )
       );
       expect(loaded).toHaveLength(2);
@@ -166,17 +124,14 @@ describe(EntityAssociationLoader, () => {
     it('returns empty results when field being queried by is null', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
-      );
+      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const loaded = await enforceResultsAsync(
         testEntity
           .associationLoader()
           .loadManyAssociatedEntitiesByFieldEqualingAsync(
             'nullableField',
             TestEntity,
-            'stringField',
-            viewerContext.getQueryContext()
+            'stringField'
           )
       );
       expect(loaded).toHaveLength(0);
@@ -187,68 +142,53 @@ describe(EntityAssociationLoader, () => {
     it('chain loads associated entities', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity4 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
-      );
+      const testEntity4 = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testEntity3 = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('foreignKey', testEntity4.getID())
-          .createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', testEntity4.getID()).createAsync()
       );
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+        TestEntity.creator(viewerContext)
           .setField('testIndexedField', testEntity3.getID())
           .createAsync()
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('foreignKey', testEntity2.getID())
-          .createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', testEntity2.getID()).createAsync()
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+        },
+      ]);
       expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
 
-      const loaded3Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-          },
-          {
-            associatedEntityClass: TestEntity2,
-            fieldIdentifyingAssociatedEntity: 'testIndexedField',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loaded3Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+        },
+        {
+          associatedEntityClass: TestEntity2,
+          fieldIdentifyingAssociatedEntity: 'testIndexedField',
+        },
+      ]);
       expect(loaded3Result?.enforceValue().getID()).toEqual(testEntity3.getID());
 
-      const loaded4Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-          },
-          {
-            associatedEntityClass: TestEntity2,
-            fieldIdentifyingAssociatedEntity: 'testIndexedField',
-          },
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loaded4Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+        },
+        {
+          associatedEntityClass: TestEntity2,
+          fieldIdentifyingAssociatedEntity: 'testIndexedField',
+        },
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+        },
+      ]);
       expect(loaded4Result?.enforceValue().getID()).toEqual(testEntity4.getID());
     });
 
@@ -257,20 +197,15 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('foreignKey', uuidv4())
-          .createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync()
       );
 
-      const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+        },
+      ]);
       expect(loadResult?.ok).toBe(false);
     });
 
@@ -280,26 +215,19 @@ describe(EntityAssociationLoader, () => {
 
       const fieldValue = uuidv4();
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', fieldValue)
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', fieldValue).createAsync()
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('foreignKey', fieldValue)
-          .createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', fieldValue).createAsync()
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-            associatedEntityLookupByField: 'stringField',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+          associatedEntityLookupByField: 'stringField',
+        },
+      ]);
       expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
     });
 
@@ -308,21 +236,16 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('foreignKey', uuidv4())
-          .createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync()
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-            associatedEntityLookupByField: 'stringField',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+          associatedEntityLookupByField: 'stringField',
+        },
+      ]);
       expect(loaded2Result).toBeNull();
     });
 
@@ -331,20 +254,15 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('nullableField', null)
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('nullableField', null).createAsync()
       );
 
-      const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'nullableField',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'nullableField',
+        },
+      ]);
       expect(loadedResult).toBeNull();
     });
   });

package/src/__tests__/EntityCommonUseCases-test.ts

@@ -7,15 +7,15 @@ import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
 import EntityPrivacyPolicy, { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
+import ViewerContext from '../ViewerContext';
 import { enforceResultsAsync } from '../entityUtils';
 import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
 import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
 import AlwaysDenyPrivacyPolicyRule from '../rules/AlwaysDenyPrivacyPolicyRule';
 import PrivacyPolicyRule, { RuleEvaluationResult } from '../rules/PrivacyPolicyRule';
-import TestViewerContext from '../testfixtures/TestViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
-class TestUserViewerContext extends TestViewerContext {
+class TestUserViewerContext extends ViewerContext {
   constructor(entityCompanionProvider: EntityCompanionProvider, private readonly userID: string) {
     super(entityCompanionProvider);
   }
@@ -82,23 +82,23 @@ class DenyIfNotOwnerPrivacyPolicyRule extends PrivacyPolicyRule<
 class BlahEntityPrivacyPolicy extends EntityPrivacyPolicy<
   BlahFields,
   string,
-  TestUserViewerContext,
+  ViewerContext,
   BlahEntity
 > {
   protected override readonly createRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, TestUserViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
   ];
   protected override readonly readRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, TestUserViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
   ];
   protected override readonly updateRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, TestUserViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysDenyPrivacyPolicyRule<BlahFields, string, TestUserViewerContext, BlahEntity>(),
+    new AlwaysDenyPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
   ];
 }
 
@@ -110,21 +110,15 @@ it('runs through a common workflow', async () => {
   const vc2 = new TestUserViewerContext(entityCompanionProvider, uuidv4());
 
   const blahOwner1 = await enforceAsyncResult(
-    BlahEntity.creator(vc1, vc1.getQueryContext())
-      .setField('ownerID', vc1.getUserID()!)
-      .createAsync()
+    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync()
   );
 
   await enforceAsyncResult(
-    BlahEntity.creator(vc1, vc1.getQueryContext())
-      .setField('ownerID', vc1.getUserID()!)
-      .createAsync()
+    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync()
   );
 
   const blahOwner2 = await enforceAsyncResult(
-    BlahEntity.creator(vc2, vc2.getQueryContext())
-      .setField('ownerID', vc2.getUserID()!)
-      .createAsync()
+    BlahEntity.creator(vc2).setField('ownerID', vc2.getUserID()!).createAsync()
   );
 
   // sanity check created objects
@@ -133,45 +127,33 @@ it('runs through a common workflow', async () => {
 
   // check that two people can't read each others data
   await expect(
-    enforceAsyncResult(
-      BlahEntity.loader(vc1, vc1.getQueryContext()).loadByIDAsync(blahOwner2.getID())
-    )
+    enforceAsyncResult(BlahEntity.loader(vc1).loadByIDAsync(blahOwner2.getID()))
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
   await expect(
-    enforceAsyncResult(
-      BlahEntity.loader(vc2, vc2.getQueryContext()).loadByIDAsync(blahOwner1.getID())
-    )
+    enforceAsyncResult(BlahEntity.loader(vc2).loadByIDAsync(blahOwner1.getID()))
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
   // check that all of owner 1's objects can be loaded
   const results = await enforceResultsAsync(
-    BlahEntity.loader(vc1, vc1.getQueryContext()).loadManyByFieldEqualingAsync(
-      'ownerID',
-      vc1.getUserID()!
-    )
+    BlahEntity.loader(vc1).loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()!)
   );
   expect(results).toHaveLength(2);
 
   // check that two people can't create objects owned by others
   await expect(
     enforceAsyncResult(
-      BlahEntity.creator(vc2, vc2.getQueryContext())
-        .setField('ownerID', blahOwner1.getID())
-        .createAsync()
+      BlahEntity.creator(vc2).setField('ownerID', blahOwner1.getID()).createAsync()
     )
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
   // check that empty load many returns nothing
-  const results2 = await BlahEntity.loader(
-    vc1,
-    vc1.getQueryContext()
-  ).loadManyByFieldEqualingManyAsync('ownerID', []);
+  const results2 = await BlahEntity.loader(vc1).loadManyByFieldEqualingManyAsync('ownerID', []);
   for (const value in results2.values) {
     expect(value).toHaveLength(0);
   }
 
   // check that the user can't delete their own data (as specified by privacy rules)
-  await expect(
-    enforceAsyncResult(BlahEntity.deleteAsync(blahOwner2, vc1.getQueryContext()))
-  ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
+  await expect(enforceAsyncResult(BlahEntity.deleteAsync(blahOwner2))).rejects.toBeInstanceOf(
+    EntityNotAuthorizedError
+  );
 });