@expo/entity 0.32.0 → 0.34.0

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -14,20 +14,24 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
           .setField('stringField', testOtherEntity.getID())
           .createAsync()
       );
       const loadedOther = await enforceAsyncResult(
-        testEntity.associationLoader().loadAssociatedEntityAsync('stringField', TestEntity)
+        testEntity
+          .associationLoader()
+          .loadAssociatedEntityAsync('stringField', TestEntity, viewerContext.getQueryContext())
       );
       expect(loadedOther.getID()).toEqual(testOtherEntity.getID());
 
       const loadedOther2 = await enforceAsyncResult(
-        testEntity.associationLoader().loadAssociatedEntityAsync('nullableField', TestEntity)
+        testEntity
+          .associationLoader()
+          .loadAssociatedEntityAsync('nullableField', TestEntity, viewerContext.getQueryContext())
       );
       expect(loadedOther2).toBeNull();
     });
@@ -37,15 +41,27 @@ 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).createAsync());
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
+      );
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('stringField', testEntity.getID())
+          .createAsync()
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('stringField', testEntity.getID())
+          .createAsync()
       );
       const loaded = await enforceResultsAsync(
-        testEntity.associationLoader().loadManyAssociatedEntitiesAsync(TestEntity, 'stringField')
+        testEntity
+          .associationLoader()
+          .loadManyAssociatedEntitiesAsync(
+            TestEntity,
+            'stringField',
+            viewerContext.getQueryContext()
+          )
       );
       expect(loaded).toHaveLength(2);
       expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
@@ -58,16 +74,21 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
           .setField('stringField', testOtherEntity.getID())
           .createAsync()
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
+        .loadAssociatedEntityByFieldEqualingAsync(
+          'stringField',
+          TestEntity,
+          'customIdField',
+          viewerContext.getQueryContext()
+        );
       expect(loadedOtherResult?.enforceValue().getID()).toEqual(testOtherEntity.getID());
     });
 
@@ -75,11 +96,18 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', uuidv4()).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('stringField', uuidv4())
+          .createAsync()
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
+        .loadAssociatedEntityByFieldEqualingAsync(
+          'stringField',
+          TestEntity,
+          'customIdField',
+          viewerContext.getQueryContext()
+        );
       expect(loadedOtherResult).toBeNull();
     });
 
@@ -87,11 +115,18 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', 'blah').createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('stringField', 'blah')
+          .createAsync()
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('nullableField', TestEntity, 'customIdField');
+        .loadAssociatedEntityByFieldEqualingAsync(
+          'nullableField',
+          TestEntity,
+          'customIdField',
+          viewerContext.getQueryContext()
+        );
       expect(loadedOtherResult).toBeNull();
     });
   });
@@ -100,12 +135,18 @@ 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).createAsync());
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
+      );
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('stringField', testEntity.getID())
+          .createAsync()
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('stringField', testEntity.getID())
+          .createAsync()
       );
       const loaded = await enforceResultsAsync(
         testEntity
@@ -113,7 +154,8 @@ describe(EntityAssociationLoader, () => {
           .loadManyAssociatedEntitiesByFieldEqualingAsync(
             'customIdField',
             TestEntity,
-            'stringField'
+            'stringField',
+            viewerContext.getQueryContext()
           )
       );
       expect(loaded).toHaveLength(2);
@@ -124,14 +166,17 @@ 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).createAsync());
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
+      );
       const loaded = await enforceResultsAsync(
         testEntity
           .associationLoader()
           .loadManyAssociatedEntitiesByFieldEqualingAsync(
             'nullableField',
             TestEntity,
-            'stringField'
+            'stringField',
+            viewerContext.getQueryContext()
           )
       );
       expect(loaded).toHaveLength(0);
@@ -142,53 +187,68 @@ describe(EntityAssociationLoader, () => {
     it('chain loads associated entities', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity4 = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
+      const testEntity4 = await enforceAsyncResult(
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
+      );
       const testEntity3 = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', testEntity4.getID()).createAsync()
+        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('foreignKey', testEntity4.getID())
+          .createAsync()
       );
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
           .setField('testIndexedField', testEntity3.getID())
           .createAsync()
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', testEntity2.getID()).createAsync()
+        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('foreignKey', testEntity2.getID())
+          .createAsync()
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-      ]);
+      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
+        [
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+        ],
+        viewerContext.getQueryContext()
+      );
       expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
 
-      const loaded3Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-        {
-          associatedEntityClass: TestEntity2,
-          fieldIdentifyingAssociatedEntity: 'testIndexedField',
-        },
-      ]);
+      const loaded3Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
+        [
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+          {
+            associatedEntityClass: TestEntity2,
+            fieldIdentifyingAssociatedEntity: 'testIndexedField',
+          },
+        ],
+        viewerContext.getQueryContext()
+      );
       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',
-        },
-      ]);
+      const loaded4Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
+        [
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+          {
+            associatedEntityClass: TestEntity2,
+            fieldIdentifyingAssociatedEntity: 'testIndexedField',
+          },
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+        ],
+        viewerContext.getQueryContext()
+      );
       expect(loaded4Result?.enforceValue().getID()).toEqual(testEntity4.getID());
     });
 
@@ -197,15 +257,20 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync()
+        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('foreignKey', uuidv4())
+          .createAsync()
       );
 
-      const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-      ]);
+      const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
+        [
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+        ],
+        viewerContext.getQueryContext()
+      );
       expect(loadResult?.ok).toBe(false);
     });
 
@@ -215,19 +280,26 @@ describe(EntityAssociationLoader, () => {
 
       const fieldValue = uuidv4();
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', fieldValue).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('stringField', fieldValue)
+          .createAsync()
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', fieldValue).createAsync()
+        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('foreignKey', fieldValue)
+          .createAsync()
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-          associatedEntityLookupByField: 'stringField',
-        },
-      ]);
+      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
+        [
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+            associatedEntityLookupByField: 'stringField',
+          },
+        ],
+        viewerContext.getQueryContext()
+      );
       expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
     });
 
@@ -236,16 +308,21 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync()
+        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('foreignKey', uuidv4())
+          .createAsync()
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-          associatedEntityLookupByField: 'stringField',
-        },
-      ]);
+      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
+        [
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+            associatedEntityLookupByField: 'stringField',
+          },
+        ],
+        viewerContext.getQueryContext()
+      );
       expect(loaded2Result).toBeNull();
     });
 
@@ -254,15 +331,20 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('nullableField', null).createAsync()
+        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+          .setField('nullableField', null)
+          .createAsync()
       );
 
-      const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'nullableField',
-        },
-      ]);
+      const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
+        [
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'nullableField',
+          },
+        ],
+        viewerContext.getQueryContext()
+      );
       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 ViewerContext {
+class TestUserViewerContext extends TestViewerContext {
   constructor(entityCompanionProvider: EntityCompanionProvider, private readonly userID: string) {
     super(entityCompanionProvider);
   }
@@ -82,23 +82,23 @@ class DenyIfNotOwnerPrivacyPolicyRule extends PrivacyPolicyRule<
 class BlahEntityPrivacyPolicy extends EntityPrivacyPolicy<
   BlahFields,
   string,
-  ViewerContext,
+  TestUserViewerContext,
   BlahEntity
 > {
   protected override readonly createRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, TestUserViewerContext, BlahEntity>(),
   ];
   protected override readonly readRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, TestUserViewerContext, BlahEntity>(),
   ];
   protected override readonly updateRules = [
     new DenyIfNotOwnerPrivacyPolicyRule(),
-    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, TestUserViewerContext, BlahEntity>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysDenyPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+    new AlwaysDenyPrivacyPolicyRule<BlahFields, string, TestUserViewerContext, BlahEntity>(),
   ];
 }
 
@@ -110,15 +110,21 @@ it('runs through a common workflow', async () => {
   const vc2 = new TestUserViewerContext(entityCompanionProvider, uuidv4());
 
   const blahOwner1 = await enforceAsyncResult(
-    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync()
+    BlahEntity.creator(vc1, vc1.getQueryContext())
+      .setField('ownerID', vc1.getUserID()!)
+      .createAsync()
   );
 
   await enforceAsyncResult(
-    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync()
+    BlahEntity.creator(vc1, vc1.getQueryContext())
+      .setField('ownerID', vc1.getUserID()!)
+      .createAsync()
   );
 
   const blahOwner2 = await enforceAsyncResult(
-    BlahEntity.creator(vc2).setField('ownerID', vc2.getUserID()!).createAsync()
+    BlahEntity.creator(vc2, vc2.getQueryContext())
+      .setField('ownerID', vc2.getUserID()!)
+      .createAsync()
   );
 
   // sanity check created objects
@@ -127,33 +133,45 @@ it('runs through a common workflow', async () => {
 
   // check that two people can't read each others data
   await expect(
-    enforceAsyncResult(BlahEntity.loader(vc1).loadByIDAsync(blahOwner2.getID()))
+    enforceAsyncResult(
+      BlahEntity.loader(vc1, vc1.getQueryContext()).loadByIDAsync(blahOwner2.getID())
+    )
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
   await expect(
-    enforceAsyncResult(BlahEntity.loader(vc2).loadByIDAsync(blahOwner1.getID()))
+    enforceAsyncResult(
+      BlahEntity.loader(vc2, vc2.getQueryContext()).loadByIDAsync(blahOwner1.getID())
+    )
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
   // check that all of owner 1's objects can be loaded
   const results = await enforceResultsAsync(
-    BlahEntity.loader(vc1).loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()!)
+    BlahEntity.loader(vc1, vc1.getQueryContext()).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).setField('ownerID', blahOwner1.getID()).createAsync()
+      BlahEntity.creator(vc2, vc2.getQueryContext())
+        .setField('ownerID', blahOwner1.getID())
+        .createAsync()
     )
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
   // check that empty load many returns nothing
-  const results2 = await BlahEntity.loader(vc1).loadManyByFieldEqualingManyAsync('ownerID', []);
+  const results2 = await BlahEntity.loader(
+    vc1,
+    vc1.getQueryContext()
+  ).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))).rejects.toBeInstanceOf(
-    EntityNotAuthorizedError
-  );
+  await expect(
+    enforceAsyncResult(BlahEntity.deleteAsync(blahOwner2, vc1.getQueryContext()))
+  ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 });