@expo/entity-database-adapter-knex 0.35.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,7 +42,7 @@ describe('postgres entity integration', () => {
   it('supports parallel partial updates', async () => {
     const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
     const entity = await enforceAsyncResult(
-      PostgresTestEntity.creator(vc).setField('name', 'hello').createAsync()
+      PostgresTestEntity.creator(vc).setField('name', 'hello').createAsync(),
     );
 
     // update two different fields at the same time (from the same entity)
@@ -69,7 +69,7 @@ describe('postgres entity integration', () => {
     it('throws knex error upon empty update', async () => {
       const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
       const entity = await enforceAsyncResult(
-        PostgresTestEntity.creator(vc).setField('name', 'hello').createAsync()
+        PostgresTestEntity.creator(vc).setField('name', 'hello').createAsync(),
       );
       await expect(PostgresTestEntity.updater(entity).updateAsync()).rejects.toThrow();
     });
@@ -77,7 +77,7 @@ describe('postgres entity integration', () => {
     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).setField('name', 'hello').createAsync()
+        PostgresTestEntity.creator(vc).setField('name', 'hello').createAsync(),
       );
       await expect(PostgresTestEntity.updater(entity).updateAsync()).rejects.toThrow();
     });
@@ -88,66 +88,89 @@ describe('postgres entity integration', () => {
 
     // put one in the DB
     const firstEntity = await enforceAsyncResult(
-      PostgresTestEntity.creator(vc1).setField('name', 'hello').createAsync()
+      PostgresTestEntity.creator(vc1).setField('name', 'hello').createAsync(),
     );
 
-    await enforceAsyncResult(PostgresTestEntity.loader(vc1).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).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).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', () => {
@@ -158,7 +181,7 @@ describe('postgres entity integration', () => {
         PostgresTestEntity.creator(vc1)
           .setField('stringArray', ['hello', 'world'])
           .setField('jsonArrayField', ['hello', 'world'])
-          .createAsync()
+          .createAsync(),
       );
 
       expect(entity.getField('stringArray')).toEqual(['hello', 'world']);
@@ -171,7 +194,7 @@ describe('postgres entity integration', () => {
       const entity = await enforceAsyncResult(
         PostgresTestEntity.creator(vc1)
           .setField('jsonObjectField', { hello: 'world' })
-          .createAsync()
+          .createAsync(),
       );
 
       expect(entity.getField('jsonObjectField')).toEqual({ hello: 'world' });
@@ -183,12 +206,12 @@ describe('postgres entity integration', () => {
       const entity1 = await enforceAsyncResult(
         PostgresTestEntity.creator(vc1)
           .setField('maybeJsonArrayField', ['hello', 'world'])
-          .createAsync()
+          .createAsync(),
       );
       const entity2 = await enforceAsyncResult(
         PostgresTestEntity.creator(vc1)
           .setField('maybeJsonArrayField', { hello: 'world' })
-          .createAsync()
+          .createAsync(),
       );
 
       expect(entity1.getField('maybeJsonArrayField')).toEqual(['hello', 'world']);
@@ -201,17 +224,17 @@ describe('postgres entity integration', () => {
       const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
 
       let entity = await enforceAsyncResult(
-        PostgresTestEntity.creator(vc1).setField('bigintField', '72057594037928038').createAsync()
+        PostgresTestEntity.creator(vc1).setField('bigintField', '72057594037928038').createAsync(),
       );
       expect(entity.getField('bigintField')).toEqual('72057594037928038');
 
       entity = await enforceAsyncResult(
-        PostgresTestEntity.updater(entity).setField('bigintField', '10').updateAsync()
+        PostgresTestEntity.updater(entity).setField('bigintField', '10').updateAsync(),
       );
       expect(entity.getField('bigintField')).toEqual('10');
 
       entity = await enforceAsyncResult(
-        PostgresTestEntity.updater(entity).setField('bigintField', '-10').updateAsync()
+        PostgresTestEntity.updater(entity).setField('bigintField', '-10').updateAsync(),
       );
       expect(entity.getField('bigintField')).toEqual('-10');
     });
@@ -226,7 +249,7 @@ describe('postgres entity integration', () => {
           .setField('name', 'hello')
           .setField('hasACat', false)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await enforceAsyncResult(
@@ -234,7 +257,7 @@ describe('postgres entity integration', () => {
           .setField('name', 'world')
           .setField('hasACat', false)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await enforceAsyncResult(
@@ -242,7 +265,7 @@ describe('postgres entity integration', () => {
           .setField('name', 'wat')
           .setField('hasACat', false)
           .setField('hasADog', false)
-          .createAsync()
+          .createAsync(),
       );
 
       const results = await PostgresTestEntity.loader(vc1)
@@ -299,25 +322,25 @@ describe('postgres entity integration', () => {
         PostgresTestEntity.creator(vc1)
           .setField('name', 'a')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
       await enforceAsyncResult(
         PostgresTestEntity.creator(vc1)
           .setField('name', 'b')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
       await enforceAsyncResult(
         PostgresTestEntity.creator(vc1)
           .setField('name', null)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
       await enforceAsyncResult(
         PostgresTestEntity.creator(vc1)
           .setField('name', null)
           .setField('hasADog', false)
-          .createAsync()
+          .createAsync(),
       );
 
       const results = await PostgresTestEntity.loader(vc1)
@@ -340,7 +363,7 @@ describe('postgres entity integration', () => {
                 order: OrderByOrdering.DESCENDING,
               },
             ],
-          }
+          },
         );
       expect(results2).toHaveLength(2);
       expect(results2.map((e) => e.getField('name'))).toEqual([null, 'a']);
@@ -355,7 +378,7 @@ describe('postgres entity integration', () => {
           .setField('name', 'hello')
           .setField('hasACat', false)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       const results = await PostgresTestEntity.loader(vc1)
@@ -372,13 +395,13 @@ describe('postgres entity integration', () => {
           .setField('name', 'hello')
           .setField('hasACat', false)
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await expect(
         PostgresTestEntity.loader(vc1)
           .enforcing()
-          .loadManyByRawWhereClauseAsync('invalid_column = ?', ['hello'])
+          .loadManyByRawWhereClauseAsync('invalid_column = ?', ['hello']),
       ).rejects.toThrow();
     });
 
@@ -389,21 +412,21 @@ describe('postgres entity integration', () => {
         PostgresTestEntity.creator(vc1)
           .setField('name', 'a')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await enforceAsyncResult(
         PostgresTestEntity.creator(vc1)
           .setField('name', 'b')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       await enforceAsyncResult(
         PostgresTestEntity.creator(vc1)
           .setField('name', 'c')
           .setField('hasADog', true)
-          .createAsync()
+          .createAsync(),
       );
 
       const results = await PostgresTestEntity.loader(vc1)
@@ -455,58 +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)
             .setField('name', 'beforeCreate')
-            .enforceCreateAsync()
+            .enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value beforeCreate');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeCreate')
+            .loadByFieldEqualingAsync('name', 'beforeCreate'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.creator(vc1)
             .setField('name', 'afterCreate')
-            .enforceCreateAsync()
+            .enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value afterCreate');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterCreate')
+            .loadByFieldEqualingAsync('name', 'afterCreate'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.creator(vc1).setField('name', 'beforeAll').enforceCreateAsync()
+          PostgresTriggerTestEntity.creator(vc1).setField('name', 'beforeAll').enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value beforeAll');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeAll')
+            .loadByFieldEqualingAsync('name', 'beforeAll'),
         ).resolves.toBeNull();
 
         await expect(
-          PostgresTriggerTestEntity.creator(vc1).setField('name', 'afterAll').enforceCreateAsync()
+          PostgresTriggerTestEntity.creator(vc1).setField('name', 'afterAll').enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value afterAll');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterAll')
+            .loadByFieldEqualingAsync('name', 'afterAll'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.creator(vc1)
             .setField('name', 'afterCommit')
-            .enforceCreateAsync()
+            .enforceCreateAsync(),
         ).rejects.toThrowError('name cannot have value afterCommit');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterCommit')
+            .loadByFieldEqualingAsync('name', 'afterCommit'),
         ).resolves.not.toBeNull();
       });
     });
@@ -514,7 +537,7 @@ 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)
@@ -524,56 +547,56 @@ describe('postgres entity integration', () => {
         await expect(
           PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'beforeUpdate')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value beforeUpdate');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeUpdate')
+            .loadByFieldEqualingAsync('name', 'beforeUpdate'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'afterUpdate')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value afterUpdate');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterUpdate')
+            .loadByFieldEqualingAsync('name', 'afterUpdate'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'beforeAll')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value beforeAll');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeAll')
+            .loadByFieldEqualingAsync('name', 'beforeAll'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'afterAll')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value afterAll');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterAll')
+            .loadByFieldEqualingAsync('name', 'afterAll'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.updater(entity)
             .setField('name', 'afterCommit')
-            .enforceUpdateAsync()
+            .enforceUpdateAsync(),
         ).rejects.toThrowError('name cannot have value afterCommit');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterCommit')
+            .loadByFieldEqualingAsync('name', 'afterCommit'),
         ).resolves.not.toBeNull();
       });
     });
@@ -581,31 +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)
           .setField('name', 'beforeDelete')
           .enforceCreateAsync();
         await expect(
-          PostgresTriggerTestEntity.enforceDeleteAsync(entityBeforeDelete)
+          PostgresTriggerTestEntity.enforceDeleteAsync(entityBeforeDelete),
         ).rejects.toThrowError('name cannot have value beforeDelete');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'beforeDelete')
+            .loadByFieldEqualingAsync('name', 'beforeDelete'),
         ).resolves.not.toBeNull();
 
         const entityAfterDelete = await PostgresTriggerTestEntity.creator(vc1)
           .setField('name', 'afterDelete')
           .enforceCreateAsync();
         await expect(
-          PostgresTriggerTestEntity.enforceDeleteAsync(entityAfterDelete)
+          PostgresTriggerTestEntity.enforceDeleteAsync(entityAfterDelete),
         ).rejects.toThrowError('name cannot have value afterDelete');
         await expect(
           PostgresTriggerTestEntity.loader(vc1)
             .enforcing()
-            .loadByFieldEqualingAsync('name', 'afterDelete')
+            .loadByFieldEqualingAsync('name', 'afterDelete'),
         ).resolves.not.toBeNull();
       });
     });
@@ -613,25 +636,25 @@ 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)
               .setField('name', 'beforeCreateAndBeforeUpdate')
-              .enforceCreateAsync()
+              .enforceCreateAsync(),
           ).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
           await expect(
             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)
@@ -641,19 +664,19 @@ describe('postgres entity integration', () => {
           await expect(
             PostgresValidatorTestEntity.updater(entity)
               .setField('name', 'beforeCreateAndBeforeUpdate')
-              .enforceUpdateAsync()
+              .enforceUpdateAsync(),
           ).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
           await expect(
             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)
@@ -663,7 +686,7 @@ describe('postgres entity integration', () => {
           await expect(
             PostgresValidatorTestEntity.loader(vc1)
               .enforcing()
-              .loadByFieldEqualingAsync('name', 'shouldBeDeleted')
+              .loadByFieldEqualingAsync('name', 'shouldBeDeleted'),
           ).resolves.toBeNull();
         });
       });
@@ -718,7 +741,7 @@ describe('postgres entity integration', () => {
             preCommitCallCount++;
             throw Error('wat');
           }, 0);
-        })
+        }),
       ).rejects.toThrowError('wat');
 
       expect(preCommitCallCount).toBe(2);

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

@@ -35,40 +35,40 @@ describe('postgres entity integration', () => {
     it('throws after deletion of multiple rows or no rows', async () => {
       const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
       const entity1 = await enforceAsyncResult(
-        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'hello').createAsync()
+        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'hello').createAsync(),
       );
       await enforceAsyncResult(
-        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'world').createAsync()
+        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'world').createAsync(),
       );
 
       await expect(InvalidTestEntity.deleteAsync(entity1)).rejects.toThrowError(
-        'Excessive deletions from database adapter delete'
+        'Excessive deletions from database adapter delete',
       );
     });
 
     it('throws after update of multiple rows', async () => {
       const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
       const entity1 = await enforceAsyncResult(
-        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'hello').createAsync()
+        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'hello').createAsync(),
       );
       await enforceAsyncResult(
-        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'world').createAsync()
+        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'world').createAsync(),
       );
 
       await expect(
-        InvalidTestEntity.updater(entity1).setField('name', 'blah').enforceUpdateAsync()
+        InvalidTestEntity.updater(entity1).setField('name', 'blah').enforceUpdateAsync(),
       ).rejects.toThrowError('Excessive results from database adapter update');
     });
 
     it('throws after update of no rows', async () => {
       const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
       const entity1 = await enforceAsyncResult(
-        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'hello').createAsync()
+        InvalidTestEntity.creator(vc).setField('id', 1).setField('name', 'hello').createAsync(),
       );
       await InvalidTestEntity.deleteAsync(entity1);
 
       await expect(
-        InvalidTestEntity.updater(entity1).setField('name', 'blah').enforceUpdateAsync()
+        InvalidTestEntity.updater(entity1).setField('name', 'blah').enforceUpdateAsync(),
       ).rejects.toThrowError('Empty results from database adapter update');
     });
   });