@expo/entity-database-adapter-knex 0.43.0 → 0.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/entity-database-adapter-knex",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "description": "Knex database adapter for @expo/entity",
   "files": [
     "build",
@@ -28,24 +28,24 @@
   "author": "Expo",
   "license": "MIT",
   "dependencies": {
-    "@expo/entity": "^0.43.0",
+    "@expo/entity": "^0.45.0",
     "knex": "^3.1.0"
   },
   "devDependencies": {
-    "@expo/entity-testing-utils": "^0.43.0",
+    "@expo/entity-testing-utils": "^0.45.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": "618383027dc76b9250f22d163321ec25e2af0115"
+  "gitHead": "fe2d246f87adc98a13cc7c1ae57f3628769560c9"
 }

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

@@ -0,0 +1,223 @@
+import { createWithUniqueConstraintRecoveryAsync, ViewerContext } from '@expo/entity';
+import knex, { Knex } from 'knex';
+import nullthrows from 'nullthrows';
+
+import PostgresUniqueTestEntity from '../__testfixtures__/PostgresUniqueTestEntity';
+import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
+
+describe(createWithUniqueConstraintRecoveryAsync, () => {
+  let knexInstance: Knex;
+
+  beforeAll(() => {
+    knexInstance = knex({
+      client: 'pg',
+      connection: {
+        user: nullthrows(process.env['PGUSER']),
+        password: nullthrows(process.env['PGPASSWORD']),
+        host: 'localhost',
+        port: parseInt(nullthrows(process.env['PGPORT']), 10),
+        database: nullthrows(process.env['PGDATABASE']),
+      },
+    });
+  });
+
+  beforeEach(async () => {
+    await PostgresUniqueTestEntity.createOrTruncatePostgresTableAsync(knexInstance);
+  });
+
+  afterAll(async () => {
+    await PostgresUniqueTestEntity.dropPostgresTableAsync(knexInstance);
+    await knexInstance.destroy();
+  });
+
+  describe.each([true, false])('is parallel creations %p', (parallel) => {
+    it('recovers when the same entity is created twice outside of transaction', async () => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+      const args = {
+        name: 'unique',
+      };
+
+      let createdEntities: [PostgresUniqueTestEntity, PostgresUniqueTestEntity];
+      if (parallel) {
+        createdEntities = await Promise.all([
+          createWithUniqueConstraintRecoveryAsync(
+            vc1,
+            PostgresUniqueTestEntity,
+            PostgresUniqueTestEntity.getByNameAsync,
+            args,
+            PostgresUniqueTestEntity.createWithNameAsync,
+            args,
+          ),
+          createWithUniqueConstraintRecoveryAsync(
+            vc1,
+            PostgresUniqueTestEntity,
+            PostgresUniqueTestEntity.getByNameAsync,
+            args,
+            PostgresUniqueTestEntity.createWithNameAsync,
+            args,
+          ),
+        ]);
+      } else {
+        createdEntities = [
+          await createWithUniqueConstraintRecoveryAsync(
+            vc1,
+            PostgresUniqueTestEntity,
+            PostgresUniqueTestEntity.getByNameAsync,
+            args,
+            PostgresUniqueTestEntity.createWithNameAsync,
+            args,
+          ),
+          await createWithUniqueConstraintRecoveryAsync(
+            vc1,
+            PostgresUniqueTestEntity,
+            PostgresUniqueTestEntity.getByNameAsync,
+            args,
+            PostgresUniqueTestEntity.createWithNameAsync,
+            args,
+          ),
+        ];
+      }
+
+      expect(createdEntities[0].getID()).toEqual(createdEntities[1].getID());
+    });
+
+    it('recovers when the same entity is created twice within same transaction', async () => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+      const args = {
+        name: 'unique',
+      };
+
+      const createdEntities = await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          if (parallel) {
+            return await Promise.all([
+              createWithUniqueConstraintRecoveryAsync(
+                vc1,
+                PostgresUniqueTestEntity,
+                PostgresUniqueTestEntity.getByNameAsync,
+                args,
+                PostgresUniqueTestEntity.createWithNameAsync,
+                args,
+                queryContext,
+              ),
+              createWithUniqueConstraintRecoveryAsync(
+                vc1,
+                PostgresUniqueTestEntity,
+                PostgresUniqueTestEntity.getByNameAsync,
+                args,
+                PostgresUniqueTestEntity.createWithNameAsync,
+                args,
+                queryContext,
+              ),
+            ]);
+          } else {
+            return [
+              await createWithUniqueConstraintRecoveryAsync(
+                vc1,
+                PostgresUniqueTestEntity,
+                PostgresUniqueTestEntity.getByNameAsync,
+                args,
+                PostgresUniqueTestEntity.createWithNameAsync,
+                args,
+                queryContext,
+              ),
+              await createWithUniqueConstraintRecoveryAsync(
+                vc1,
+                PostgresUniqueTestEntity,
+                PostgresUniqueTestEntity.getByNameAsync,
+                args,
+                PostgresUniqueTestEntity.createWithNameAsync,
+                args,
+                queryContext,
+              ),
+            ];
+          }
+        },
+      );
+
+      expect(nullthrows(createdEntities[0]).getID()).toEqual(
+        nullthrows(createdEntities[1]).getID(),
+      );
+    });
+
+    it('recovers when the same entity is created twice within two transactions', async () => {
+      const vc1 = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+      const args = {
+        name: 'unique',
+      };
+
+      let createdEntities: [PostgresUniqueTestEntity, PostgresUniqueTestEntity];
+      if (parallel) {
+        createdEntities = await Promise.all([
+          await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+            'postgres',
+            async (queryContext) => {
+              return await createWithUniqueConstraintRecoveryAsync(
+                vc1,
+                PostgresUniqueTestEntity,
+                PostgresUniqueTestEntity.getByNameAsync,
+                args,
+                PostgresUniqueTestEntity.createWithNameAsync,
+                args,
+                queryContext,
+              );
+            },
+          ),
+          await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+            'postgres',
+            async (queryContext) => {
+              return await createWithUniqueConstraintRecoveryAsync(
+                vc1,
+                PostgresUniqueTestEntity,
+                PostgresUniqueTestEntity.getByNameAsync,
+                args,
+                PostgresUniqueTestEntity.createWithNameAsync,
+                args,
+                queryContext,
+              );
+            },
+          ),
+        ]);
+      } else {
+        createdEntities = [
+          await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+            'postgres',
+            async (queryContext) => {
+              return await createWithUniqueConstraintRecoveryAsync(
+                vc1,
+                PostgresUniqueTestEntity,
+                PostgresUniqueTestEntity.getByNameAsync,
+                args,
+                PostgresUniqueTestEntity.createWithNameAsync,
+                args,
+                queryContext,
+              );
+            },
+          ),
+          await vc1.runInTransactionForDatabaseAdaptorFlavorAsync(
+            'postgres',
+            async (queryContext) => {
+              return await createWithUniqueConstraintRecoveryAsync(
+                vc1,
+                PostgresUniqueTestEntity,
+                PostgresUniqueTestEntity.getByNameAsync,
+                args,
+                PostgresUniqueTestEntity.createWithNameAsync,
+                args,
+                queryContext,
+              );
+            },
+          ),
+        ];
+      }
+
+      expect(nullthrows(createdEntities[0]).getID()).toEqual(
+        nullthrows(createdEntities[1]).getID(),
+      );
+    });
+  });
+});

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));
 

package/src/__testfixtures__/PostgresUniqueTestEntity.ts

@@ -7,6 +7,7 @@ import {
   EntityCompanionDefinition,
   Entity,
   UUIDField,
+  EntityTransactionalQueryContext,
 } from '@expo/entity';
 import { Knex } from 'knex';
 
@@ -53,6 +54,27 @@ export default class PostgresUniqueTestEntity extends Entity<
       await knex.schema.dropTable(tableName);
     }
   }
+
+  public static async getByNameAsync(
+    viewerContext: ViewerContext,
+    args: { name: string },
+    queryContext?: EntityTransactionalQueryContext,
+  ): Promise<PostgresUniqueTestEntity | null> {
+    return await PostgresUniqueTestEntity.loader(
+      viewerContext,
+      queryContext,
+    ).loadByFieldEqualingAsync('name', args.name);
+  }
+
+  public static async createWithNameAsync(
+    viewerContext: ViewerContext,
+    args: { name: string },
+    queryContext?: EntityTransactionalQueryContext,
+  ): Promise<PostgresUniqueTestEntity> {
+    return await PostgresUniqueTestEntity.creator(viewerContext, queryContext)
+      .setField('name', args.name)
+      .createAsync();
+  }
 }
 
 class PostgresUniqueTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
@@ -108,6 +130,7 @@ export const postgresTestEntityConfiguration = new EntityConfiguration<
     }),
     name: new StringField({
       columnName: 'name',
+      cache: true,
     }),
   },
   databaseAdapterFlavor: 'postgres',