@expo/entity-database-adapter-knex 0.34.0 → 0.36.0

package/src/__integration-tests__/PostgresEntityIntegration-test.ts

@@ -1,13 +1,13 @@
 import {
   OrderByOrdering,
   createUnitTestEntityCompanionProvider,
-  enforceResultsAsync,
   ViewerContext,
   TransactionIsolationLevel,
 } from '@expo/entity';
 import { enforceAsyncResult } from '@expo/results';
 import { knex, Knex } from 'knex';
 import nullthrows from 'nullthrows';
+import { setTimeout } from 'timers/promises';
 
 import PostgresTestEntity from '../testfixtures/PostgresTestEntity';
 import PostgresTriggerTestEntity from '../testfixtures/PostgresTriggerTestEntity';
@@ -42,34 +42,16 @@ describe('postgres entity integration', () => {
   it('supports parallel partial updates', async () => {
     const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
     const entity = await enforceAsyncResult(
-      PostgresTestEntity.creator(
-        vc,
-        vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .setField('name', 'hello')
-        .createAsync()
+      PostgresTestEntity.creator(vc).setField('name', 'hello').createAsync(),
     );
 
     // update two different fields at the same time (from the same entity)
     await Promise.all([
-      PostgresTestEntity.updater(
-        entity,
-        vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .setField('hasACat', true)
-        .updateAsync(),
-      PostgresTestEntity.updater(
-        entity,
-        vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .setField('hasADog', false)
-        .updateAsync(),
+      PostgresTestEntity.updater(entity).setField('hasACat', true).updateAsync(),
+      PostgresTestEntity.updater(entity).setField('hasADog', false).updateAsync(),
     ]);
 
-    const loadedEntity = await PostgresTestEntity.loader(
-      vc,
-      vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-    )
+    const loadedEntity = await PostgresTestEntity.loader(vc)
       .enforcing()
       .loadByIDAsync(entity.getID());
 
@@ -80,49 +62,24 @@ describe('postgres entity integration', () => {
   describe('empty creates and updates', () => {
     it('allows empty create', async () => {
       const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-      const entity = await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc,
-          vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        ).createAsync()
-      );
+      const entity = await enforceAsyncResult(PostgresTestEntity.creator(vc).createAsync());
       expect(entity.getID()).toBeTruthy();
     });
 
     it('throws knex error upon empty update', async () => {
       const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
       const entity = await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc,
-          vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
-          .setField('name', 'hello')
-          .createAsync()
+        PostgresTestEntity.creator(vc).setField('name', 'hello').createAsync(),
       );
-      await expect(
-        PostgresTestEntity.updater(
-          entity,
-          vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        ).updateAsync()
-      ).rejects.toThrow();
+      await expect(PostgresTestEntity.updater(entity).updateAsync()).rejects.toThrow();
     });
 
     it('throws error upon empty update for stub database adapter to match behavior', async () => {
       const vc = new ViewerContext(createUnitTestEntityCompanionProvider());
       const entity = await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc,
-          vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
-          .setField('name', 'hello')
-          .createAsync()
+        PostgresTestEntity.creator(vc).setField('name', 'hello').createAsync(),
       );
-      await expect(
-        PostgresTestEntity.updater(
-          entity,
-          vc.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        ).updateAsync()
-      ).rejects.toThrow();
+      await expect(PostgresTestEntity.updater(entity).updateAsync()).rejects.toThrow();
     });
   });
 
@@ -131,84 +88,89 @@ describe('postgres entity integration', () => {
 
     // put one in the DB
     const firstEntity = await enforceAsyncResult(
-      PostgresTestEntity.creator(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .setField('name', 'hello')
-        .createAsync()
+      PostgresTestEntity.creator(vc1).setField('name', 'hello').createAsync(),
     );
 
-    await enforceAsyncResult(
-      PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      ).loadByIDAsync(firstEntity.getID())
-    );
+    await PostgresTestEntity.loader(vc1).enforcing().loadByIDAsync(firstEntity.getID());
 
     const errorToThrow = new Error('Intentional error');
 
     await expect(
-      vc1.runInTransactionForDatabaseAdaptorFlavorAsync('postgres', async (queryContext) => {
-        // put another in the DB that will be rolled back due to error thrown
-        await enforceAsyncResult(
-          PostgresTestEntity.creator(vc1, queryContext).setField('name', 'hello').createAsync()
-        );
+      vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          // put another in the DB that will be rolled back due to error thrown
+          await enforceAsyncResult(
+            PostgresTestEntity.creator(vc1, queryContext).setField('name', 'hello').createAsync(),
+          );
 
-        throw errorToThrow;
-      })
+          throw errorToThrow;
+        },
+        {}, // test empty transaction config
+      ),
     ).rejects.toEqual(errorToThrow);
 
-    const entities = await enforceResultsAsync(
-      PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      ).loadManyByFieldEqualingAsync('name', 'hello')
-    );
+    const entities = await PostgresTestEntity.loader(vc1)
+      .enforcing()
+      .loadManyByFieldEqualingAsync('name', 'hello');
     expect(entities).toHaveLength(1);
   });
 
-  it('passes transaction config into transactions', async () => {
-    const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
-
-    const firstEntity = await enforceAsyncResult(
-      PostgresTestEntity.creator(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
-        .setField('name', 'hello')
-        .createAsync()
-    );
+  describe('isolation levels', () => {
+    test.each(Object.values(TransactionIsolationLevel))(
+      'isolation level: %p',
+      async (isolationLevel: TransactionIsolationLevel) => {
+        const vc1 = new ViewerContext(
+          createKnexIntegrationTestEntityCompanionProvider(knexInstance),
+        );
 
-    const loadAndUpdateAsync = async (newName: string): Promise<{ error?: Error }> => {
-      try {
-        await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
-          'postgres',
-          async (queryContext) => {
-            const entity = await PostgresTestEntity.loader(vc1, queryContext)
-              .enforcing()
-              .loadByIDAsync(firstEntity.getID());
-            await PostgresTestEntity.updater(entity, queryContext)
-              .setField('name', newName)
-              .enforceUpdateAsync();
-          },
-          { isolationLevel: TransactionIsolationLevel.SERIALIZABLE }
+        const firstEntity = await enforceAsyncResult(
+          PostgresTestEntity.creator(vc1).setField('name', 'hello').createAsync(),
         );
-        return {};
-      } catch (e) {
-        return { error: e as Error };
-      }
-    };
-
-    // do some parallel updates to trigger serializable error in at least some of them
-    const results = await Promise.all([
-      loadAndUpdateAsync('hello2'),
-      loadAndUpdateAsync('hello3'),
-      loadAndUpdateAsync('hello4'),
-      loadAndUpdateAsync('hello5'),
-    ]);
 
-    expect(results.filter((r) => (r.error as any)?.cause?.code === '40001').length > 0).toBe(true);
+        const loadAndUpdateAsync = async (
+          newName: string,
+          delay: number,
+        ): Promise<{ error?: Error }> => {
+          try {
+            await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+              'postgres',
+              async (queryContext) => {
+                const entity = await PostgresTestEntity.loader(vc1, queryContext)
+                  .enforcing()
+                  .loadByIDAsync(firstEntity.getID());
+                await setTimeout(delay);
+                await PostgresTestEntity.updater(entity, queryContext)
+                  .setField('name', entity.getField('name') + ',' + newName)
+                  .enforceUpdateAsync();
+              },
+              { isolationLevel },
+            );
+            return {};
+          } catch (e) {
+            return { error: e as Error };
+          }
+        };
+
+        // do some parallel updates to trigger serializable error in at least some of them
+        const results = await Promise.all([
+          loadAndUpdateAsync('hello2', 0),
+          loadAndUpdateAsync('hello3', 100),
+          loadAndUpdateAsync('hello4', 200),
+          loadAndUpdateAsync('hello5', 300),
+        ]);
+
+        if (isolationLevel === TransactionIsolationLevel.READ_COMMITTED) {
+          // read committed seems executes the transactions and doesn't produce a consistent result, but doesn't throw
+          expect(results.filter((r) => !!r.error).length > 0).toBe(false);
+        } else {
+          // all other isolation levels throw since they're doing nonrepeatable reads
+          expect(results.filter((r) => (r.error as any)?.cause?.code === '40001').length > 0).toBe(
+            true,
+          );
+        }
+      },
+    );
   });
 
   describe('JSON fields', () => {
@@ -216,13 +178,10 @@ describe('postgres entity integration', () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
       const entity = await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('stringArray', ['hello', 'world'])
           .setField('jsonArrayField', ['hello', 'world'])
-          .createAsync()
+          .createAsync(),
       );
 
       expect(entity.getField('stringArray')).toEqual(['hello', 'world']);
@@ -233,12 +192,9 @@ describe('postgres entity integration', () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
       const entity = await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('jsonObjectField', { hello: 'world' })
-          .createAsync()
+          .createAsync(),
       );
 
       expect(entity.getField('jsonObjectField')).toEqual({ hello: 'world' });
@@ -248,20 +204,14 @@ describe('postgres entity integration', () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
       const entity1 = await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('maybeJsonArrayField', ['hello', 'world'])
-          .createAsync()
+          .createAsync(),
       );
       const entity2 = await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('maybeJsonArrayField', { hello: 'world' })
-          .createAsync()
+          .createAsync(),
       );
 
       expect(entity1.getField('maybeJsonArrayField')).toEqual(['hello', 'world']);
@@ -274,32 +224,17 @@ describe('postgres entity integration', () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
       let entity = await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
-          .setField('bigintField', '72057594037928038')
-          .createAsync()
+        PostgresTestEntity.creator(vc1).setField('bigintField', '72057594037928038').createAsync(),
       );
       expect(entity.getField('bigintField')).toEqual('72057594037928038');
 
       entity = await enforceAsyncResult(
-        PostgresTestEntity.updater(
-          entity,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
-          .setField('bigintField', '10')
-          .updateAsync()
+        PostgresTestEntity.updater(entity).setField('bigintField', '10').updateAsync(),
       );
       expect(entity.getField('bigintField')).toEqual('10');
 
       entity = await enforceAsyncResult(
-        PostgresTestEntity.updater(
-          entity,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
-          .setField('bigintField', '-10')
-          .updateAsync()
+        PostgresTestEntity.updater(entity).setField('bigintField', '-10').updateAsync(),
       );
       expect(entity.getField('bigintField')).toEqual('-10');
     });
@@ -310,42 +245,30 @@ describe('postgres entity integration', () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'hello')
           .setField('hasACat', false)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'world')
           .setField('hasACat', false)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'wat')
           .setField('hasACat', false)
           .setField('hasADog', false)
-          .createAsync()
+          .createAsync(),
       );
 
-      const results = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const results = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByFieldEqualityConjunctionAsync([
           {
@@ -360,10 +283,7 @@ describe('postgres entity integration', () => {
 
       expect(results).toHaveLength(2);
 
-      const results2 = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const results2 = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByFieldEqualityConjunctionAsync([
           { fieldName: 'hasADog', fieldValues: [true, false] },
@@ -374,37 +294,13 @@ describe('postgres entity integration', () => {
     it('supports query modifiers', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
-      await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
-          .setField('name', 'a')
-          .createAsync()
-      );
+      await enforceAsyncResult(PostgresTestEntity.creator(vc1).setField('name', 'a').createAsync());
 
-      await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
-          .setField('name', 'b')
-          .createAsync()
-      );
+      await enforceAsyncResult(PostgresTestEntity.creator(vc1).setField('name', 'b').createAsync());
 
-      await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
-          .setField('name', 'c')
-          .createAsync()
-      );
+      await enforceAsyncResult(PostgresTestEntity.creator(vc1).setField('name', 'c').createAsync());
 
-      const results = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const results = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByFieldEqualityConjunctionAsync([], {
           limit: 2,
@@ -423,55 +319,37 @@ describe('postgres entity integration', () => {
     it('supports null field values', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'a')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'b')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', null)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', null)
           .setField('hasADog', false)
-          .createAsync()
+          .createAsync(),
       );
 
-      const results = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const results = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByFieldEqualityConjunctionAsync([{ fieldName: 'name', fieldValue: null }]);
       expect(results).toHaveLength(2);
       expect(results[0]!.getField('name')).toBeNull();
 
-      const results2 = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const results2 = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByFieldEqualityConjunctionAsync(
           [
@@ -485,7 +363,7 @@ describe('postgres entity integration', () => {
                 order: OrderByOrdering.DESCENDING,
               },
             ],
-          }
+          },
         );
       expect(results2).toHaveLength(2);
       expect(results2.map((e) => e.getField('name'))).toEqual([null, 'a']);
@@ -496,20 +374,14 @@ describe('postgres entity integration', () => {
     it('loads by raw where clause', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'hello')
           .setField('hasACat', false)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
-      const results = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const results = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByRawWhereClauseAsync('name = ?', ['hello']);
 
@@ -519,23 +391,17 @@ describe('postgres entity integration', () => {
     it('throws with invalid where clause', async () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'hello')
           .setField('hasACat', false)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await expect(
-        PostgresTestEntity.loader(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.loader(vc1)
           .enforcing()
-          .loadManyByRawWhereClauseAsync('invalid_column = ?', ['hello'])
+          .loadManyByRawWhereClauseAsync('invalid_column = ?', ['hello']),
       ).rejects.toThrow();
     });
 
@@ -543,39 +409,27 @@ describe('postgres entity integration', () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'a')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'b')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await enforceAsyncResult(
-        PostgresTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        PostgresTestEntity.creator(vc1)
           .setField('name', 'c')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
-      const results = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const results = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
           limit: 2,
@@ -591,10 +445,7 @@ describe('postgres entity integration', () => {
       expect(results).toHaveLength(2);
       expect(results.map((e) => e.getField('name'))).toEqual(['b', 'c']);
 
-      const resultsMultipleOrderBy = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const resultsMultipleOrderBy = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
           orderBy: [
@@ -612,10 +463,7 @@ describe('postgres entity integration', () => {
       expect(resultsMultipleOrderBy).toHaveLength(3);
       expect(resultsMultipleOrderBy.map((e) => e.getField('name'))).toEqual(['c', 'b', 'a']);
 
-      const resultsOrderByRaw = await PostgresTestEntity.loader(
-        vc1,
-        vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-      )
+      const resultsOrderByRaw = await PostgresTestEntity.loader(vc1)
         .enforcing()
         .loadManyByRawWhereClauseAsync('has_a_dog = ?', [true], {
           orderByRaw: 'has_a_dog ASC, name DESC',
@@ -630,92 +478,58 @@ describe('postgres entity integration', () => {
     describe('create', () => {
       it('rolls back transaction when trigger throws except afterCommit', async () => {
         const vc1 = new ViewerContext(
-          createKnexIntegrationTestEntityCompanionProvider(knexInstance)
+          createKnexIntegrationTestEntityCompanionProvider(knexInstance),
         );
 
         await expect(
-          PostgresTriggerTestEntity.creator(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.creator(vc1)
             .setField('name', 'beforeCreate')
-            .enforceCreateAsync()
+            .enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value beforeCreate');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeCreate')
+            .loadByFieldEqualingAsync('name', 'beforeCreate'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.creator(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.creator(vc1)
             .setField('name', 'afterCreate')
-            .enforceCreateAsync()
+            .enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value afterCreate');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterCreate')
+            .loadByFieldEqualingAsync('name', 'afterCreate'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.creator(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
-            .setField('name', 'beforeAll')
-            .enforceCreateAsync()
+          PostgresTriggerTestEntity.creator(vc1).setField('name', 'beforeAll').enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value beforeAll');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeAll')
+            .loadByFieldEqualingAsync('name', 'beforeAll'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.creator(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
-            .setField('name', 'afterAll')
-            .enforceCreateAsync()
+          PostgresTriggerTestEntity.creator(vc1).setField('name', 'afterAll').enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value afterAll');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterAll')
+            .loadByFieldEqualingAsync('name', 'afterAll'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.creator(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.creator(vc1)
             .setField('name', 'afterCommit')
-            .enforceCreateAsync()
+            .enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value afterCommit');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterCommit')
+            .loadByFieldEqualingAsync('name', 'afterCommit'),
         ).resolves.not.toBeNull();
       });
     });
@@ -723,99 +537,66 @@ describe('postgres entity integration', () => {
     describe('update', () => {
       it('rolls back transaction when trigger throws except afterCommit', async () => {
         const vc1 = new ViewerContext(
-          createKnexIntegrationTestEntityCompanionProvider(knexInstance)
+          createKnexIntegrationTestEntityCompanionProvider(knexInstance),
         );
 
-        const entity = await PostgresTriggerTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        const entity = await PostgresTriggerTestEntity.creator(vc1)
           .setField('name', 'blah')
           .enforceCreateAsync();
 
         await expect(
-          PostgresTriggerTestEntity.updater(
-            entity,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'beforeUpdate')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value beforeUpdate');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeUpdate')
+            .loadByFieldEqualingAsync('name', 'beforeUpdate'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.updater(
-            entity,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'afterUpdate')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value afterUpdate');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterUpdate')
+            .loadByFieldEqualingAsync('name', 'afterUpdate'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.updater(
-            entity,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'beforeAll')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value beforeAll');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeAll')
+            .loadByFieldEqualingAsync('name', 'beforeAll'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.updater(
-            entity,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'afterAll')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value afterAll');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterAll')
+            .loadByFieldEqualingAsync('name', 'afterAll'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.updater(
-            entity,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'afterCommit')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value afterCommit');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterCommit')
+            .loadByFieldEqualingAsync('name', 'afterCommit'),
         ).resolves.not.toBeNull();
       });
     });
@@ -823,49 +604,31 @@ describe('postgres entity integration', () => {
     describe('delete', () => {
       it('rolls back transaction when trigger throws except afterCommit', async () => {
         const vc1 = new ViewerContext(
-          createKnexIntegrationTestEntityCompanionProvider(knexInstance)
+          createKnexIntegrationTestEntityCompanionProvider(knexInstance),
         );
 
-        const entityBeforeDelete = await PostgresTriggerTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        const entityBeforeDelete = await PostgresTriggerTestEntity.creator(vc1)
           .setField('name', 'beforeDelete')
           .enforceCreateAsync();
         await expect(
-          PostgresTriggerTestEntity.enforceDeleteAsync(
-            entityBeforeDelete,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.enforceDeleteAsync(entityBeforeDelete),
         ).rejects.toThrowError('name cannot have value beforeDelete');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeDelete')
+            .loadByFieldEqualingAsync('name', 'beforeDelete'),
         ).resolves.not.toBeNull();
 
-        const entityAfterDelete = await PostgresTriggerTestEntity.creator(
-          vc1,
-          vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-        )
+        const entityAfterDelete = await PostgresTriggerTestEntity.creator(vc1)
           .setField('name', 'afterDelete')
           .enforceCreateAsync();
         await expect(
-          PostgresTriggerTestEntity.enforceDeleteAsync(
-            entityAfterDelete,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.enforceDeleteAsync(entityAfterDelete),
         ).rejects.toThrowError('name cannot have value afterDelete');
         await expect(
-          PostgresTriggerTestEntity.loader(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterDelete')
+            .loadByFieldEqualingAsync('name', 'afterDelete'),
         ).resolves.not.toBeNull();
       });
     });
@@ -873,81 +636,57 @@ describe('postgres entity integration', () => {
       describe('create', () => {
         it('rolls back transaction when trigger throws ', async () => {
           const vc1 = new ViewerContext(
-            createKnexIntegrationTestEntityCompanionProvider(knexInstance)
+            createKnexIntegrationTestEntityCompanionProvider(knexInstance),
           );
 
           await expect(
-            PostgresValidatorTestEntity.creator(
-              vc1,
-              vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-            )
+            PostgresValidatorTestEntity.creator(vc1)
               .setField('name', 'beforeCreateAndBeforeUpdate')
-              .enforceCreateAsync()
+              .enforceCreateAsync(),
           ).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
           await expect(
-            PostgresValidatorTestEntity.loader(
-              vc1,
-              vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-            )
+            PostgresValidatorTestEntity.loader(vc1)
               .enforcing()
-              .loadByFieldEqualingAsync('name', 'beforeCreateAndBeforeUpdate')
+              .loadByFieldEqualingAsync('name', 'beforeCreateAndBeforeUpdate'),
           ).resolves.toBeNull();
         });
       });
       describe('update', () => {
         it('rolls back transaction when trigger throws ', async () => {
           const vc1 = new ViewerContext(
-            createKnexIntegrationTestEntityCompanionProvider(knexInstance)
+            createKnexIntegrationTestEntityCompanionProvider(knexInstance),
           );
 
-          const entity = await PostgresValidatorTestEntity.creator(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          const entity = await PostgresValidatorTestEntity.creator(vc1)
             .setField('name', 'blah')
             .enforceCreateAsync();
 
           await expect(
-            PostgresValidatorTestEntity.updater(
-              entity,
-              vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-            )
+            PostgresValidatorTestEntity.updater(entity)
               .setField('name', 'beforeCreateAndBeforeUpdate')
-              .enforceUpdateAsync()
+              .enforceUpdateAsync(),
           ).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
           await expect(
-            PostgresValidatorTestEntity.loader(
-              vc1,
-              vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-            )
+            PostgresValidatorTestEntity.loader(vc1)
               .enforcing()
-              .loadByFieldEqualingAsync('name', 'beforeCreateAndBeforeUpdate')
+              .loadByFieldEqualingAsync('name', 'beforeCreateAndBeforeUpdate'),
           ).resolves.toBeNull();
         });
       });
       describe('delete', () => {
         it('validation should not run on a delete mutation', async () => {
           const vc1 = new ViewerContext(
-            createKnexIntegrationTestEntityCompanionProvider(knexInstance)
+            createKnexIntegrationTestEntityCompanionProvider(knexInstance),
           );
 
-          const entityToDelete = await PostgresValidatorTestEntity.creator(
-            vc1,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          )
+          const entityToDelete = await PostgresValidatorTestEntity.creator(vc1)
             .setField('name', 'shouldBeDeleted')
             .enforceCreateAsync();
-          await PostgresValidatorTestEntity.enforceDeleteAsync(
-            entityToDelete,
-            vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-          );
+          await PostgresValidatorTestEntity.enforceDeleteAsync(entityToDelete);
           await expect(
-            PostgresValidatorTestEntity.loader(
-              vc1,
-              vc1.getNonTransactionalQueryContextForDatabaseAdaptorFlavor('postgres')
-            )
+            PostgresValidatorTestEntity.loader(vc1)
               .enforcing()
-              .loadByFieldEqualingAsync('name', 'shouldBeDeleted')
+              .loadByFieldEqualingAsync('name', 'shouldBeDeleted'),
           ).resolves.toBeNull();
         });
       });
@@ -1002,7 +741,7 @@ describe('postgres entity integration', () => {
             preCommitCallCount++;
             throw Error('wat');
           }, 0);
-        })
+        }),
       ).rejects.toThrowError('wat');
 
       expect(preCommitCallCount).toBe(2);