@expo/entity-database-adapter-knex 0.42.0 → 0.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/entity-database-adapter-knex",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "description": "Knex database adapter for @expo/entity",
   "files": [
     "build",
@@ -28,24 +28,24 @@
   "author": "Expo",
   "license": "MIT",
   "dependencies": {
-    "@expo/entity": "^0.42.0",
+    "@expo/entity": "^0.44.0",
     "knex": "^3.1.0"
   },
   "devDependencies": {
-    "@expo/entity-testing-utils": "^0.42.0",
+    "@expo/entity-testing-utils": "^0.44.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^20.14.1",
     "ctix": "^2.7.0",
-    "eslint": "^8.57.1",
-    "eslint-config-universe": "^14.0.0",
-    "eslint-plugin-tsdoc": "^0.3.0",
+    "eslint": "^9.26.0",
+    "eslint-config-universe": "^15.0.3",
+    "eslint-plugin-tsdoc": "^0.4.0",
     "jest": "^29.7.0",
     "pg": "8.14.1",
-    "prettier": "^3.3.3",
+    "prettier": "^3.5.3",
     "prettier-plugin-organize-imports": "^4.1.0",
-    "ts-jest": "^29.3.1",
+    "ts-jest": "^29.3.2",
     "ts-mockito": "^2.6.1",
     "typescript": "^5.8.3"
   },
-  "gitHead": "8414d96d948882735687da146e84913397cd8368"
+  "gitHead": "b9b09933e5a5b02037aa4688c5969705a29995c0"
 }

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

@@ -1,4 +1,4 @@
-import { ViewerContext } from '@expo/entity';
+import { TransactionalDataLoaderMode, ViewerContext } from '@expo/entity';
 import { knex, Knex } from 'knex';
 import nullthrows from 'nullthrows';
 
@@ -47,7 +47,7 @@ describe(PostgresEntityQueryContextProvider, () => {
         .updateAsync();
 
       // ensure the outer transaction is not aborted due to postgres error in inner transaction,
-      // in this case the error triggered is a unique constraint violation
+      // in this case the error triggered is a unique constraint violation from a conflict with the first entity created above
       try {
         await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
           const entity = await PostgresUniqueTestEntity.loader(
@@ -70,6 +70,360 @@ describe(PostgresEntityQueryContextProvider, () => {
     expect(entityLoaded.getField('name')).toEqual('wat3');
   });
 
+  test('dataloader consistency with nested transactions', async () => {
+    const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+    // put it in local dataloader
+    const entity = await PostgresUniqueTestEntity.creator(vc1)
+      .setField('name', 'who')
+      .createAsync();
+    const entityLoaded = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(entity.getID());
+    expect(entityLoaded.getField('name')).toEqual('who');
+
+    await vc1.runInTransactionForDatabaseAdaptorFlavorAsync('postgres', async (queryContext) => {
+      const entityLoadedOuter = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(
+        entity.getID(),
+      );
+      expect(entityLoadedOuter.getField('name')).toEqual('who');
+
+      await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+        const entityLoadedInner = await PostgresUniqueTestEntity.loader(
+          vc1,
+          innerQueryContext,
+        ).loadByIDAsync(entity.getID());
+        const updatedEntity = await PostgresUniqueTestEntity.updater(
+          entityLoadedInner,
+          innerQueryContext,
+        )
+          .setField('name', 'wat')
+          .updateAsync();
+        expect(updatedEntity.getField('name')).toEqual('wat');
+      });
+
+      const entityLoadedAfterNested = await PostgresUniqueTestEntity.loader(
+        vc1,
+        queryContext,
+      ).loadByIDAsync(entity.getID());
+      expect(entityLoadedAfterNested.getField('name')).toEqual('wat');
+    });
+
+    const entityLoadedAfterTransaction = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(
+      entity.getID(),
+    );
+    expect(entityLoadedAfterTransaction.getField('name')).toEqual('wat');
+  });
+
+  test('dataloader consistency with nested transactions that throw', async () => {
+    const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+    // put it in local dataloader
+    const entity = await PostgresUniqueTestEntity.creator(vc1)
+      .setField('name', 'who')
+      .createAsync();
+    const entityLoaded = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(entity.getID());
+    expect(entityLoaded.getField('name')).toEqual('who');
+
+    await vc1.runInTransactionForDatabaseAdaptorFlavorAsync('postgres', async (queryContext) => {
+      const entityLoadedOuter = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(
+        entity.getID(),
+      );
+      expect(entityLoadedOuter.getField('name')).toEqual('who');
+
+      try {
+        await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+          const entityLoadedInner = await PostgresUniqueTestEntity.loader(
+            vc1,
+            innerQueryContext,
+          ).loadByIDAsync(entity.getID());
+          const updatedEntity = await PostgresUniqueTestEntity.updater(
+            entityLoadedInner,
+            innerQueryContext,
+          )
+            .setField('name', 'wat')
+            .updateAsync();
+          expect(updatedEntity.getField('name')).toEqual('wat');
+          throw new Error('wat');
+        });
+      } catch {}
+
+      const entityLoadedAfterNested = await PostgresUniqueTestEntity.loader(
+        vc1,
+        queryContext,
+      ).loadByIDAsync(entity.getID());
+      expect(entityLoadedAfterNested.getField('name')).toEqual('who');
+    });
+
+    const entityLoadedAfterTransaction = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(
+      entity.getID(),
+    );
+    expect(entityLoadedAfterTransaction.getField('name')).toEqual('who');
+  });
+
+  test('dataloader consistency with concurrent loads outside of transaction', async () => {
+    const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+    // put it in local dataloader
+    const entity = await PostgresUniqueTestEntity.creator(vc1)
+      .setField('name', 'who')
+      .createAsync();
+    const entityLoaded = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(entity.getID());
+    expect(entityLoaded.getField('name')).toEqual('who');
+
+    let openBarrier1: () => void;
+    const barrier1 = new Promise<void>((resolve) => {
+      openBarrier1 = resolve;
+    });
+
+    let openBarrier2: () => void;
+    const barrier2 = new Promise<void>((resolve) => {
+      openBarrier2 = resolve;
+    });
+
+    await Promise.all([
+      vc1.runInTransactionForDatabaseAdaptorFlavorAsync('postgres', async (queryContext) => {
+        const entityLoadedOuter = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(
+          entity.getID(),
+        );
+        expect(entityLoadedOuter.getField('name')).toEqual('who');
+
+        await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+          const entityLoadedInner = await PostgresUniqueTestEntity.loader(
+            vc1,
+            innerQueryContext,
+          ).loadByIDAsync(entity.getID());
+          const updatedEntity = await PostgresUniqueTestEntity.updater(
+            entityLoadedInner,
+            innerQueryContext,
+          )
+            .setField('name', 'wat')
+            .updateAsync();
+          expect(updatedEntity.getField('name')).toEqual('wat');
+          const entityLoadedAfterUpdate = await PostgresUniqueTestEntity.loader(
+            vc1,
+            innerQueryContext,
+          ).loadByIDAsync(entity.getID());
+          expect(entityLoadedAfterUpdate.getField('name')).toEqual('wat');
+        });
+        openBarrier1();
+        await barrier2;
+      }),
+      (async () => {
+        await barrier1;
+
+        const entityLoadedOutsideOfTransactionsBeforeNestedCommit =
+          await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(entity.getID());
+        expect(entityLoadedOutsideOfTransactionsBeforeNestedCommit.getField('name')).toEqual('who');
+        openBarrier2!();
+      })(),
+    ]);
+
+    const entityLoadedAfterTransaction = await PostgresUniqueTestEntity.loader(vc1).loadByIDAsync(
+      entity.getID(),
+    );
+    expect(entityLoadedAfterTransaction.getField('name')).toEqual('wat');
+  });
+
+  test('consistent behavior with and without transactional dataloader for concurrent loads outside of nested transaction', async () => {
+    // Subtransactions are not supported in postgres. See #194 for more info.
+    // Instead, savepoints and rollbacks are used to simulate subtransactions, which results in non-isolated read semantics.
+    //
+    // This test tests the same behavior exists whether there is a dataloader or not in transactions, thus indicating that
+    // the dataloader invalidation is not the issue.
+
+    const runTest = async (
+      transactionalDataLoaderMode: TransactionalDataLoaderMode,
+    ): Promise<void> => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+      await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (outerQueryContext) => {
+          // put it in local dataloader
+          const entity = await PostgresUniqueTestEntity.creator(vc1, outerQueryContext)
+            .setField('name', 'who')
+            .createAsync();
+          const entityLoaded = await PostgresUniqueTestEntity.loader(
+            vc1,
+            outerQueryContext,
+          ).loadByIDAsync(entity.getID());
+          if (entityLoaded.getField('name') !== 'who') {
+            throw new Error('entity loaded wrong value');
+          }
+
+          let openBarrier1: () => void;
+          const barrier1 = new Promise<void>((resolve) => {
+            openBarrier1 = resolve;
+          });
+
+          let openBarrier2: () => void;
+          const barrier2 = new Promise<void>((resolve) => {
+            openBarrier2 = resolve;
+          });
+
+          await Promise.all([
+            outerQueryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+              const entityLoadedInner = await PostgresUniqueTestEntity.loader(
+                vc1,
+                innerQueryContext,
+              ).loadByIDAsync(entity.getID());
+              const updatedEntity = await PostgresUniqueTestEntity.updater(
+                entityLoadedInner,
+                innerQueryContext,
+              )
+                .setField('name', 'wat')
+                .updateAsync();
+              if (updatedEntity.getField('name') !== 'wat') {
+                throw new Error('entity updated wrong value');
+              }
+
+              const entityLoadedAfterUpdate = await PostgresUniqueTestEntity.loader(
+                vc1,
+                innerQueryContext,
+              ).loadByIDAsync(entity.getID());
+              if (entityLoadedAfterUpdate.getField('name') !== 'wat') {
+                throw new Error('entity loaded wrong value after update');
+              }
+              openBarrier1();
+              await barrier2;
+            }),
+            (async () => {
+              await barrier1;
+
+              // if postgres supported nested transactions, this would read isolated from the nested transaction above
+              // but since it doesn't, this will read the updated value.
+              const entityLoadedInOuterTransactionBeforeNestedCommit =
+                await PostgresUniqueTestEntity.loader(vc1, outerQueryContext).loadByIDAsync(
+                  entity.getID(),
+                );
+              if (entityLoadedInOuterTransactionBeforeNestedCommit.getField('name') !== 'who') {
+                throw new Error('outer transaction read wrong value');
+              }
+
+              openBarrier2!();
+            })(),
+          ]);
+
+          const entityLoadedAfterTransaction = await PostgresUniqueTestEntity.loader(
+            vc1,
+            outerQueryContext,
+          ).loadByIDAsync(entity.getID());
+          if (entityLoadedAfterTransaction.getField('name') !== 'wat') {
+            throw new Error('entity loaded wrong value after transaction');
+          }
+        },
+        { transactionalDataLoaderMode },
+      );
+    };
+
+    await expect(runTest(TransactionalDataLoaderMode.DISABLED)).rejects.toThrow(
+      'outer transaction read wrong value',
+    );
+    await expect(runTest(TransactionalDataLoaderMode.ENABLED)).rejects.toThrow(
+      'outer transaction read wrong value',
+    );
+    await expect(runTest(TransactionalDataLoaderMode.ENABLED_BATCH_ONLY)).rejects.toThrow(
+      'outer transaction read wrong value',
+    );
+  });
+
+  test('consistent behavior with and without transactional dataloader for concurrent mutations outside of nested transaction that reads', async () => {
+    // this test has a similar issue to the one above: absence of real nested transactions in postgres
+    // this should have the same behavior no matter if there is a dataloader or not in transactions
+
+    const runTest = async (
+      transactionalDataLoaderMode: TransactionalDataLoaderMode,
+    ): Promise<void> => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+      await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (outerQueryContext) => {
+          // put it in local dataloader
+          const entity = await PostgresUniqueTestEntity.creator(vc1, outerQueryContext)
+            .setField('name', 'who')
+            .createAsync();
+          const entityLoaded = await PostgresUniqueTestEntity.loader(
+            vc1,
+            outerQueryContext,
+          ).loadByIDAsync(entity.getID());
+          if (entityLoaded.getField('name') !== 'who') {
+            throw new Error('entity loaded wrong value');
+          }
+
+          let openBarrier1: () => void;
+          const barrier1 = new Promise<void>((resolve) => {
+            openBarrier1 = resolve;
+          });
+
+          let openBarrier2: () => void;
+          const barrier2 = new Promise<void>((resolve) => {
+            openBarrier2 = resolve;
+          });
+
+          await Promise.all([
+            (async () => {
+              await barrier1;
+
+              const entityLoadedOuterAgain = await PostgresUniqueTestEntity.loader(
+                vc1,
+                outerQueryContext,
+              ).loadByIDAsync(entity.getID());
+              const updatedEntity = await PostgresUniqueTestEntity.updater(
+                entityLoadedOuterAgain,
+                outerQueryContext,
+              )
+                .setField('name', 'wat')
+                .updateAsync();
+              if (updatedEntity.getField('name') !== 'wat') {
+                throw new Error('entity updated wrong value');
+              }
+
+              openBarrier2!();
+            })(),
+
+            outerQueryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
+              const entityLoadedInner = await PostgresUniqueTestEntity.loader(
+                vc1,
+                innerQueryContext,
+              ).loadByIDAsync(entity.getID());
+              if (entityLoadedInner.getField('name') !== 'who') {
+                throw new Error('entity loaded inner wrong value 1');
+              }
+
+              openBarrier1();
+              await barrier2;
+
+              const entityLoadedInnerAgain = await PostgresUniqueTestEntity.loader(
+                vc1,
+                innerQueryContext,
+              ).loadByIDAsync(entity.getID());
+              if (entityLoadedInnerAgain.getField('name') !== 'who') {
+                throw new Error('entity loaded inner wrong value 2');
+              }
+            }),
+          ]);
+
+          const entityLoadedAfterTransaction = await PostgresUniqueTestEntity.loader(
+            vc1,
+            outerQueryContext,
+          ).loadByIDAsync(entity.getID());
+          if (entityLoadedAfterTransaction.getField('name') !== 'wat') {
+            throw new Error('entity loaded wrong value after transaction');
+          }
+        },
+        { transactionalDataLoaderMode },
+      );
+    };
+
+    await expect(runTest(TransactionalDataLoaderMode.DISABLED)).rejects.toThrow(
+      'entity loaded inner wrong value 2',
+    );
+    await expect(runTest(TransactionalDataLoaderMode.ENABLED)).rejects.toThrow(
+      'entity loaded inner wrong value 2',
+    );
+    await expect(runTest(TransactionalDataLoaderMode.ENABLED_BATCH_ONLY)).rejects.toThrow(
+      'entity loaded inner wrong value 2',
+    );
+  });
+
   it('supports multi-nested transactions', async () => {
     const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));