@expo/entity 0.16.0 → 0.20.0

package/src/__tests__/EntityLoader-test.ts

@@ -21,6 +21,7 @@ describe(EntityLoader, () => {
   it('loads entities', async () => {
     const dateToInsert = new Date();
     const viewerContext = instance(mock(ViewerContext));
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = StubQueryContextProvider.getQueryContext();
 
     const id1 = uuidv4();
@@ -36,7 +37,7 @@ describe(EntityLoader, () => {
               {
                 customIdField: id1,
                 testIndexedField: 'h1',
-                numberField: 5,
+                intField: 5,
                 stringField: 'huh',
                 dateField: dateToInsert,
                 nullableField: null,
@@ -44,7 +45,7 @@ describe(EntityLoader, () => {
               {
                 customIdField: id2,
                 testIndexedField: 'h2',
-                numberField: 3,
+                intField: 3,
                 stringField: 'huh',
                 dateField: dateToInsert,
                 nullableField: null,
@@ -71,7 +72,8 @@ describe(EntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       privacyPolicy,
-      dataManager
+      dataManager,
+      metricsAdapter
     );
     const entity = await enforceAsyncResult(entityLoader.loadByIDAsync(id1));
     expect(entity.getID()).toEqual(id1);
@@ -82,11 +84,11 @@ describe(EntityLoader, () => {
     );
     expect(entities.map((m) => m.getID())).toEqual([id1, id2]);
 
-    const entityResultNumber3 = await entityLoader.loadByFieldEqualingAsync('numberField', 3);
+    const entityResultNumber3 = await entityLoader.loadByFieldEqualingAsync('intField', 3);
     expect(entityResultNumber3).not.toBeNull();
     expect(entityResultNumber3!.enforceValue().getID()).toEqual(id2);
 
-    const entityResultNumber4 = await entityLoader.loadByFieldEqualingAsync('numberField', 4);
+    const entityResultNumber4 = await entityLoader.loadByFieldEqualingAsync('intField', 4);
     expect(entityResultNumber4).toBeNull();
 
     const entityResultDuplicateValues = await entityLoader
@@ -111,6 +113,7 @@ describe(EntityLoader, () => {
     const privacyPolicy = new TestEntityPrivacyPolicy();
     const spiedPrivacyPolicy = spy(privacyPolicy);
     const viewerContext = instance(mock(ViewerContext));
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = StubQueryContextProvider.getQueryContext();
 
     const id1 = uuidv4();
@@ -127,7 +130,7 @@ describe(EntityLoader, () => {
               {
                 customIdField: id1,
                 stringField: 'huh',
-                numberField: 4,
+                intField: 4,
                 testIndexedField: '4',
                 dateField: new Date(),
                 nullableField: null,
@@ -135,7 +138,7 @@ describe(EntityLoader, () => {
               {
                 customIdField: id2,
                 stringField: 'huh',
-                numberField: 4,
+                intField: 4,
                 testIndexedField: '5',
                 dateField: new Date(),
                 nullableField: null,
@@ -143,7 +146,7 @@ describe(EntityLoader, () => {
               {
                 customIdField: id3,
                 stringField: 'huh2',
-                numberField: 4,
+                intField: 4,
                 testIndexedField: '6',
                 dateField: new Date(),
                 nullableField: null,
@@ -169,7 +172,8 @@ describe(EntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       privacyPolicy,
-      dataManager
+      dataManager,
+      metricsAdapter
     );
     const entities = await enforceResultsAsync(
       entityLoader.loadManyByFieldEqualityConjunctionAsync([
@@ -178,14 +182,19 @@ describe(EntityLoader, () => {
           fieldValue: 'huh',
         },
         {
-          fieldName: 'numberField',
+          fieldName: 'intField',
           fieldValue: 4,
         },
       ])
     );
     expect(entities).toHaveLength(2);
     verify(
-      spiedPrivacyPolicy.authorizeReadAsync(viewerContext, queryContext, anyOfClass(TestEntity))
+      spiedPrivacyPolicy.authorizeReadAsync(
+        viewerContext,
+        queryContext,
+        anyOfClass(TestEntity),
+        anything()
+      )
     ).twice();
 
     await expect(
@@ -200,6 +209,7 @@ describe(EntityLoader, () => {
     const spiedPrivacyPolicy = spy(privacyPolicy);
 
     const viewerContext = instance(mock(ViewerContext));
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = StubQueryContextProvider.getQueryContext();
 
     const id1 = uuidv4();
@@ -215,7 +225,7 @@ describe(EntityLoader, () => {
                 customIdField: id1,
                 stringField: 'huh',
                 testIndexedField: '1',
-                numberField: 3,
+                intField: 3,
                 dateField: new Date(),
                 nullableField: null,
               },
@@ -240,14 +250,18 @@ describe(EntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       privacyPolicy,
-      dataManager
+      dataManager,
+      metricsAdapter
     );
     const entity = await enforceAsyncResult(entityLoader.loadByIDAsync(id1));
-    verify(spiedPrivacyPolicy.authorizeReadAsync(viewerContext, queryContext, entity)).once();
+    verify(
+      spiedPrivacyPolicy.authorizeReadAsync(viewerContext, queryContext, entity, anything())
+    ).once();
   });
 
   it('invalidates upon invalidate one', async () => {
     const viewerContext = instance(mock(ViewerContext));
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
@@ -260,7 +274,8 @@ describe(EntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       privacyPolicy,
-      dataManagerInstance
+      dataManagerInstance,
+      metricsAdapter
     );
     await entityLoader.invalidateFieldsAsync({ customIdField: id1 } as any);
 
@@ -271,6 +286,7 @@ describe(EntityLoader, () => {
 
   it('invalidates upon invalidate by field', async () => {
     const viewerContext = instance(mock(ViewerContext));
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
@@ -283,7 +299,8 @@ describe(EntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       privacyPolicy,
-      dataManagerInstance
+      dataManagerInstance,
+      metricsAdapter
     );
     await entityLoader.invalidateFieldsAsync({ customIdField: id1 } as any);
     verify(
@@ -293,6 +310,7 @@ describe(EntityLoader, () => {
 
   it('invalidates upon invalidate by entity', async () => {
     const viewerContext = instance(mock(ViewerContext));
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
@@ -309,7 +327,8 @@ describe(EntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       privacyPolicy,
-      dataManagerInstance
+      dataManagerInstance,
+      metricsAdapter
     );
     await entityLoader.invalidateEntityAsync(entityInstance);
     verify(
@@ -319,6 +338,7 @@ describe(EntityLoader, () => {
 
   it('returns error result when not allowed', async () => {
     const viewerContext = instance(mock(ViewerContext));
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicyMock = mock(TestEntityPrivacyPolicy);
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
@@ -331,7 +351,12 @@ describe(EntityLoader, () => {
     const rejectionError = new Error();
 
     when(
-      privacyPolicyMock.authorizeReadAsync(viewerContext, queryContext, anyOfClass(TestEntity))
+      privacyPolicyMock.authorizeReadAsync(
+        viewerContext,
+        queryContext,
+        anyOfClass(TestEntity),
+        anything()
+      )
     ).thenReject(rejectionError);
 
     const privacyPolicy = instance(privacyPolicyMock);
@@ -343,7 +368,8 @@ describe(EntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       privacyPolicy,
-      dataManagerInstance
+      dataManagerInstance,
+      metricsAdapter
     );
 
     const entityResult = await entityLoader.loadByIDAsync(id1);
@@ -354,6 +380,7 @@ describe(EntityLoader, () => {
 
   it('throws upon database adapter error', async () => {
     const viewerContext = instance(mock(ViewerContext));
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
@@ -372,7 +399,8 @@ describe(EntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       privacyPolicy,
-      dataManagerInstance
+      dataManagerInstance,
+      metricsAdapter
     );
 
     const loadByValue = uuidv4();

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

@@ -0,0 +1,105 @@
+import Entity from '../Entity';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
+import EntityConfiguration from '../EntityConfiguration';
+import { UUIDField } from '../EntityFields';
+import { EntityMutationType, EntityTriggerMutationInfo } from '../EntityMutationInfo';
+import { EntityNonTransactionalMutationTrigger } from '../EntityMutationTriggerConfiguration';
+import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import ViewerContext from '../ViewerContext';
+import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
+import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+
+type BlahFields = {
+  id: string;
+};
+
+class BlahEntityPrivacyPolicy extends EntityPrivacyPolicy<
+  BlahFields,
+  string,
+  ViewerContext,
+  BlahEntity
+> {
+  protected override readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+  ];
+  protected override readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+  ];
+  protected override readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+  ];
+  protected override readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<BlahFields, string, ViewerContext, BlahEntity>(),
+  ];
+}
+
+class BlahEntity extends Entity<BlahFields, string, ViewerContext> {
+  static getCompanionDefinition(): EntityCompanionDefinition<
+    BlahFields,
+    string,
+    ViewerContext,
+    BlahEntity,
+    BlahEntityPrivacyPolicy
+  > {
+    return blahCompanion;
+  }
+}
+
+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,
+  ViewerContext,
+  BlahEntity
+> {
+  async executeAsync(
+    viewerContext: ViewerContext,
+    entity: BlahEntity,
+    mutationInfo: EntityTriggerMutationInfo<BlahFields, string, ViewerContext, BlahEntity>
+  ): Promise<void> {
+    if (mutationInfo.type === EntityMutationType.DELETE) {
+      const entityLoaded = await BlahEntity.loader(viewerContext)
+        .enforcing()
+        .loadByIDNullableAsync(entity.getID());
+      if (entityLoaded) {
+        throw new Error(
+          'should not have been able to re-load the entity after delete. this means the cache has not been cleared'
+        );
+      }
+    }
+  }
+}
+
+describe('EntityMutator', () => {
+  test('cache consistency with post-commit callbacks', async () => {
+    const companionProvider = createUnitTestEntityCompanionProvider();
+    const viewerContext = new ViewerContext(companionProvider);
+
+    // put it in cache
+    const entity = await BlahEntity.creator(viewerContext).enforceCreateAsync();
+    const entityLoaded = await BlahEntity.loader(viewerContext)
+      .enforcing()
+      .loadByIDAsync(entity.getID());
+
+    await BlahEntity.enforceDeleteAsync(entityLoaded);
+  });
+});