@expo/entity 0.34.0 → 0.36.0

package/src/__tests__/EntityCommonUseCases-test.ts

@@ -7,16 +7,19 @@ 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 {
-  constructor(entityCompanionProvider: EntityCompanionProvider, private readonly userID: string) {
+class TestUserViewerContext extends ViewerContext {
+  constructor(
+    entityCompanionProvider: EntityCompanionProvider,
+    private readonly userID: string,
+  ) {
     super(entityCompanionProvider);
   }
 
@@ -69,8 +72,13 @@ class DenyIfNotOwnerPrivacyPolicyRule extends PrivacyPolicyRule<
   async evaluateAsync(
     viewerContext: TestUserViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    entity: BlahEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      BlahFields,
+      string,
+      TestUserViewerContext,
+      BlahEntity
+    >,
+    entity: BlahEntity,
   ): Promise<RuleEvaluationResult> {
     if (viewerContext.getUserID() === entity.getField('ownerID')) {
       return RuleEvaluationResult.SKIP;
@@ -82,23 +90,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 +118,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
@@ -134,44 +136,40 @@ 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())
-    )
+      BlahEntity.loader(vc1).withAuthorizationResults().loadByIDAsync(blahOwner2.getID()),
+    ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
   await expect(
     enforceAsyncResult(
-      BlahEntity.loader(vc2, vc2.getQueryContext()).loadByIDAsync(blahOwner1.getID())
-    )
+      BlahEntity.loader(vc2).withAuthorizationResults().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)
+      .withAuthorizationResults()
+      .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)
+    .withAuthorizationResults()
+    .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,
+  );
 });

package/src/__tests__/EntityCompanion-test.ts

@@ -3,25 +3,77 @@ import { instance, mock, when } from 'ts-mockito';
 import EntityCompanion from '../EntityCompanion';
 import EntityCompanionProvider from '../EntityCompanionProvider';
 import EntityLoaderFactory from '../EntityLoaderFactory';
+import EntityMutationTriggerConfiguration from '../EntityMutationTriggerConfiguration';
 import EntityMutatorFactory from '../EntityMutatorFactory';
+import ViewerContext from '../ViewerContext';
 import EntityTableDataCoordinator from '../internal/EntityTableDataCoordinator';
 import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
-import TestEntity, { testEntityConfiguration, TestFields } from '../testfixtures/TestEntity';
+import NoOpEntityMetricsAdapter from '../metrics/NoOpEntityMetricsAdapter';
+import TestEntityWithMutationTriggers, {
+  TestMTFields,
+  testEntityMTConfiguration,
+  TestMutationTrigger,
+} from '../testfixtures/TestEntityWithMutationTriggers';
 
 describe(EntityCompanion, () => {
   it('correctly instantiates mutator and loader factories', () => {
     const entityCompanionProvider = instance(mock<EntityCompanionProvider>());
 
-    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestFields>>();
-    when(tableDataCoordinatorMock.entityConfiguration).thenReturn(testEntityConfiguration);
+    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestMTFields>>();
+    when(tableDataCoordinatorMock.entityConfiguration).thenReturn(testEntityMTConfiguration);
 
     const companion = new EntityCompanion(
       entityCompanionProvider,
-      TestEntity.defineCompanionDefinition(),
+      TestEntityWithMutationTriggers.defineCompanionDefinition(),
       instance(tableDataCoordinatorMock),
-      instance(mock<IEntityMetricsAdapter>())
+      instance(mock<IEntityMetricsAdapter>()),
     );
     expect(companion.getLoaderFactory()).toBeInstanceOf(EntityLoaderFactory);
     expect(companion.getMutatorFactory()).toBeInstanceOf(EntityMutatorFactory);
   });
+
+  it('correctly merges local and global mutation triggers', () => {
+    const globalMutationTriggers: EntityMutationTriggerConfiguration<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers,
+      keyof TestMTFields
+    > = {
+      afterCreate: [new TestMutationTrigger('globalAfterCreate')],
+      afterAll: [new TestMutationTrigger('globalAfterAll')],
+    };
+
+    const metricsAdapter = new NoOpEntityMetricsAdapter();
+
+    const entityCompanionProvider = new EntityCompanionProvider(
+      metricsAdapter,
+      new Map(),
+      new Map(),
+      globalMutationTriggers,
+    );
+
+    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestMTFields>>();
+    when(tableDataCoordinatorMock.entityConfiguration).thenReturn(testEntityMTConfiguration);
+
+    const companion = new EntityCompanion(
+      entityCompanionProvider,
+      TestEntityWithMutationTriggers.defineCompanionDefinition(),
+      instance(tableDataCoordinatorMock),
+      instance(mock<IEntityMetricsAdapter>()),
+    );
+    expect(companion.getLoaderFactory()).toBeInstanceOf(EntityLoaderFactory);
+    expect(companion.getMutatorFactory()).toBeInstanceOf(EntityMutatorFactory);
+
+    const mergedTriggers = companion.getMutatorFactory()['mutationTriggers'];
+
+    const localTriggers = companion.entityCompanionDefinition.mutationTriggers;
+    expect(localTriggers).toBeTruthy();
+
+    expect(mergedTriggers).toStrictEqual({
+      afterCreate: [localTriggers!.afterCreate![0], globalMutationTriggers.afterCreate![0]],
+      afterAll: [localTriggers!.afterAll![0], globalMutationTriggers!.afterAll![0]],
+      afterCommit: [localTriggers!.afterCommit![0]],
+    });
+  });
 });

package/src/__tests__/EntityConfiguration-test.ts

@@ -0,0 +1,118 @@
+import EntityConfiguration from '../EntityConfiguration';
+import { UUIDField, StringField } from '../EntityFields';
+
+describe(EntityConfiguration, () => {
+  describe('when valid', () => {
+    type BlahT = {
+      id: string;
+      cacheable: string;
+      uniqueButNotCacheable: string;
+    };
+
+    type Blah2T = {
+      id: string;
+    };
+
+    const blahEntityConfiguration = new EntityConfiguration<BlahT>({
+      idField: 'id',
+      tableName: 'blah_table',
+      schema: {
+        id: new UUIDField({
+          columnName: 'id',
+        }),
+        cacheable: new StringField({
+          columnName: 'cacheable',
+          cache: true,
+        }),
+        uniqueButNotCacheable: new StringField({
+          columnName: 'unique_but_not_cacheable',
+        }),
+      },
+      databaseAdapterFlavor: 'postgres',
+      cacheAdapterFlavor: 'redis',
+    });
+
+    it('returns correct fields', () => {
+      expect(blahEntityConfiguration.idField).toEqual('id');
+      expect(blahEntityConfiguration.tableName).toEqual('blah_table');
+      expect(blahEntityConfiguration.databaseAdapterFlavor).toEqual('postgres');
+      expect(blahEntityConfiguration.cacheAdapterFlavor).toEqual('redis');
+    });
+
+    it('filters cacheable fields', () => {
+      expect(blahEntityConfiguration.cacheableKeys).toEqual(new Set(['cacheable']));
+    });
+
+    describe('cache key version', () => {
+      it('defaults to 0', () => {
+        const entityConfiguration = new EntityConfiguration<Blah2T>({
+          idField: 'id',
+          tableName: 'blah',
+          schema: {
+            id: new UUIDField({
+              columnName: 'id',
+            }),
+          },
+          databaseAdapterFlavor: 'postgres',
+          cacheAdapterFlavor: 'redis',
+        });
+        expect(entityConfiguration.cacheKeyVersion).toEqual(0);
+      });
+
+      it('sets to custom version', () => {
+        const entityConfiguration = new EntityConfiguration<Blah2T>({
+          idField: 'id',
+          tableName: 'blah',
+          schema: {
+            id: new UUIDField({
+              columnName: 'id',
+            }),
+          },
+          databaseAdapterFlavor: 'postgres',
+          cacheAdapterFlavor: 'redis',
+          cacheKeyVersion: 100,
+        });
+        expect(entityConfiguration.cacheKeyVersion).toEqual(100);
+      });
+    });
+  });
+
+  describe('validation', () => {
+    describe('disallows keys of JS Object prototype for safety', () => {
+      test.each([
+        'constructor',
+        '__defineGetter__',
+        '__defineSetter__',
+        'hasOwnProperty',
+        '__lookupGetter__',
+        '__lookupSetter__',
+        'isPrototypeOf',
+        'propertyIsEnumerable',
+        'toString',
+        'valueOf',
+        '__proto__',
+        'toLocaleString',
+      ])('disallows %p as field key', (keyName) => {
+        expect(
+          () =>
+            new EntityConfiguration<any>({
+              idField: 'id',
+              tableName: 'blah_table',
+              schema: {
+                id: new UUIDField({
+                  columnName: 'id',
+                }),
+                [keyName]: new StringField({
+                  columnName: 'any',
+                }),
+              },
+              databaseAdapterFlavor: 'postgres',
+              cacheAdapterFlavor: 'redis',
+            }),
+        ).toThrow(
+          `Entity field name not allowed to prevent conflicts with standard Object prototype fields: ${keyName}`,
+        );
+      });
+    });
+  });
+});

package/src/__tests__/EntityDatabaseAdapter-test.ts

@@ -48,7 +48,7 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
     _queryInterface: any,
     _tableName: string,
     _tableField: string,
-    _tableValues: readonly any[]
+    _tableValues: readonly any[],
   ): Promise<object[]> {
     return this.fetchResults;
   }
@@ -57,7 +57,7 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
     _queryInterface: any,
     _tableName: string,
     _rawWhereClause: string,
-    _bindings: object | any[]
+    _bindings: object | any[],
   ): Promise<object[]> {
     return this.fetchRawWhereResults;
   }
@@ -66,7 +66,7 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
     _queryInterface: any,
     _tableName: string,
     _tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
-    _tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[]
+    _tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
   ): Promise<object[]> {
     return this.fetchEqualityConditionResults;
   }
@@ -74,7 +74,7 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
   protected async insertInternalAsync(
     _queryInterface: any,
     _tableName: string,
-    _object: object
+    _object: object,
   ): Promise<object[]> {
     return this.insertResults;
   }
@@ -84,7 +84,7 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
     _tableName: string,
     _tableIdField: string,
     _id: any,
-    _object: object
+    _object: object,
   ): Promise<object[]> {
     return this.updateResults;
   }
@@ -93,7 +93,7 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
     _queryInterface: any,
     _tableName: string,
     _tableIdField: string,
-    _id: any
+    _id: any,
   ): Promise<number> {
     return this.deleteCount;
   }
@@ -166,7 +166,7 @@ describe(EntityDatabaseAdapter, () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ insertResults: [] });
       await expect(adapter.insertAsync(queryContext, {} as any)).rejects.toThrowError(
-        'Empty results from database adapter insert'
+        'Empty results from database adapter insert',
       );
     });
 
@@ -176,7 +176,7 @@ describe(EntityDatabaseAdapter, () => {
         insertResults: [{ string_field: 'hello' }, { string_field: 'hello2' }],
       });
       await expect(adapter.insertAsync(queryContext, {} as any)).rejects.toThrowError(
-        'Excessive results from database adapter insert'
+        'Excessive results from database adapter insert',
       );
     });
   });
@@ -193,7 +193,7 @@ describe(EntityDatabaseAdapter, () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ updateResults: [] });
       await expect(
-        adapter.updateAsync(queryContext, 'customIdField', 'wat', {} as any)
+        adapter.updateAsync(queryContext, 'customIdField', 'wat', {} as any),
       ).rejects.toThrowError('Empty results from database adapter update');
     });
 
@@ -203,7 +203,7 @@ describe(EntityDatabaseAdapter, () => {
         updateResults: [{ string_field: 'hello' }, { string_field: 'hello2' }],
       });
       await expect(
-        adapter.updateAsync(queryContext, 'customIdField', 'wat', {} as any)
+        adapter.updateAsync(queryContext, 'customIdField', 'wat', {} as any),
       ).rejects.toThrowError('Excessive results from database adapter update');
     });
   });
@@ -213,7 +213,7 @@ describe(EntityDatabaseAdapter, () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ deleteCount: 2 });
       await expect(adapter.deleteAsync(queryContext, 'customIdField', 'wat')).rejects.toThrowError(
-        'Excessive deletions from database adapter delet'
+        'Excessive deletions from database adapter delet',
       );
     });
   });