@expo/entity 0.31.1 → 0.33.0

package/src/ViewerContext.ts

@@ -1,7 +1,11 @@
 import { IEntityClass } from './Entity';
 import EntityCompanionProvider, { DatabaseAdapterFlavor } from './EntityCompanionProvider';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
-import { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext';
+import {
+  EntityQueryContext,
+  EntityTransactionalQueryContext,
+  TransactionConfig,
+} from './EntityQueryContext';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerScopedEntityCompanion from './ViewerScopedEntityCompanion';
 import ViewerScopedEntityCompanionProvider from './ViewerScopedEntityCompanionProvider';
@@ -27,7 +31,7 @@ export default class ViewerContext {
   }
 
   getViewerScopedEntityCompanionForClass<
-    TMFields,
+    TMFields extends object,
     TMID extends NonNullable<TMFields[TMSelectedFields]>,
     TMViewerContext extends ViewerContext,
     TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
@@ -56,10 +60,7 @@ export default class ViewerContext {
     TMPrivacyPolicy,
     TMSelectedFields
   > {
-    return this.viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(
-      entityClass,
-      entityClass.getCompanionDefinition()
-    );
+    return this.viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(entityClass);
   }
 
   /**
@@ -82,11 +83,12 @@ export default class ViewerContext {
    */
   async runInTransactionForDatabaseAdaptorFlavorAsync<TResult>(
     databaseAdaptorFlavor: DatabaseAdapterFlavor,
-    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<TResult>
+    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<TResult>,
+    transactionConfig?: TransactionConfig
   ): Promise<TResult> {
     return await this.entityCompanionProvider
       .getQueryContextProviderForDatabaseAdaptorFlavor(databaseAdaptorFlavor)
       .getQueryContext()
-      .runInTransactionIfNotInTransactionAsync(transactionScope);
+      .runInTransactionIfNotInTransactionAsync(transactionScope, transactionConfig);
   }
 }

package/src/ViewerScopedEntityCompanion.ts

@@ -12,7 +12,7 @@ import IEntityMetricsAdapter from './metrics/IEntityMetricsAdapter';
  * from the viewer-scoped entity companion provider.
  */
 export default class ViewerScopedEntityCompanion<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
@@ -26,7 +26,7 @@ export default class ViewerScopedEntityCompanion<
   TSelectedFields extends keyof TFields
 > {
   constructor(
-    private readonly entityCompanion: EntityCompanion<
+    public readonly entityCompanion: EntityCompanion<
       TFields,
       TID,
       TViewerContext,

package/src/ViewerScopedEntityCompanionProvider.ts

@@ -1,5 +1,5 @@
 import { IEntityClass } from './Entity';
-import EntityCompanionProvider, { EntityCompanionDefinition } from './EntityCompanionProvider';
+import EntityCompanionProvider from './EntityCompanionProvider';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerContext from './ViewerContext';
@@ -19,10 +19,10 @@ export default class ViewerScopedEntityCompanionProvider {
    * companion is constructed using the configuration provided by the factory.
    *
    * @param entityClass - entity class to load
-   * @param factory - entity companion factory
+   * @param entityCompanionDefinitionFn - function defining entity companion definition
    */
   getViewerScopedCompanionForEntity<
-    TFields,
+    TFields extends object,
     TID extends NonNullable<TFields[TSelectedFields]>,
     TViewerContext extends ViewerContext,
     TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
@@ -42,14 +42,6 @@ export default class ViewerScopedEntityCompanionProvider {
       TEntity,
       TPrivacyPolicy,
       TSelectedFields
-    >,
-    entityCompanionDefinition: EntityCompanionDefinition<
-      TFields,
-      TID,
-      TViewerContext,
-      TEntity,
-      TPrivacyPolicy,
-      TSelectedFields
     >
   ): ViewerScopedEntityCompanion<
     TFields,
@@ -60,7 +52,7 @@ export default class ViewerScopedEntityCompanionProvider {
     TSelectedFields
   > {
     return new ViewerScopedEntityCompanion(
-      this.entityCompanionProvider.getCompanionForEntity(entityClass, entityCompanionDefinition),
+      this.entityCompanionProvider.getCompanionForEntity(entityClass),
       this.viewerContext as TViewerContext
     );
   }

package/src/ViewerScopedEntityLoaderFactory.ts

@@ -9,7 +9,7 @@ import ViewerContext from './ViewerContext';
  * Provides a cleaner API for loading entities by passing through the ViewerContext.
  */
 export default class ViewerScopedEntityLoaderFactory<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/ViewerScopedEntityMutatorFactory.ts

@@ -9,7 +9,7 @@ import ViewerContext from './ViewerContext';
  * Provides a cleaner API for mutating entities by passing through the ViewerContext.
  */
 export default class ViewerScopedEntityMutatorFactory<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/__tests__/ComposedCacheAdapter-test.ts

@@ -1,9 +1,9 @@
 import invariant from 'invariant';
 
 import ComposedEntityCacheAdapter from '../ComposedEntityCacheAdapter';
-import EntityCacheAdapter from '../EntityCacheAdapter';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
+import IEntityCacheAdapter from '../IEntityCacheAdapter';
 import { CacheLoadResult, CacheStatus } from '../internal/ReadThroughEntityCache';
 
 type BlahFields = {
@@ -23,13 +23,11 @@ const entityConfiguration = new EntityConfiguration<BlahFields>({
 export const DOES_NOT_EXIST_LOCAL_MEMORY_CACHE = Symbol('doesNotExist');
 type LocalMemoryCacheValue<TFields> = Readonly<TFields> | typeof DOES_NOT_EXIST_LOCAL_MEMORY_CACHE;
 
-class TestLocalCacheAdapter<TFields> extends EntityCacheAdapter<TFields> {
+class TestLocalCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
   constructor(
-    entityConfiguration: EntityConfiguration<TFields>,
+    private readonly entityConfiguration: EntityConfiguration<TFields>,
     private readonly cache: Map<string, LocalMemoryCacheValue<TFields>>
-  ) {
-    super(entityConfiguration);
-  }
+  ) {}
 
   public async loadManyAsync<N extends keyof TFields>(
     fieldName: N,
@@ -123,10 +121,7 @@ function makeTestCacheAdapters(): {
   const fallbackCache = new Map();
   const fallbackCacheAdapter = new TestLocalCacheAdapter(entityConfiguration, fallbackCache);
 
-  const cacheAdapter = new ComposedEntityCacheAdapter(entityConfiguration, [
-    primaryCacheAdapter,
-    fallbackCacheAdapter,
-  ]);
+  const cacheAdapter = new ComposedEntityCacheAdapter([primaryCacheAdapter, fallbackCacheAdapter]);
 
   return {
     primaryCache,
@@ -229,7 +224,7 @@ describe(ComposedEntityCacheAdapter, () => {
     });
 
     it('handles 0 cache adapter compose case', async () => {
-      const cacheAdapter = new ComposedEntityCacheAdapter(entityConfiguration, []);
+      const cacheAdapter = new ComposedEntityCacheAdapter<any>([]);
       const results = await cacheAdapter.loadManyAsync('id', []);
       expect(results).toEqual(new Map());
     });

package/src/__tests__/EnforcingEntityLoader-test.ts

@@ -222,6 +222,49 @@ describe(EnforcingEntityLoader, () => {
     });
   });
 
+  describe('loadManyByIDsNullableAsync', () => {
+    it('throws when result is unsuccessful even when there is a null result', async () => {
+      const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
+      const rejection = new Error();
+      when(entityLoaderMock.loadManyByIDsNullableAsync(anything())).thenResolve(
+        new Map(
+          Object.entries({
+            hello: result(rejection),
+            world: null,
+          })
+        )
+      );
+      const entityLoader = instance(entityLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
+      await expect(enforcingEntityLoader.loadManyByIDsNullableAsync(anything())).rejects.toThrow(
+        rejection
+      );
+    });
+
+    it('returns value when result is successful', async () => {
+      const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
+      const resolved = {};
+      when(entityLoaderMock.loadManyByIDsNullableAsync(anything())).thenResolve(
+        new Map(
+          Object.entries({
+            hello: result(resolved),
+            world: null,
+          })
+        )
+      );
+      const entityLoader = instance(entityLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityLoader(entityLoader);
+      await expect(enforcingEntityLoader.loadManyByIDsNullableAsync(anything())).resolves.toEqual(
+        new Map(
+          Object.entries({
+            hello: resolved,
+            world: null,
+          })
+        )
+      );
+    });
+  });
+
   describe('loadFirstByFieldEqualityConjunction', () => {
     it('throws when result is unsuccessful', async () => {
       const entityLoaderMock = mock<EntityLoader<any, any, any, any, any, any>>(EntityLoader);
@@ -330,6 +373,7 @@ describe(EnforcingEntityLoader, () => {
       'tryConstructEntities',
       'validateFieldValues',
       'constructAndAuthorizeEntitiesAsync',
+      'constructEntity',
     ];
     expect(loaderProperties).toEqual(expect.arrayContaining(knownLoaderOnlyDifferences));
 

package/src/__tests__/Entity-test.ts

@@ -26,7 +26,12 @@ describe(Entity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(UpdateMutator);
     });
   });
@@ -38,7 +43,12 @@ describe(Entity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestDenyDeleteEntity(viewerContext, data);
+      const testEntity = new SimpleTestDenyDeleteEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       const canViewerUpdate = await SimpleTestDenyDeleteEntity.canViewerUpdateAsync(testEntity);
       expect(canViewerUpdate).toBe(true);
     });
@@ -49,7 +59,12 @@ describe(Entity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestDenyUpdateEntity(viewerContext, data);
+      const testEntity = new SimpleTestDenyUpdateEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       const canViewerUpdate = await SimpleTestDenyUpdateEntity.canViewerUpdateAsync(testEntity);
       expect(canViewerUpdate).toBe(false);
     });
@@ -62,7 +77,12 @@ describe(Entity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestDenyUpdateEntity(viewerContext, data);
+      const testEntity = new SimpleTestDenyUpdateEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       const canViewerDelete = await SimpleTestDenyUpdateEntity.canViewerDeleteAsync(testEntity);
       expect(canViewerDelete).toBe(true);
     });
@@ -73,7 +93,12 @@ describe(Entity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestDenyDeleteEntity(viewerContext, data);
+      const testEntity = new SimpleTestDenyDeleteEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       const canViewerDelete = await SimpleTestDenyDeleteEntity.canViewerDeleteAsync(testEntity);
       expect(canViewerDelete).toBe(false);
     });
@@ -177,37 +202,33 @@ class SimpleTestDenyDeleteEntityPrivacyPolicy extends EntityPrivacyPolicy<
 }
 
 class SimpleTestDenyUpdateEntity extends Entity<TestEntityFields, string, ViewerContext> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestEntityFields,
     string,
     ViewerContext,
     SimpleTestDenyUpdateEntity,
     SimpleTestDenyUpdateEntityPrivacyPolicy
   > {
-    return simpleTestDenyUpdateEntityCompanion;
+    return {
+      entityClass: SimpleTestDenyUpdateEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: SimpleTestDenyUpdateEntityPrivacyPolicy,
+    };
   }
 }
 
-const simpleTestDenyUpdateEntityCompanion = new EntityCompanionDefinition({
-  entityClass: SimpleTestDenyUpdateEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: SimpleTestDenyUpdateEntityPrivacyPolicy,
-});
-
 class SimpleTestDenyDeleteEntity extends Entity<TestEntityFields, string, ViewerContext> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestEntityFields,
     string,
     ViewerContext,
     SimpleTestDenyDeleteEntity,
     SimpleTestDenyDeleteEntityPrivacyPolicy
   > {
-    return simpleTestDenyDeleteEntityCompanion;
+    return {
+      entityClass: SimpleTestDenyDeleteEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: SimpleTestDenyDeleteEntityPrivacyPolicy,
+    };
   }
 }
-
-const simpleTestDenyDeleteEntityCompanion = new EntityCompanionDefinition({
-  entityClass: SimpleTestDenyDeleteEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: SimpleTestDenyDeleteEntityPrivacyPolicy,
-});

package/src/__tests__/EntityCommonUseCases-test.ts

@@ -31,14 +31,32 @@ type BlahFields = {
 };
 
 class BlahEntity extends Entity<BlahFields, string, TestUserViewerContext> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     BlahFields,
     string,
     TestUserViewerContext,
     BlahEntity,
     BlahEntityPrivacyPolicy
   > {
-    return blahCompanion;
+    return {
+      entityClass: BlahEntity,
+      entityConfiguration: new EntityConfiguration<BlahFields>({
+        idField: 'id',
+        tableName: 'blah_table',
+        schema: {
+          id: new UUIDField({
+            columnName: 'id',
+            cache: true,
+          }),
+          ownerID: new UUIDField({
+            columnName: 'owner_id',
+          }),
+        },
+        databaseAdapterFlavor: 'postgres',
+        cacheAdapterFlavor: 'redis',
+      }),
+      privacyPolicyClass: BlahEntityPrivacyPolicy,
+    };
   }
 }
 
@@ -84,26 +102,6 @@ class BlahEntityPrivacyPolicy extends EntityPrivacyPolicy<
   ];
 }
 
-const blahCompanion = new EntityCompanionDefinition({
-  entityClass: BlahEntity,
-  entityConfiguration: new EntityConfiguration<BlahFields>({
-    idField: 'id',
-    tableName: 'blah_table',
-    schema: {
-      id: new UUIDField({
-        columnName: 'id',
-        cache: true,
-      }),
-      ownerID: new UUIDField({
-        columnName: 'owner_id',
-      }),
-    },
-    databaseAdapterFlavor: 'postgres',
-    cacheAdapterFlavor: 'redis',
-  }),
-  privacyPolicyClass: BlahEntityPrivacyPolicy,
-});
-
 it('runs through a common workflow', async () => {
   // will be one entity companion provider for each request, so
   // share amongst all VCs created in that request

package/src/__tests__/EntityCompanion-test.ts

@@ -1,27 +1,24 @@
 import { instance, mock, when } from 'ts-mockito';
 
 import EntityCompanion from '../EntityCompanion';
+import EntityCompanionProvider from '../EntityCompanionProvider';
 import EntityLoaderFactory from '../EntityLoaderFactory';
 import EntityMutatorFactory from '../EntityMutatorFactory';
 import EntityTableDataCoordinator from '../internal/EntityTableDataCoordinator';
 import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
-import TestEntity, {
-  TestEntityPrivacyPolicy,
-  testEntityConfiguration,
-  TestFields,
-} from '../testfixtures/TestEntity';
+import TestEntity, { testEntityConfiguration, TestFields } from '../testfixtures/TestEntity';
 
 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 companion = new EntityCompanion(
-      TestEntity,
+      entityCompanionProvider,
+      TestEntity.defineCompanionDefinition(),
       instance(tableDataCoordinatorMock),
-      TestEntityPrivacyPolicy,
-      [],
-      {},
       instance(mock<IEntityMetricsAdapter>())
     );
     expect(companion.getLoaderFactory()).toBeInstanceOf(EntityLoaderFactory);

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,