@expo/entity 0.31.0 → 0.32.0

package/src/__tests__/EntityCompanionProvider-test.ts

@@ -23,26 +23,34 @@ const blahConfiguration = new EntityConfiguration<BlahFields>({
 });
 
 class Blah1Entity extends Entity<BlahFields, string, ViewerContext> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     BlahFields,
     string,
     ViewerContext,
     Blah1Entity,
     NoOpTest1PrivacyPolicy
   > {
-    return blah1CompanionDefinition;
+    return {
+      entityClass: Blah1Entity,
+      entityConfiguration: blahConfiguration,
+      privacyPolicyClass: NoOpTest1PrivacyPolicy,
+    };
   }
 }
 
 class Blah2Entity extends Entity<BlahFields, string, ViewerContext> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     BlahFields,
     string,
     ViewerContext,
     Blah2Entity,
     NoOpTest2PrivacyPolicy
   > {
-    return blah2CompanionDefinition;
+    return {
+      entityClass: Blah2Entity,
+      entityConfiguration: blahConfiguration,
+      privacyPolicyClass: NoOpTest2PrivacyPolicy,
+    };
   }
 }
 
@@ -59,31 +67,11 @@ class NoOpTest2PrivacyPolicy extends EntityPrivacyPolicy<
   Blah2Entity
 > {}
 
-const blah1CompanionDefinition = new EntityCompanionDefinition({
-  entityClass: Blah1Entity,
-  entityConfiguration: blahConfiguration,
-  privacyPolicyClass: NoOpTest1PrivacyPolicy,
-});
-
-const blah2CompanionDefinition = new EntityCompanionDefinition({
-  entityClass: Blah2Entity,
-  entityConfiguration: blahConfiguration,
-  privacyPolicyClass: NoOpTest2PrivacyPolicy,
-});
-
 describe(EntityCompanionProvider, () => {
   it('returns different instances for different entity types, but share table data coordinators', () => {
     const entityCompanionProvider = createUnitTestEntityCompanionProvider();
-    const companion1 = entityCompanionProvider.getCompanionForEntity(
-      Blah1Entity,
-      blah1CompanionDefinition
-    );
-
-    const companion2 = entityCompanionProvider.getCompanionForEntity(
-      Blah2Entity,
-      blah2CompanionDefinition
-    );
-
+    const companion1 = entityCompanionProvider.getCompanionForEntity(Blah1Entity);
+    const companion2 = entityCompanionProvider.getCompanionForEntity(Blah2Entity);
     expect(companion1).not.toEqual(companion2);
     expect(companion1['tableDataCoordinator']).toEqual(companion2['tableDataCoordinator']);
   });

package/src/__tests__/EntityEdges-test.ts

@@ -322,45 +322,78 @@ const makeEntityClasses = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) =>
   }
 
   class ParentEntity extends Entity<ParentFields, string, TestViewerContext> {
-    static getCompanionDefinition(): EntityCompanionDefinition<
+    static defineCompanionDefinition(): EntityCompanionDefinition<
       ParentFields,
       string,
       TestViewerContext,
       ParentEntity,
       TestEntityPrivacyPolicy
     > {
-      return parentEntityCompanion;
+      return {
+        entityClass: ParentEntity,
+        entityConfiguration: parentEntityConfiguration,
+        privacyPolicyClass: TestEntityPrivacyPolicy,
+        mutationTriggers: {
+          beforeDelete: [new ParentCheckInfoDeletionTrigger()],
+          afterDelete: [new ParentCheckInfoDeletionTrigger()],
+
+          beforeUpdate: [new ParentCheckInfoUpdateTrigger()],
+          afterUpdate: [new ParentCheckInfoUpdateTrigger()],
+        },
+      };
     }
   }
 
   class ChildEntity extends Entity<ChildFields, string, TestViewerContext> {
-    static getCompanionDefinition(): EntityCompanionDefinition<
+    static defineCompanionDefinition(): EntityCompanionDefinition<
       ChildFields,
       string,
       TestViewerContext,
       ChildEntity,
       TestEntityPrivacyPolicy
     > {
-      return childEntityCompanion;
+      return {
+        entityClass: ChildEntity,
+        entityConfiguration: childEntityConfiguration,
+        privacyPolicyClass: TestEntityPrivacyPolicy,
+        mutationTriggers: {
+          beforeDelete: [new ChildCheckInfoDeletionTrigger()],
+          afterDelete: [new ChildCheckInfoDeletionTrigger()],
+
+          beforeUpdate: [new ChildCheckInfoUpdateTrigger()],
+          afterUpdate: [new ChildCheckInfoUpdateTrigger()],
+        },
+      };
     }
   }
 
   class GrandChildEntity extends Entity<GrandChildFields, string, TestViewerContext> {
-    static getCompanionDefinition(): EntityCompanionDefinition<
+    static defineCompanionDefinition(): EntityCompanionDefinition<
       GrandChildFields,
       string,
       TestViewerContext,
       GrandChildEntity,
       TestEntityPrivacyPolicy
     > {
-      return grandChildEntityCompanion;
+      return {
+        entityClass: GrandChildEntity,
+        entityConfiguration: grandChildEntityConfiguration,
+        privacyPolicyClass: TestEntityPrivacyPolicy,
+        mutationTriggers: {
+          beforeDelete: [new GrandChildCheckInfoDeletionTrigger()],
+          afterDelete: [new GrandChildCheckInfoDeletionTrigger()],
+
+          beforeUpdate: [new GrandChildCheckInfoUpdateTrigger()],
+          afterUpdate: [new GrandChildCheckInfoUpdateTrigger()],
+        },
+      };
     }
   }
 
   const parentEntityConfiguration = new EntityConfiguration<ParentFields>({
     idField: 'id',
     tableName: 'parents',
-    getInboundEdges: () => [ChildEntity],
+    inboundEdges: [ChildEntity],
     schema: {
       id: new UUIDField({
         columnName: 'id',
@@ -374,7 +407,7 @@ const makeEntityClasses = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) =>
   const childEntityConfiguration = new EntityConfiguration<ChildFields>({
     idField: 'id',
     tableName: 'children',
-    getInboundEdges: () => [GrandChildEntity],
+    inboundEdges: [GrandChildEntity],
     schema: {
       id: new UUIDField({
         columnName: 'id',
@@ -384,7 +417,7 @@ const makeEntityClasses = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) =>
         columnName: 'parent_id',
         cache: true,
         association: {
-          getAssociatedEntityClass: () => ParentEntity,
+          associatedEntityClass: ParentEntity,
           edgeDeletionBehavior,
         },
       }),
@@ -405,7 +438,7 @@ const makeEntityClasses = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) =>
         columnName: 'parent_id',
         cache: true,
         association: {
-          getAssociatedEntityClass: () => ChildEntity,
+          associatedEntityClass: ChildEntity,
           edgeDeletionBehavior,
         },
       }),
@@ -414,45 +447,6 @@ const makeEntityClasses = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) =>
     cacheAdapterFlavor: 'redis',
   });
 
-  const parentEntityCompanion = new EntityCompanionDefinition({
-    entityClass: ParentEntity,
-    entityConfiguration: parentEntityConfiguration,
-    privacyPolicyClass: TestEntityPrivacyPolicy,
-    mutationTriggers: () => ({
-      beforeDelete: [new ParentCheckInfoDeletionTrigger()],
-      afterDelete: [new ParentCheckInfoDeletionTrigger()],
-
-      beforeUpdate: [new ParentCheckInfoUpdateTrigger()],
-      afterUpdate: [new ParentCheckInfoUpdateTrigger()],
-    }),
-  });
-
-  const childEntityCompanion = new EntityCompanionDefinition({
-    entityClass: ChildEntity,
-    entityConfiguration: childEntityConfiguration,
-    privacyPolicyClass: TestEntityPrivacyPolicy,
-    mutationTriggers: () => ({
-      beforeDelete: [new ChildCheckInfoDeletionTrigger()],
-      afterDelete: [new ChildCheckInfoDeletionTrigger()],
-
-      beforeUpdate: [new ChildCheckInfoUpdateTrigger()],
-      afterUpdate: [new ChildCheckInfoUpdateTrigger()],
-    }),
-  });
-
-  const grandChildEntityCompanion = new EntityCompanionDefinition({
-    entityClass: GrandChildEntity,
-    entityConfiguration: grandChildEntityConfiguration,
-    privacyPolicyClass: TestEntityPrivacyPolicy,
-    mutationTriggers: () => ({
-      beforeDelete: [new GrandChildCheckInfoDeletionTrigger()],
-      afterDelete: [new GrandChildCheckInfoDeletionTrigger()],
-
-      beforeUpdate: [new GrandChildCheckInfoUpdateTrigger()],
-      afterUpdate: [new GrandChildCheckInfoUpdateTrigger()],
-    }),
-  });
-
   return {
     ParentEntity,
     ChildEntity,

package/src/__tests__/EntityLoader-constructor-test.ts

@@ -87,17 +87,22 @@ export default class TestEntity extends Entity<
   ViewerContext,
   TestFieldSelection
 > {
-  constructor(viewerContext: ViewerContext, rawFields: Readonly<TestFields>) {
-    if (rawFields.id === ID_SENTINEL_THROW_LITERAL) {
+  constructor(constructorParams: {
+    viewerContext: ViewerContext;
+    id: string;
+    databaseFields: Readonly<TestFields>;
+    selectedFields: Readonly<TestFields>;
+  }) {
+    if (constructorParams.selectedFields.id === ID_SENTINEL_THROW_LITERAL) {
       // eslint-disable-next-line no-throw-literal,@typescript-eslint/no-throw-literal
       throw 'hello';
-    } else if (rawFields.id === ID_SENTINEL_THROW_ERROR) {
+    } else if (constructorParams.selectedFields.id === ID_SENTINEL_THROW_ERROR) {
       throw new Error('world');
     }
-    super(viewerContext, rawFields);
+    super(constructorParams);
   }
 
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -105,16 +110,14 @@ export default class TestEntity extends Entity<
     TestEntityPrivacyPolicy,
     TestFieldSelection
   > {
-    return testEntityCompanion;
+    return {
+      entityClass: TestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+    };
   }
 }
 
-export const testEntityCompanion = new EntityCompanionDefinition({
-  entityClass: TestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-});
-
 describe(EntityLoader, () => {
   it('handles thrown errors and literals from constructor', async () => {
     const viewerContext = instance(mock(ViewerContext));
@@ -158,6 +161,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManager,
       metricsAdapter

package/src/__tests__/EntityLoader-test.ts

@@ -2,6 +2,7 @@ import { enforceAsyncResult } from '@expo/results';
 import { mock, instance, verify, spy, deepEqual, anyOfClass, anything, when } from 'ts-mockito';
 import { v4 as uuidv4 } from 'uuid';
 
+import { OrderByOrdering } from '../EntityDatabaseAdapter';
 import EntityLoader from '../EntityLoader';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import ViewerContext from '../ViewerContext';
@@ -74,6 +75,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManager,
       metricsAdapter
@@ -176,6 +178,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManager,
       metricsAdapter
@@ -210,6 +213,102 @@ describe(EntityLoader, () => {
     ).rejects.toThrowError('Entity field not valid: TestEntity (customIdField = not-a-uuid)');
   });
 
+  it('loads entities with loadFirstByFieldEqualityConjunction', async () => {
+    const privacyPolicy = new TestEntityPrivacyPolicy();
+    const spiedPrivacyPolicy = spy(privacyPolicy);
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
+    const queryContext = StubQueryContextProvider.getQueryContext();
+
+    const id1 = uuidv4();
+    const id2 = uuidv4();
+    const id3 = uuidv4();
+    const databaseAdapter = new StubDatabaseAdapter<TestFields>(
+      testEntityConfiguration,
+      StubDatabaseAdapter.convertFieldObjectsToDataStore(
+        testEntityConfiguration,
+        new Map([
+          [
+            testEntityConfiguration.tableName,
+            [
+              {
+                customIdField: id1,
+                stringField: 'huh',
+                intField: 4,
+                testIndexedField: '4',
+                dateField: new Date(),
+                nullableField: null,
+              },
+              {
+                customIdField: id2,
+                stringField: 'huh',
+                intField: 4,
+                testIndexedField: '5',
+                dateField: new Date(),
+                nullableField: null,
+              },
+              {
+                customIdField: id3,
+                stringField: 'huh2',
+                intField: 4,
+                testIndexedField: '6',
+                dateField: new Date(),
+                nullableField: null,
+              },
+            ],
+          ],
+        ])
+      )
+    );
+    const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const dataManager = new EntityDataManager(
+      databaseAdapter,
+      entityCache,
+      StubQueryContextProvider,
+      instance(mock<IEntityMetricsAdapter>()),
+      TestEntity.name
+    );
+    const entityLoader = new EntityLoader(
+      viewerContext,
+      queryContext,
+      privacyPolicyEvaluationContext,
+      testEntityConfiguration,
+      TestEntity,
+      /* entitySelectedFields */ undefined,
+      privacyPolicy,
+      dataManager,
+      metricsAdapter
+    );
+    const result = await entityLoader.loadFirstByFieldEqualityConjunctionAsync(
+      [
+        {
+          fieldName: 'stringField',
+          fieldValue: 'huh',
+        },
+        {
+          fieldName: 'intField',
+          fieldValue: 4,
+        },
+      ],
+      { orderBy: [{ fieldName: 'testIndexedField', order: OrderByOrdering.DESCENDING }] }
+    );
+    expect(result).not.toBeNull();
+    expect(result!.ok).toBe(true);
+    expect(result!.enforceValue().getField('testIndexedField')).toEqual('5');
+    verify(
+      spiedPrivacyPolicy.authorizeReadAsync(
+        viewerContext,
+        queryContext,
+        privacyPolicyEvaluationContext,
+        anyOfClass(TestEntity),
+        anything()
+      )
+    ).once();
+  });
+
   it('authorizes loaded entities', async () => {
     const privacyPolicy = new TestEntityPrivacyPolicy();
     const spiedPrivacyPolicy = spy(privacyPolicy);
@@ -257,6 +356,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManager,
       metricsAdapter
@@ -289,6 +389,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
       metricsAdapter
@@ -316,6 +417,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
       metricsAdapter
@@ -346,6 +448,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
       metricsAdapter
@@ -390,6 +493,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
       metricsAdapter
@@ -423,6 +527,7 @@ describe(EntityLoader, () => {
       privacyPolicyEvaluationContext,
       testEntityConfiguration,
       TestEntity,
+      /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
       metricsAdapter

package/src/__tests__/EntityMutator-MutationCacheConsistency-test.ts

@@ -34,37 +34,35 @@ class BlahEntityPrivacyPolicy extends EntityPrivacyPolicy<
 }
 
 class BlahEntity extends Entity<BlahFields, string, ViewerContext> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     BlahFields,
     string,
     ViewerContext,
     BlahEntity,
     BlahEntityPrivacyPolicy
   > {
-    return blahCompanion;
+    return {
+      entityClass: BlahEntity,
+      entityConfiguration: new EntityConfiguration<BlahFields>({
+        idField: 'id',
+        tableName: 'blah_table',
+        schema: {
+          id: new UUIDField({
+            columnName: 'id',
+            cache: true,
+          }),
+        },
+        databaseAdapterFlavor: 'postgres',
+        cacheAdapterFlavor: 'redis',
+      }),
+      privacyPolicyClass: BlahEntityPrivacyPolicy,
+      mutationTriggers: {
+        afterCommit: [new TestNonTransactionalMutationTrigger()],
+      },
+    };
   }
 }
 
-const blahCompanion = new EntityCompanionDefinition({
-  entityClass: BlahEntity,
-  entityConfiguration: new EntityConfiguration<BlahFields>({
-    idField: 'id',
-    tableName: 'blah_table',
-    schema: {
-      id: new UUIDField({
-        columnName: 'id',
-        cache: true,
-      }),
-    },
-    databaseAdapterFlavor: 'postgres',
-    cacheAdapterFlavor: 'redis',
-  }),
-  privacyPolicyClass: BlahEntityPrivacyPolicy,
-  mutationTriggers: () => ({
-    afterCommit: [new TestNonTransactionalMutationTrigger()],
-  }),
-});
-
 class TestNonTransactionalMutationTrigger extends EntityNonTransactionalMutationTrigger<
   BlahFields,
   string,