@expo/entity 0.40.0 → 0.41.0

package/src/ReadonlyEntity.ts

@@ -1,8 +1,13 @@
 import invariant from 'invariant';
 
+import AuthorizationResultBasedEntityAssociationLoader from './AuthorizationResultBasedEntityAssociationLoader';
+import AuthorizationResultBasedEntityLoader from './AuthorizationResultBasedEntityLoader';
+import EnforcingEntityAssociationLoader from './EnforcingEntityAssociationLoader';
+import EnforcingEntityLoader from './EnforcingEntityLoader';
 import { IEntityClass } from './Entity';
 import EntityAssociationLoader from './EntityAssociationLoader';
 import EntityLoader from './EntityLoader';
+import EntityLoaderUtils from './EntityLoaderUtils';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
 import ViewerContext from './ViewerContext';
@@ -82,12 +87,33 @@ export default abstract class ReadonlyEntity<
   }
 
   /**
-   * @returns EntityAssociationLoader for this entity
+   * @returns EnforcingEntityAssociationLoader for this entity
    */
   associationLoader(
     queryContext?: EntityQueryContext,
-  ): EntityAssociationLoader<TFields, TID, TViewerContext, this, TSelectedFields> {
-    return new EntityAssociationLoader(this, queryContext);
+  ): EnforcingEntityAssociationLoader<TFields, TID, TViewerContext, this, TSelectedFields> {
+    return new EntityAssociationLoader<TFields, TID, TViewerContext, this, TSelectedFields>(
+      this,
+      queryContext,
+    ).enforcing();
+  }
+
+  /**
+   * @returns AuthorizationResultBasedEntityAssociationLoader for this entity
+   */
+  associationLoaderWithAuthorizationResults(
+    queryContext?: EntityQueryContext,
+  ): AuthorizationResultBasedEntityAssociationLoader<
+    TFields,
+    TID,
+    TViewerContext,
+    this,
+    TSelectedFields
+  > {
+    return new EntityAssociationLoader<TFields, TID, TViewerContext, this, TSelectedFields>(
+      this,
+      queryContext,
+    ).withAuthorizationResults();
   }
 
   /**
@@ -148,15 +174,102 @@ export default abstract class ReadonlyEntity<
       .getViewerScopedEntityCompanionForClass(this)
       .getQueryContextProvider()
       .getQueryContext(),
-  ): EntityLoader<
+  ): EnforcingEntityLoader<
+    TMFields,
+    TMID,
+    TMViewerContext,
+    TMEntity,
+    TMPrivacyPolicy,
+    TMSelectedFields
+  > {
+    return new EntityLoader(viewerContext, queryContext, this).enforcing();
+  }
+
+  /**
+   * Vend loader for loading an entity in a given query context.
+   * @param viewerContext - viewer context of loading user
+   * @param queryContext - query context in which to perform the load
+   */
+  static loaderWithAuthorizationResults<
+    TMFields extends object,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
+    TMViewerContext extends ViewerContext,
+    TMViewerContext2 extends TMViewerContext,
+    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
+    TMPrivacyPolicy extends EntityPrivacyPolicy<
+      TMFields,
+      TMID,
+      TMViewerContext,
+      TMEntity,
+      TMSelectedFields
+    >,
+    TMSelectedFields extends keyof TMFields = keyof TMFields,
+  >(
+    this: IEntityClass<
+      TMFields,
+      TMID,
+      TMViewerContext,
+      TMEntity,
+      TMPrivacyPolicy,
+      TMSelectedFields
+    >,
+    viewerContext: TMViewerContext2,
+    queryContext: EntityQueryContext = viewerContext
+      .getViewerScopedEntityCompanionForClass(this)
+      .getQueryContextProvider()
+      .getQueryContext(),
+  ): AuthorizationResultBasedEntityLoader<
+    TMFields,
+    TMID,
+    TMViewerContext,
+    TMEntity,
+    TMPrivacyPolicy,
+    TMSelectedFields
+  > {
+    return new EntityLoader(viewerContext, queryContext, this).withAuthorizationResults();
+  }
+
+  /**
+   * Vend loader for loading an entity in a given query context.
+   * @param viewerContext - viewer context of loading user
+   * @param queryContext - query context in which to perform the load
+   */
+  static loaderUtils<
+    TMFields extends object,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
+    TMViewerContext extends ViewerContext,
+    TMViewerContext2 extends TMViewerContext,
+    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
+    TMPrivacyPolicy extends EntityPrivacyPolicy<
+      TMFields,
+      TMID,
+      TMViewerContext,
+      TMEntity,
+      TMSelectedFields
+    >,
+    TMSelectedFields extends keyof TMFields = keyof TMFields,
+  >(
+    this: IEntityClass<
+      TMFields,
+      TMID,
+      TMViewerContext,
+      TMEntity,
+      TMPrivacyPolicy,
+      TMSelectedFields
+    >,
+    viewerContext: TMViewerContext2,
+    queryContext: EntityQueryContext = viewerContext
+      .getViewerScopedEntityCompanionForClass(this)
+      .getQueryContextProvider()
+      .getQueryContext(),
+  ): EntityLoaderUtils<
     TMFields,
     TMID,
     TMViewerContext,
-    TMViewerContext2,
     TMEntity,
     TMPrivacyPolicy,
     TMSelectedFields
   > {
-    return new EntityLoader(viewerContext, queryContext, this);
+    return new EntityLoader(viewerContext, queryContext, this).utils();
   }
 }

package/src/__tests__/AuthorizationResultBasedEntityAssociationLoader-test.ts

@@ -14,26 +14,23 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+        TestEntity.creatorWithAuthorizationResults(viewerContext).createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', testOtherEntity.getID())
           .createAsync(),
       );
       const loadedOther = await enforceAsyncResult(
         testEntity
-          .associationLoader()
-          .withAuthorizationResults()
+          .associationLoaderWithAuthorizationResults()
           .loadAssociatedEntityAsync('stringField', TestEntity),
       );
       expect(loadedOther.getID()).toEqual(testOtherEntity.getID());
 
       const loadedOther2 = await enforceAsyncResult(
         testEntity
-          .associationLoader()
-          .withAuthorizationResults()
+          .associationLoaderWithAuthorizationResults()
           .loadAssociatedEntityAsync('nullableField', TestEntity),
       );
       expect(loadedOther2).toBeNull();
@@ -45,24 +42,21 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+        TestEntity.creatorWithAuthorizationResults(viewerContext).createAsync(),
       );
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', testEntity.getID())
           .createAsync(),
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', testEntity.getID())
           .createAsync(),
       );
       const loaded = await enforceResultsAsync(
         testEntity
-          .associationLoader()
-          .withAuthorizationResults()
+          .associationLoaderWithAuthorizationResults()
           .loadManyAssociatedEntitiesAsync(TestEntity, 'stringField'),
       );
       expect(loaded).toHaveLength(2);
@@ -76,17 +70,15 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+        TestEntity.creatorWithAuthorizationResults(viewerContext).createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', testOtherEntity.getID())
           .createAsync(),
       );
       const loadedOtherResult = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
       expect(loadedOtherResult?.enforceValue().getID()).toEqual(testOtherEntity.getID());
     });
@@ -95,14 +87,12 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', uuidv4())
           .createAsync(),
       );
       const loadedOtherResult = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
       expect(loadedOtherResult).toBeNull();
     });
@@ -111,14 +101,12 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', 'blah')
           .createAsync(),
       );
       const loadedOtherResult = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityByFieldEqualingAsync('nullableField', TestEntity, 'customIdField');
       expect(loadedOtherResult).toBeNull();
     });
@@ -129,24 +117,21 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+        TestEntity.creatorWithAuthorizationResults(viewerContext).createAsync(),
       );
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', testEntity.getID())
           .createAsync(),
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', testEntity.getID())
           .createAsync(),
       );
       const loaded = await enforceResultsAsync(
         testEntity
-          .associationLoader()
-          .withAuthorizationResults()
+          .associationLoaderWithAuthorizationResults()
           .loadManyAssociatedEntitiesByFieldEqualingAsync(
             'customIdField',
             TestEntity,
@@ -162,12 +147,11 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+        TestEntity.creatorWithAuthorizationResults(viewerContext).createAsync(),
       );
       const loaded = await enforceResultsAsync(
         testEntity
-          .associationLoader()
-          .withAuthorizationResults()
+          .associationLoaderWithAuthorizationResults()
           .loadManyAssociatedEntitiesByFieldEqualingAsync(
             'nullableField',
             TestEntity,
@@ -183,30 +167,26 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity4 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).withAuthorizationResults().createAsync(),
+        TestEntity.creatorWithAuthorizationResults(viewerContext).createAsync(),
       );
       const testEntity3 = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity2.creatorWithAuthorizationResults(viewerContext)
           .setField('foreignKey', testEntity4.getID())
           .createAsync(),
       );
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('testIndexedField', testEntity3.getID())
           .createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity2.creatorWithAuthorizationResults(viewerContext)
           .setField('foreignKey', testEntity2.getID())
           .createAsync(),
       );
 
       const loaded2Result = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityThroughAsync([
           {
             associatedEntityClass: TestEntity,
@@ -216,8 +196,7 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
 
       const loaded3Result = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityThroughAsync([
           {
             associatedEntityClass: TestEntity,
@@ -231,8 +210,7 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       expect(loaded3Result?.enforceValue().getID()).toEqual(testEntity3.getID());
 
       const loaded4Result = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityThroughAsync([
           {
             associatedEntityClass: TestEntity,
@@ -255,15 +233,13 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity2.creatorWithAuthorizationResults(viewerContext)
           .setField('foreignKey', uuidv4())
           .createAsync(),
       );
 
       const loadResult = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityThroughAsync([
           {
             associatedEntityClass: TestEntity,
@@ -279,21 +255,18 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
 
       const fieldValue = uuidv4();
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('stringField', fieldValue)
           .createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity2.creatorWithAuthorizationResults(viewerContext)
           .setField('foreignKey', fieldValue)
           .createAsync(),
       );
 
       const loaded2Result = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityThroughAsync([
           {
             associatedEntityClass: TestEntity,
@@ -309,15 +282,13 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity2.creatorWithAuthorizationResults(viewerContext)
           .setField('foreignKey', uuidv4())
           .createAsync(),
       );
 
       const loaded2Result = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityThroughAsync([
           {
             associatedEntityClass: TestEntity,
@@ -333,15 +304,13 @@ describe(AuthorizationResultBasedEntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .withAuthorizationResults()
+        TestEntity.creatorWithAuthorizationResults(viewerContext)
           .setField('nullableField', null)
           .createAsync(),
       );
 
       const loadedResult = await testEntity
-        .associationLoader()
-        .withAuthorizationResults()
+        .associationLoaderWithAuthorizationResults()
         .loadAssociatedEntityThroughAsync([
           {
             associatedEntityClass: TestEntity,

package/src/__tests__/Entity-test.ts

@@ -1,22 +1,37 @@
+import {
+  AuthorizationResultBasedCreateMutator,
+  AuthorizationResultBasedDeleteMutator,
+  AuthorizationResultBasedUpdateMutator,
+} from '../AuthorizationResultBasedEntityMutator';
+import EnforcingEntityCreator from '../EnforcingEntityCreator';
+import EnforcingEntityDeleter from '../EnforcingEntityDeleter';
+import EnforcingEntityUpdater from '../EnforcingEntityUpdater';
 import Entity from '../Entity';
-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 EntityCreator', () => {
+    it('creates a new EnforcingEntityCreator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(EntityCreator);
+      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(EnforcingEntityCreator);
+    });
+  });
+
+  describe('creatorWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedCreateMutator', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(SimpleTestEntity.creatorWithAuthorizationResults(viewerContext)).toBeInstanceOf(
+        AuthorizationResultBasedCreateMutator,
+      );
     });
   });
 
   describe('updater', () => {
-    it('creates a new EntityUpdater', () => {
+    it('creates a new EnforcingEntityUpdater', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
       const data = {
@@ -28,12 +43,48 @@ describe(Entity, () => {
         databaseFields: data,
         selectedFields: data,
       });
-      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(EntityUpdater);
+      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(EnforcingEntityUpdater);
+    });
+  });
+
+  describe('updaterWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedUpdateMutator', () => {
+      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.updaterWithAuthorizationResults(testEntity)).toBeInstanceOf(
+        AuthorizationResultBasedUpdateMutator,
+      );
     });
   });
 
   describe('deleter', () => {
-    it('creates a new EntityDeleter', () => {
+    it('creates a new EnforcingEntityDeleter', () => {
+      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(EnforcingEntityDeleter);
+    });
+  });
+
+  describe('deleterWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedDeleteMutator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
       const data = {
@@ -45,7 +96,9 @@ describe(Entity, () => {
         databaseFields: data,
         selectedFields: data,
       });
-      expect(SimpleTestEntity.deleter(testEntity)).toBeInstanceOf(EntityDeleter);
+      expect(SimpleTestEntity.deleterWithAuthorizationResults(testEntity)).toBeInstanceOf(
+        AuthorizationResultBasedDeleteMutator,
+      );
     });
   });
 });

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -10,10 +10,8 @@ describe(EntityAssociationLoader, () => {
     it('creates a new EnforcingEntityLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      const testEntity = await SimpleTestEntity.creator(viewerContext).enforcing().createAsync();
-      expect(testEntity.associationLoader().enforcing()).toBeInstanceOf(
-        EnforcingEntityAssociationLoader,
-      );
+      const testEntity = await SimpleTestEntity.creator(viewerContext).createAsync();
+      expect(testEntity.associationLoader()).toBeInstanceOf(EnforcingEntityAssociationLoader);
     });
   });
 
@@ -21,8 +19,8 @@ describe(EntityAssociationLoader, () => {
     it('creates a new AuthorizationResultBasedEntityAssociationLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      const testEntity = await SimpleTestEntity.creator(viewerContext).enforcing().createAsync();
-      expect(testEntity.associationLoader().withAuthorizationResults()).toBeInstanceOf(
+      const testEntity = await SimpleTestEntity.creator(viewerContext).createAsync();
+      expect(testEntity.associationLoaderWithAuthorizationResults()).toBeInstanceOf(
         AuthorizationResultBasedEntityAssociationLoader,
       );
     });

package/src/__tests__/EntityCommonUseCases-test.ts

@@ -118,22 +118,19 @@ it('runs through a common workflow', async () => {
   const vc2 = new TestUserViewerContext(entityCompanionProvider, uuidv4());
 
   const blahOwner1 = await enforceAsyncResult(
-    BlahEntity.creator(vc1)
-      .withAuthorizationResults()
+    BlahEntity.creatorWithAuthorizationResults(vc1)
       .setField('ownerID', vc1.getUserID())
       .createAsync(),
   );
 
   await enforceAsyncResult(
-    BlahEntity.creator(vc1)
-      .withAuthorizationResults()
+    BlahEntity.creatorWithAuthorizationResults(vc1)
       .setField('ownerID', vc1.getUserID())
       .createAsync(),
   );
 
   const blahOwner2 = await enforceAsyncResult(
-    BlahEntity.creator(vc2)
-      .withAuthorizationResults()
+    BlahEntity.creatorWithAuthorizationResults(vc2)
       .setField('ownerID', vc2.getUserID())
       .createAsync(),
   );
@@ -145,43 +142,43 @@ it('runs through a common workflow', async () => {
   // check that two people can't read each others data
   await expect(
     enforceAsyncResult(
-      BlahEntity.loader(vc1).withAuthorizationResults().loadByIDAsync(blahOwner2.getID()),
+      BlahEntity.loaderWithAuthorizationResults(vc1).loadByIDAsync(blahOwner2.getID()),
     ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
   await expect(
     enforceAsyncResult(
-      BlahEntity.loader(vc2).withAuthorizationResults().loadByIDAsync(blahOwner1.getID()),
+      BlahEntity.loaderWithAuthorizationResults(vc2).loadByIDAsync(blahOwner1.getID()),
     ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
   // check that all of owner 1's objects can be loaded
   const results = await enforceResultsAsync(
-    BlahEntity.loader(vc1)
-      .withAuthorizationResults()
-      .loadManyByFieldEqualingAsync('ownerID', vc1.getUserID()),
+    BlahEntity.loaderWithAuthorizationResults(vc1).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)
-        .withAuthorizationResults()
+      BlahEntity.creatorWithAuthorizationResults(vc2)
         .setField('ownerID', blahOwner1.getID())
         .createAsync(),
     ),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 
   // check that empty load many returns nothing
-  const results2 = await BlahEntity.loader(vc1)
-    .withAuthorizationResults()
-    .loadManyByFieldEqualingManyAsync('ownerID', []);
+  const results2 = await BlahEntity.loaderWithAuthorizationResults(
+    vc1,
+  ).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.deleter(blahOwner2).withAuthorizationResults().deleteAsync()),
+    enforceAsyncResult(BlahEntity.deleterWithAuthorizationResults(blahOwner2).deleteAsync()),
   ).rejects.toBeInstanceOf(EntityNotAuthorizedError);
 });