@expo/entity 0.38.0 → 0.40.0

package/src/__tests__/AuthorizationResultBasedEntityAssociationLoader-test.ts

@@ -0,0 +1,354 @@
+import { enforceAsyncResult } from '@expo/results';
+import { v4 as uuidv4 } from 'uuid';
+
+import AuthorizationResultBasedEntityAssociationLoader from '../AuthorizationResultBasedEntityAssociationLoader';
+import { enforceResultsAsync } from '../entityUtils';
+import TestEntity from '../testfixtures/TestEntity';
+import TestEntity2 from '../testfixtures/TestEntity2';
+import TestViewerContext from '../testfixtures/TestViewerContext';
+import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+
+describe(AuthorizationResultBasedEntityAssociationLoader, () => {
+  describe('loadAssociatedEntityAsync', () => {
+    it('loads associated entities by ID and correctly handles a null value', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+      const testOtherEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+      );
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', testOtherEntity.getID())
+          .createAsync(),
+      );
+      const loadedOther = await enforceAsyncResult(
+        testEntity
+          .associationLoader()
+          .withAuthorizationResults()
+          .loadAssociatedEntityAsync('stringField', TestEntity),
+      );
+      expect(loadedOther.getID()).toEqual(testOtherEntity.getID());
+
+      const loadedOther2 = await enforceAsyncResult(
+        testEntity
+          .associationLoader()
+          .withAuthorizationResults()
+          .loadAssociatedEntityAsync('nullableField', TestEntity),
+      );
+      expect(loadedOther2).toBeNull();
+    });
+  });
+
+  describe('loadManyAssociatedEntitiesAsync', () => {
+    it('loads many associated entities referencing this entity', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+      );
+      const testOtherEntity1 = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', testEntity.getID())
+          .createAsync(),
+      );
+      const testOtherEntity2 = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', testEntity.getID())
+          .createAsync(),
+      );
+      const loaded = await enforceResultsAsync(
+        testEntity
+          .associationLoader()
+          .withAuthorizationResults()
+          .loadManyAssociatedEntitiesAsync(TestEntity, 'stringField'),
+      );
+      expect(loaded).toHaveLength(2);
+      expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
+      expect(loaded.find((e) => e.getID() === testOtherEntity2.getID())).not.toBeUndefined();
+    });
+  });
+
+  describe('loadAssociatedEntityByFieldEqualingAsync', () => {
+    it('loads associated entity by field equaling', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+      const testOtherEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+      );
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', testOtherEntity.getID())
+          .createAsync(),
+      );
+      const loadedOtherResult = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
+      expect(loadedOtherResult?.enforceValue().getID()).toEqual(testOtherEntity.getID());
+    });
+
+    it('returns null when loading associated entities by field equaling a non existent association', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', uuidv4())
+          .createAsync(),
+      );
+      const loadedOtherResult = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
+      expect(loadedOtherResult).toBeNull();
+    });
+
+    it('returns null when load-by field is null', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', 'blah')
+          .createAsync(),
+      );
+      const loadedOtherResult = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityByFieldEqualingAsync('nullableField', TestEntity, 'customIdField');
+      expect(loadedOtherResult).toBeNull();
+    });
+  });
+
+  describe('loadManyAssociatedEntitiesByFieldEqualingAsync', () => {
+    it('loads many associated entities by field equaling', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+      );
+      const testOtherEntity1 = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', testEntity.getID())
+          .createAsync(),
+      );
+      const testOtherEntity2 = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', testEntity.getID())
+          .createAsync(),
+      );
+      const loaded = await enforceResultsAsync(
+        testEntity
+          .associationLoader()
+          .withAuthorizationResults()
+          .loadManyAssociatedEntitiesByFieldEqualingAsync(
+            'customIdField',
+            TestEntity,
+            'stringField',
+          ),
+      );
+      expect(loaded).toHaveLength(2);
+      expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
+      expect(loaded.find((e) => e.getID() === testOtherEntity2.getID())).not.toBeUndefined();
+    });
+
+    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).withAuthorizationResults().createAsync(),
+      );
+      const loaded = await enforceResultsAsync(
+        testEntity
+          .associationLoader()
+          .withAuthorizationResults()
+          .loadManyAssociatedEntitiesByFieldEqualingAsync(
+            'nullableField',
+            TestEntity,
+            'stringField',
+          ),
+      );
+      expect(loaded).toHaveLength(0);
+    });
+  });
+
+  describe('loadAssociatedEntityThroughAsync', () => {
+    it('chain loads associated entities', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+      const testEntity4 = await enforceAsyncResult(
+        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+      );
+      const testEntity3 = await enforceAsyncResult(
+        TestEntity2.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('foreignKey', testEntity4.getID())
+          .createAsync(),
+      );
+      const testEntity2 = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('testIndexedField', testEntity3.getID())
+          .createAsync(),
+      );
+      const testEntity = await enforceAsyncResult(
+        TestEntity2.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('foreignKey', testEntity2.getID())
+          .createAsync(),
+      );
+
+      const loaded2Result = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityThroughAsync([
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+        ]);
+      expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
+
+      const loaded3Result = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityThroughAsync([
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+          {
+            associatedEntityClass: TestEntity2,
+            fieldIdentifyingAssociatedEntity: 'testIndexedField',
+          },
+        ]);
+      expect(loaded3Result?.enforceValue().getID()).toEqual(testEntity3.getID());
+
+      const loaded4Result = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityThroughAsync([
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+          {
+            associatedEntityClass: TestEntity2,
+            fieldIdentifyingAssociatedEntity: 'testIndexedField',
+          },
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+        ]);
+      expect(loaded4Result?.enforceValue().getID()).toEqual(testEntity4.getID());
+    });
+
+    it('fails when chain loading associated entity fails', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+
+      const testEntity = await enforceAsyncResult(
+        TestEntity2.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('foreignKey', uuidv4())
+          .createAsync(),
+      );
+
+      const loadResult = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityThroughAsync([
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+          },
+        ]);
+      expect(loadResult?.ok).toBe(false);
+    });
+
+    it('supports chain loading by field equality', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+
+      const fieldValue = uuidv4();
+      const testEntity2 = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('stringField', fieldValue)
+          .createAsync(),
+      );
+      const testEntity = await enforceAsyncResult(
+        TestEntity2.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('foreignKey', fieldValue)
+          .createAsync(),
+      );
+
+      const loaded2Result = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityThroughAsync([
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+            associatedEntityLookupByField: 'stringField',
+          },
+        ]);
+      expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
+    });
+
+    it('returns null when chain loading by field equality returns null', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+
+      const testEntity = await enforceAsyncResult(
+        TestEntity2.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('foreignKey', uuidv4())
+          .createAsync(),
+      );
+
+      const loaded2Result = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityThroughAsync([
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'foreignKey',
+            associatedEntityLookupByField: 'stringField',
+          },
+        ]);
+      expect(loaded2Result).toBeNull();
+    });
+
+    it('returns null when chain loading by field is null', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new TestViewerContext(companionProvider);
+
+      const testEntity = await enforceAsyncResult(
+        TestEntity.creator(viewerContext)
+          .withAuthorizationResults()
+          .setField('nullableField', null)
+          .createAsync(),
+      );
+
+      const loadedResult = await testEntity
+        .associationLoader()
+        .withAuthorizationResults()
+        .loadAssociatedEntityThroughAsync([
+          {
+            associatedEntityClass: TestEntity,
+            fieldIdentifyingAssociatedEntity: 'nullableField',
+          },
+        ]);
+      expect(loadedResult).toBeNull();
+    });
+  });
+});

package/src/__tests__/{EntityLoader-constructor-test.ts → AuthorizationResultBasedEntityLoader-constructor-test.ts}

@@ -1,10 +1,11 @@
 import { instance, mock } from 'ts-mockito';
 
+import AuthorizationResultBasedEntityLoader from '../AuthorizationResultBasedEntityLoader';
 import Entity from '../Entity';
 import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { StringField } from '../EntityFields';
-import EntityLoader from '../EntityLoader';
+import EntityLoaderUtils from '../EntityLoaderUtils';
 import EntityPrivacyPolicy, { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import ViewerContext from '../ViewerContext';
 import EntityDataManager from '../internal/EntityDataManager';
@@ -94,7 +95,7 @@ export default class TestEntity extends Entity<
     selectedFields: Readonly<TestFields>;
   }) {
     if (constructorParams.selectedFields.id === ID_SENTINEL_THROW_LITERAL) {
-      // eslint-disable-next-line no-throw-literal,@typescript-eslint/no-throw-literal
+      // eslint-disable-next-line no-throw-literal,@typescript-eslint/only-throw-error
       throw 'hello';
     } else if (constructorParams.selectedFields.id === ID_SENTINEL_THROW_ERROR) {
       throw new Error('world');
@@ -118,7 +119,7 @@ export default class TestEntity extends Entity<
   }
 }
 
-describe(EntityLoader, () => {
+describe(AuthorizationResultBasedEntityLoader, () => {
   it('handles thrown errors and literals from constructor', async () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
@@ -134,7 +135,7 @@ describe(EntityLoader, () => {
         >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getQueryContext();
+    const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(
       testEntityConfiguration,
@@ -162,11 +163,11 @@ describe(EntityLoader, () => {
     const dataManager = new EntityDataManager(
       databaseAdapter,
       entityCache,
-      StubQueryContextProvider,
+      new StubQueryContextProvider(),
       metricsAdapter,
       TestEntity.name,
     );
-    const entityLoader = new EntityLoader(
+    const utils = new EntityLoaderUtils(
       viewerContext,
       queryContext,
       privacyPolicyEvaluationContext,
@@ -177,19 +178,25 @@ describe(EntityLoader, () => {
       dataManager,
       metricsAdapter,
     );
+    const entityLoader = new AuthorizationResultBasedEntityLoader(
+      queryContext,
+      testEntityConfiguration,
+      TestEntity,
+      dataManager,
+      metricsAdapter,
+      utils,
+    );
 
     let capturedThrownThing1: any;
     try {
-      await entityLoader.withAuthorizationResults().loadByIDAsync(ID_SENTINEL_THROW_LITERAL);
+      await entityLoader.loadByIDAsync(ID_SENTINEL_THROW_LITERAL);
     } catch (e) {
       capturedThrownThing1 = e;
     }
     expect(capturedThrownThing1).not.toBeInstanceOf(Error);
     expect(capturedThrownThing1).toEqual('hello');
 
-    const result = await entityLoader
-      .withAuthorizationResults()
-      .loadByIDAsync(ID_SENTINEL_THROW_ERROR);
+    const result = await entityLoader.loadByIDAsync(ID_SENTINEL_THROW_ERROR);
     expect(result.ok).toBe(false);
     expect(result.enforceError().message).toEqual('world');
   });