@expo/entity 0.35.0 → 0.36.0

package/src/__tests__/Entity-test.ts

@@ -1,12 +1,6 @@
 import Entity from '../Entity';
-import { EntityCompanionDefinition } from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
-import { UUIDField } from '../EntityFields';
 import { CreateMutator, UpdateMutator } from '../EntityMutator';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import ViewerContext from '../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
-import AlwaysDenyPrivacyPolicyRule from '../rules/AlwaysDenyPrivacyPolicyRule';
 import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
@@ -35,200 +29,4 @@ describe(Entity, () => {
       expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(UpdateMutator);
     });
   });
-
-  describe('canViewerUpdateAsync', () => {
-    it('appropriately executes update privacy policy', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new ViewerContext(companionProvider);
-      const data = {
-        id: 'what',
-      };
-      const testEntity = new SimpleTestDenyDeleteEntity({
-        viewerContext,
-        id: 'what',
-        databaseFields: data,
-        selectedFields: data,
-      });
-      const canViewerUpdate = await SimpleTestDenyDeleteEntity.canViewerUpdateAsync(testEntity);
-      expect(canViewerUpdate).toBe(true);
-    });
-
-    it('denies when policy denies', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new ViewerContext(companionProvider);
-      const data = {
-        id: 'what',
-      };
-      const testEntity = new SimpleTestDenyUpdateEntity({
-        viewerContext,
-        id: 'what',
-        databaseFields: data,
-        selectedFields: data,
-      });
-      const canViewerUpdate = await SimpleTestDenyUpdateEntity.canViewerUpdateAsync(testEntity);
-      expect(canViewerUpdate).toBe(false);
-    });
-  });
-
-  describe('canViewerDeleteAsync', () => {
-    it('appropriately executes update privacy policy', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new ViewerContext(companionProvider);
-      const data = {
-        id: 'what',
-      };
-      const testEntity = new SimpleTestDenyUpdateEntity({
-        viewerContext,
-        id: 'what',
-        databaseFields: data,
-        selectedFields: data,
-      });
-      const canViewerDelete = await SimpleTestDenyUpdateEntity.canViewerDeleteAsync(testEntity);
-      expect(canViewerDelete).toBe(true);
-    });
-
-    it('denies when policy denies', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new ViewerContext(companionProvider);
-      const data = {
-        id: 'what',
-      };
-      const testEntity = new SimpleTestDenyDeleteEntity({
-        viewerContext,
-        id: 'what',
-        databaseFields: data,
-        selectedFields: data,
-      });
-      const canViewerDelete = await SimpleTestDenyDeleteEntity.canViewerDeleteAsync(testEntity);
-      expect(canViewerDelete).toBe(false);
-    });
-  });
 });
-
-type TestEntityFields = {
-  id: string;
-};
-
-const testEntityConfiguration = new EntityConfiguration<TestEntityFields>({
-  idField: 'id',
-  tableName: 'blah',
-  schema: {
-    id: new UUIDField({
-      columnName: 'custom_id',
-    }),
-  },
-  databaseAdapterFlavor: 'postgres',
-  cacheAdapterFlavor: 'redis',
-});
-
-class SimpleTestDenyUpdateEntityPrivacyPolicy extends EntityPrivacyPolicy<
-  TestEntityFields,
-  string,
-  ViewerContext,
-  SimpleTestDenyUpdateEntity
-> {
-  protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyUpdateEntity
-    >(),
-  ];
-  protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyUpdateEntity
-    >(),
-  ];
-  protected override readonly updateRules = [
-    new AlwaysDenyPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyUpdateEntity
-    >(),
-  ];
-  protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyUpdateEntity
-    >(),
-  ];
-}
-
-class SimpleTestDenyDeleteEntityPrivacyPolicy extends EntityPrivacyPolicy<
-  TestEntityFields,
-  string,
-  ViewerContext,
-  SimpleTestDenyDeleteEntity
-> {
-  protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyDeleteEntity
-    >(),
-  ];
-  protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyDeleteEntity
-    >(),
-  ];
-  protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyDeleteEntity
-    >(),
-  ];
-  protected override readonly deleteRules = [
-    new AlwaysDenyPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      ViewerContext,
-      SimpleTestDenyDeleteEntity
-    >(),
-  ];
-}
-
-class SimpleTestDenyUpdateEntity extends Entity<TestEntityFields, string, ViewerContext> {
-  static defineCompanionDefinition(): EntityCompanionDefinition<
-    TestEntityFields,
-    string,
-    ViewerContext,
-    SimpleTestDenyUpdateEntity,
-    SimpleTestDenyUpdateEntityPrivacyPolicy
-  > {
-    return {
-      entityClass: SimpleTestDenyUpdateEntity,
-      entityConfiguration: testEntityConfiguration,
-      privacyPolicyClass: SimpleTestDenyUpdateEntityPrivacyPolicy,
-    };
-  }
-}
-
-class SimpleTestDenyDeleteEntity extends Entity<TestEntityFields, string, ViewerContext> {
-  static defineCompanionDefinition(): EntityCompanionDefinition<
-    TestEntityFields,
-    string,
-    ViewerContext,
-    SimpleTestDenyDeleteEntity,
-    SimpleTestDenyDeleteEntityPrivacyPolicy
-  > {
-    return {
-      entityClass: SimpleTestDenyDeleteEntity,
-      entityConfiguration: testEntityConfiguration,
-      privacyPolicyClass: SimpleTestDenyDeleteEntityPrivacyPolicy,
-    };
-  }
-}

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -14,20 +14,20 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).createAsync()
+        TestEntity.creator(viewerContext).createAsync(),
       );
       const testEntity = await enforceAsyncResult(
         TestEntity.creator(viewerContext)
           .setField('stringField', testOtherEntity.getID())
-          .createAsync()
+          .createAsync(),
       );
       const loadedOther = await enforceAsyncResult(
-        testEntity.associationLoader().loadAssociatedEntityAsync('stringField', TestEntity)
+        testEntity.associationLoader().loadAssociatedEntityAsync('stringField', TestEntity),
       );
       expect(loadedOther.getID()).toEqual(testOtherEntity.getID());
 
       const loadedOther2 = await enforceAsyncResult(
-        testEntity.associationLoader().loadAssociatedEntityAsync('nullableField', TestEntity)
+        testEntity.associationLoader().loadAssociatedEntityAsync('nullableField', TestEntity),
       );
       expect(loadedOther2).toBeNull();
     });
@@ -39,13 +39,13 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
       );
       const loaded = await enforceResultsAsync(
-        testEntity.associationLoader().loadManyAssociatedEntitiesAsync(TestEntity, 'stringField')
+        testEntity.associationLoader().loadManyAssociatedEntitiesAsync(TestEntity, 'stringField'),
       );
       expect(loaded).toHaveLength(2);
       expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
@@ -58,12 +58,12 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).createAsync()
+        TestEntity.creator(viewerContext).createAsync(),
       );
       const testEntity = await enforceAsyncResult(
         TestEntity.creator(viewerContext)
           .setField('stringField', testOtherEntity.getID())
-          .createAsync()
+          .createAsync(),
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
@@ -75,7 +75,7 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', uuidv4()).createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', uuidv4()).createAsync(),
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
@@ -87,7 +87,7 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', 'blah').createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', 'blah').createAsync(),
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
@@ -102,10 +102,10 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
       );
       const loaded = await enforceResultsAsync(
         testEntity
@@ -113,8 +113,8 @@ describe(EntityAssociationLoader, () => {
           .loadManyAssociatedEntitiesByFieldEqualingAsync(
             'customIdField',
             TestEntity,
-            'stringField'
-          )
+            'stringField',
+          ),
       );
       expect(loaded).toHaveLength(2);
       expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
@@ -131,8 +131,8 @@ describe(EntityAssociationLoader, () => {
           .loadManyAssociatedEntitiesByFieldEqualingAsync(
             'nullableField',
             TestEntity,
-            'stringField'
-          )
+            'stringField',
+          ),
       );
       expect(loaded).toHaveLength(0);
     });
@@ -144,15 +144,19 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity4 = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testEntity3 = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', testEntity4.getID()).createAsync()
+        TestEntity2.creator(viewerContext)
+          .setField('foreignKey', testEntity4.getID())
+          .createAsync(),
       );
       const testEntity2 = await enforceAsyncResult(
         TestEntity.creator(viewerContext)
           .setField('testIndexedField', testEntity3.getID())
-          .createAsync()
+          .createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', testEntity2.getID()).createAsync()
+        TestEntity2.creator(viewerContext)
+          .setField('foreignKey', testEntity2.getID())
+          .createAsync(),
       );
 
       const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
@@ -197,7 +201,7 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync(),
       );
 
       const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
@@ -215,10 +219,10 @@ describe(EntityAssociationLoader, () => {
 
       const fieldValue = uuidv4();
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', fieldValue).createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', fieldValue).createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', fieldValue).createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', fieldValue).createAsync(),
       );
 
       const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
@@ -236,7 +240,7 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync(),
       );
 
       const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
@@ -254,7 +258,7 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('nullableField', null).createAsync()
+        TestEntity.creator(viewerContext).setField('nullableField', null).createAsync(),
       );
 
       const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([

package/src/__tests__/EntityCommonUseCases-test.ts

@@ -16,7 +16,10 @@ import PrivacyPolicyRule, { RuleEvaluationResult } from '../rules/PrivacyPolicyR
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 class TestUserViewerContext extends ViewerContext {
-  constructor(entityCompanionProvider: EntityCompanionProvider, private readonly userID: string) {
+  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;
@@ -110,15 +118,15 @@ 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).setField('ownerID', vc1.getUserID()!).createAsync(),
   );
 
   await enforceAsyncResult(
-    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync()
+    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync(),
   );
 
   const blahOwner2 = await enforceAsyncResult(
-    BlahEntity.creator(vc2).setField('ownerID', vc2.getUserID()!).createAsync()
+    BlahEntity.creator(vc2).setField('ownerID', vc2.getUserID()!).createAsync(),
   );
 
   // sanity check created objects
@@ -127,33 +135,41 @@ 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).withAuthorizationResults().loadByIDAsync(blahOwner2.getID()),
+    ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
   await expect(
-    enforceAsyncResult(BlahEntity.loader(vc2).loadByIDAsync(blahOwner1.getID()))
+    enforceAsyncResult(
+      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).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).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).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))).rejects.toBeInstanceOf(
-    EntityNotAuthorizedError
+    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}`,
+        );
+      });
+    });
+  });
+});