@expo/entity 0.38.0 → 0.40.0

package/src/__tests__/EnforcingEntityAssociationLoader-test.ts

@@ -0,0 +1,253 @@
+import { result } from '@expo/results';
+import { mock, instance, when, anything } from 'ts-mockito';
+
+import AuthorizationResultBasedEntityAssociationLoader from '../AuthorizationResultBasedEntityAssociationLoader';
+import EnforcingEntityAssociationLoader from '../EnforcingEntityAssociationLoader';
+
+describe(EnforcingEntityAssociationLoader, () => {
+  describe('loadAssociatedEntityAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityAsync(anything(), anything()),
+      ).thenResolve(result(rejection));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadAssociatedEntityAsync(anything(), anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = {} as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityAsync(anything(), anything()),
+      ).thenResolve(result(resolved));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadAssociatedEntityAsync(anything(), anything()),
+      ).resolves.toEqual(resolved);
+    });
+  });
+
+  describe('loadManyAssociatedEntitiesAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadManyAssociatedEntitiesAsync(
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve([result(rejection)]);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadManyAssociatedEntitiesAsync(
+          anything(),
+          anything() as never,
+        ),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = [] as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadManyAssociatedEntitiesAsync(
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve([result(resolved)]);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadManyAssociatedEntitiesAsync(anything(), anything() as never),
+      ).resolves.toEqual([resolved]);
+    });
+  });
+
+  describe('loadAssociatedEntityByFieldEqualingAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve(result(rejection));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = {} as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve(result(resolved));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).resolves.toEqual(resolved);
+    });
+
+    it('returns null when result is successful but null', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = null;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve(resolved);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).resolves.toEqual(resolved);
+    });
+  });
+
+  describe('loadManyAssociatedEntitiesByFieldEqualingAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadManyAssociatedEntitiesByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve([result(rejection)]);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadManyAssociatedEntitiesByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = [] as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadManyAssociatedEntitiesByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve([result(resolved)]);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadManyAssociatedEntitiesByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).resolves.toEqual([resolved]);
+    });
+  });
+
+  describe('loadAssociatedEntityThroughAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityThroughAsync(anything()),
+      ).thenResolve(result(rejection));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadAssociatedEntityThroughAsync(anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = {} as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityThroughAsync(anything()),
+      ).thenResolve(result(resolved));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadAssociatedEntityThroughAsync(anything()),
+      ).resolves.toEqual(resolved);
+    });
+  });
+
+  it('has the same method names as AuthorizationResultBasedEntityAssociationLoader', () => {
+    const enforcingLoaderProperties = Object.getOwnPropertyNames(
+      EnforcingEntityAssociationLoader.prototype,
+    );
+    const nonEnforcingLoaderProperties = Object.getOwnPropertyNames(
+      AuthorizationResultBasedEntityAssociationLoader.prototype,
+    );
+
+    expect(enforcingLoaderProperties).toEqual(nonEnforcingLoaderProperties);
+  });
+});

package/src/__tests__/Entity-test.ts

@@ -1,20 +1,22 @@
 import Entity from '../Entity';
-import { CreateMutator, UpdateMutator } from '../EntityMutator';
+import EntityCreator from '../EntityCreator';
+import EntityDeleter from '../EntityDeleter';
+import EntityUpdater from '../EntityUpdater';
 import ViewerContext from '../ViewerContext';
 import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe(Entity, () => {
   describe('creator', () => {
-    it('creates a new CreateMutator', () => {
+    it('creates a new EntityCreator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(CreateMutator);
+      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(EntityCreator);
     });
   });
 
   describe('updater', () => {
-    it('creates a new UpdateMutator', () => {
+    it('creates a new EntityUpdater', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
       const data = {
@@ -26,7 +28,24 @@ describe(Entity, () => {
         databaseFields: data,
         selectedFields: data,
       });
-      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(UpdateMutator);
+      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(EntityUpdater);
+    });
+  });
+
+  describe('deleter', () => {
+    it('creates a new EntityDeleter', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const data = {
+        id: 'what',
+      };
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      expect(SimpleTestEntity.deleter(testEntity)).toBeInstanceOf(EntityDeleter);
     });
   });
 });

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -1,273 +1,30 @@
-import { enforceAsyncResult } from '@expo/results';
-import { v4 as uuidv4 } from 'uuid';
-
+import AuthorizationResultBasedEntityAssociationLoader from '../AuthorizationResultBasedEntityAssociationLoader';
+import EnforcingEntityAssociationLoader from '../EnforcingEntityAssociationLoader';
 import EntityAssociationLoader from '../EntityAssociationLoader';
-import { enforceResultsAsync } from '../entityUtils';
-import TestEntity from '../testfixtures/TestEntity';
-import TestEntity2 from '../testfixtures/TestEntity2';
-import TestViewerContext from '../testfixtures/TestViewerContext';
+import ViewerContext from '../ViewerContext';
+import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe(EntityAssociationLoader, () => {
-  describe('loadAssociatedEntityAsync', () => {
-    it('loads associated entities by ID and correctly handles a null value', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).createAsync(),
-      );
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .setField('stringField', testOtherEntity.getID())
-          .createAsync(),
-      );
-      const loadedOther = await enforceAsyncResult(
-        testEntity.associationLoader().loadAssociatedEntityAsync('stringField', TestEntity),
-      );
-      expect(loadedOther.getID()).toEqual(testOtherEntity.getID());
-
-      const loadedOther2 = await enforceAsyncResult(
-        testEntity.associationLoader().loadAssociatedEntityAsync('nullableField', TestEntity),
-      );
-      expect(loadedOther2).toBeNull();
-    });
-  });
-
-  describe('loadManyAssociatedEntitiesAsync', () => {
-    it('loads many associated entities referencing this entity', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      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(),
-      );
-      const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
-      );
-      const loaded = await enforceResultsAsync(
-        testEntity.associationLoader().loadManyAssociatedEntitiesAsync(TestEntity, 'stringField'),
-      );
-      expect(loaded).toHaveLength(2);
-      expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
-      expect(loaded.find((e) => e.getID() === testOtherEntity2.getID())).not.toBeUndefined();
-    });
-  });
-
-  describe('loadAssociatedEntityByFieldEqualingAsync', () => {
-    it('loads associated entity by field equaling', async () => {
+  describe('enforcing', () => {
+    it('creates a new EnforcingEntityLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).createAsync(),
+      const viewerContext = new ViewerContext(companionProvider);
+      const testEntity = await SimpleTestEntity.creator(viewerContext).enforcing().createAsync();
+      expect(testEntity.associationLoader().enforcing()).toBeInstanceOf(
+        EnforcingEntityAssociationLoader,
       );
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .setField('stringField', testOtherEntity.getID())
-          .createAsync(),
-      );
-      const loadedOtherResult = await testEntity
-        .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
-      expect(loadedOtherResult?.enforceValue().getID()).toEqual(testOtherEntity.getID());
-    });
-
-    it('returns null when loading associated entities by field equaling a non existent association', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', uuidv4()).createAsync(),
-      );
-      const loadedOtherResult = await testEntity
-        .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
-      expect(loadedOtherResult).toBeNull();
-    });
-
-    it('returns null when load-by field is null', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', 'blah').createAsync(),
-      );
-      const loadedOtherResult = await testEntity
-        .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('nullableField', TestEntity, 'customIdField');
-      expect(loadedOtherResult).toBeNull();
     });
   });
 
-  describe('loadManyAssociatedEntitiesByFieldEqualingAsync', () => {
-    it('loads many associated entities by field equaling', async () => {
+  describe('withAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedEntityAssociationLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
-      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(),
+      const viewerContext = new ViewerContext(companionProvider);
+      const testEntity = await SimpleTestEntity.creator(viewerContext).enforcing().createAsync();
+      expect(testEntity.associationLoader().withAuthorizationResults()).toBeInstanceOf(
+        AuthorizationResultBasedEntityAssociationLoader,
       );
-      const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
-      );
-      const loaded = await enforceResultsAsync(
-        testEntity
-          .associationLoader()
-          .loadManyAssociatedEntitiesByFieldEqualingAsync(
-            'customIdField',
-            TestEntity,
-            'stringField',
-          ),
-      );
-      expect(loaded).toHaveLength(2);
-      expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
-      expect(loaded.find((e) => e.getID() === testOtherEntity2.getID())).not.toBeUndefined();
-    });
-
-    it('returns empty results when field being queried by is null', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
-      const loaded = await enforceResultsAsync(
-        testEntity
-          .associationLoader()
-          .loadManyAssociatedEntitiesByFieldEqualingAsync(
-            'nullableField',
-            TestEntity,
-            'stringField',
-          ),
-      );
-      expect(loaded).toHaveLength(0);
-    });
-  });
-
-  describe('loadAssociatedEntityThroughAsync', () => {
-    it('chain loads associated entities', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      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(),
-      );
-      const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .setField('testIndexedField', testEntity3.getID())
-          .createAsync(),
-      );
-      const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext)
-          .setField('foreignKey', testEntity2.getID())
-          .createAsync(),
-      );
-
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-      ]);
-      expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
-
-      const loaded3Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-        {
-          associatedEntityClass: TestEntity2,
-          fieldIdentifyingAssociatedEntity: 'testIndexedField',
-        },
-      ]);
-      expect(loaded3Result?.enforceValue().getID()).toEqual(testEntity3.getID());
-
-      const loaded4Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-        {
-          associatedEntityClass: TestEntity2,
-          fieldIdentifyingAssociatedEntity: 'testIndexedField',
-        },
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-      ]);
-      expect(loaded4Result?.enforceValue().getID()).toEqual(testEntity4.getID());
-    });
-
-    it('fails when chain loading associated entity fails', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-
-      const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync(),
-      );
-
-      const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-      ]);
-      expect(loadResult?.ok).toBe(false);
-    });
-
-    it('supports chain loading by field equality', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-
-      const fieldValue = uuidv4();
-      const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', fieldValue).createAsync(),
-      );
-      const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', fieldValue).createAsync(),
-      );
-
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-          associatedEntityLookupByField: 'stringField',
-        },
-      ]);
-      expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
-    });
-
-    it('returns null when chain loading by field equality returns null', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-
-      const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync(),
-      );
-
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-          associatedEntityLookupByField: 'stringField',
-        },
-      ]);
-      expect(loaded2Result).toBeNull();
-    });
-
-    it('returns null when chain loading by field is null', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('nullableField', null).createAsync(),
-      );
-
-      const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'nullableField',
-        },
-      ]);
-      expect(loadedResult).toBeNull();
     });
   });
 });

package/src/__tests__/EntityCommonUseCases-test.ts

@@ -118,15 +118,24 @@ 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)
+      .withAuthorizationResults()
+      .setField('ownerID', vc1.getUserID())
+      .createAsync(),
   );
 
   await enforceAsyncResult(
-    BlahEntity.creator(vc1).setField('ownerID', vc1.getUserID()!).createAsync(),
+    BlahEntity.creator(vc1)
+      .withAuthorizationResults()
+      .setField('ownerID', vc1.getUserID())
+      .createAsync(),
   );
 
   const blahOwner2 = await enforceAsyncResult(
-    BlahEntity.creator(vc2).setField('ownerID', vc2.getUserID()!).createAsync(),
+    BlahEntity.creator(vc2)
+      .withAuthorizationResults()
+      .setField('ownerID', vc2.getUserID())
+      .createAsync(),
   );
 
   // sanity check created objects
@@ -149,14 +158,17 @@ it('runs through a common workflow', async () => {
   const results = await enforceResultsAsync(
     BlahEntity.loader(vc1)
       .withAuthorizationResults()
-      .loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()!),
+      .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)
+        .withAuthorizationResults()
+        .setField('ownerID', blahOwner1.getID())
+        .createAsync(),
     ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
@@ -169,7 +181,7 @@ it('runs through a common workflow', async () => {
   }
 
   // check that the user can't delete their own data (as specified by privacy rules)
-  await expect(enforceAsyncResult(BlahEntity.deleteAsync(blahOwner2))).rejects.toBeInstanceOf(
-    EntityNotAuthorizedError,
-  );
+  await expect(
+    enforceAsyncResult(BlahEntity.deleter(blahOwner2).withAuthorizationResults().deleteAsync()),
+  ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 });

package/src/__tests__/EntityCompanion-test.ts

@@ -72,7 +72,7 @@ describe(EntityCompanion, () => {
 
     expect(mergedTriggers).toStrictEqual({
       afterCreate: [localTriggers!.afterCreate![0], globalMutationTriggers.afterCreate![0]],
-      afterAll: [localTriggers!.afterAll![0], globalMutationTriggers!.afterAll![0]],
+      afterAll: [localTriggers!.afterAll![0], globalMutationTriggers.afterAll![0]],
       afterCommit: [localTriggers!.afterCommit![0]],
     });
   });

package/src/__tests__/EntityDatabaseAdapter-test.ts

@@ -9,12 +9,12 @@ import { FieldTransformerMap } from '../internal/EntityFieldTransformationUtils'
 import { TestFields, testEntityConfiguration } from '../testfixtures/TestEntity';
 
 class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
-  private fetchResults: object[];
-  private insertResults: object[];
-  private updateResults: object[];
-  private fetchEqualityConditionResults: object[];
-  private fetchRawWhereResults: object[];
-  private deleteCount: number;
+  private readonly fetchResults: object[];
+  private readonly insertResults: object[];
+  private readonly updateResults: object[];
+  private readonly fetchEqualityConditionResults: object[];
+  private readonly fetchRawWhereResults: object[];
+  private readonly deleteCount: number;
 
   constructor({
     fetchResults = [],