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

package/package.json

@@ -1,23 +1,20 @@
 {
   "name": "@expo/entity-database-adapter-knex",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "description": "Knex database adapter for @expo/entity",
   "files": [
     "build",
     "src"
   ],
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
+  "main": "build/src/index.js",
+  "types": "build/src/index.d.ts",
   "scripts": {
-    "tsc": "tsc",
-    "build": "tsc -b tsconfig.build.json",
-    "clean": "rm -rf build coverage coverage-integration",
-    "lint": "eslint src",
-    "lint-fix": "eslint src --fix",
-    "test": "jest --rootDir . --config ../../resources/jest.config.js --passWithNoTests",
-    "integration": "../../resources/run-with-docker yarn integration-no-setup",
-    "integration-no-setup": "jest --config ../../resources/jest-integration.config.js --rootDir . --runInBand --passWithNoTests",
-    "ctix": "ctix build --config ../../.ctirc && ../../resources/prepend-barrel.sh '@expo/entity-database-adapter-knex'"
+    "build": "tsc --build",
+    "clean": "yarn build --clean",
+    "lint": "yarn run --top-level eslint src",
+    "lint-fix": "yarn lint --fix",
+    "test": "yarn test:all --rootDir $(pwd)",
+    "integration": "yarn integration:all --rootDir $(pwd)"
   },
   "engines": {
     "node": ">=16"
@@ -28,24 +25,14 @@
   "author": "Expo",
   "license": "MIT",
   "dependencies": {
-    "@expo/entity": "^0.44.0",
+    "@expo/entity": "^0.46.0",
     "knex": "^3.1.0"
   },
   "devDependencies": {
-    "@expo/entity-testing-utils": "^0.44.0",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^20.14.1",
-    "ctix": "^2.7.0",
-    "eslint": "^9.26.0",
-    "eslint-config-universe": "^15.0.3",
-    "eslint-plugin-tsdoc": "^0.4.0",
-    "jest": "^29.7.0",
+    "@expo/entity-testing-utils": "^0.46.0",
+    "@jest/globals": "^30.0.0",
     "pg": "8.14.1",
-    "prettier": "^3.5.3",
-    "prettier-plugin-organize-imports": "^4.1.0",
-    "ts-jest": "^29.3.2",
-    "ts-mockito": "^2.6.1",
     "typescript": "^5.8.3"
   },
-  "gitHead": "b9b09933e5a5b02037aa4688c5969705a29995c0"
+  "gitHead": "79f61f8d7f7f024e4e9a557473a5737eedb3ffe6"
 }

package/src/PostgresEntityDatabaseAdapter.ts

@@ -1,18 +1,18 @@
 import {
   EntityDatabaseAdapter,
-  FieldTransformerMap,
   FieldTransformer,
-  TableQuerySelectionModifiers,
-  TableFieldSingleValueEqualityCondition,
+  FieldTransformerMap,
   TableFieldMultiValueEqualityCondition,
+  TableFieldSingleValueEqualityCondition,
+  TableQuerySelectionModifiers,
   TableQuerySelectionModifiersWithOrderByRaw,
 } from '@expo/entity';
 import { Knex } from 'knex';
 
 import { JSONArrayField, MaybeJSONArrayField } from './EntityFields';
-import wrapNativePostgresCallAsync from './errors/wrapNativePostgresCallAsync';
+import { wrapNativePostgresCallAsync } from './errors/wrapNativePostgresCallAsync';
 
-export default class PostgresEntityDatabaseAdapter<
+export class PostgresEntityDatabaseAdapter<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
 > extends EntityDatabaseAdapter<TFields, TIDField> {

package/src/PostgresEntityDatabaseAdapterProvider.ts

@@ -1,14 +1,12 @@
 import {
-  IEntityDatabaseAdapterProvider,
   EntityConfiguration,
   EntityDatabaseAdapter,
+  IEntityDatabaseAdapterProvider,
 } from '@expo/entity';
 
-import PostgresEntityDatabaseAdapter from './PostgresEntityDatabaseAdapter';
+import { PostgresEntityDatabaseAdapter } from './PostgresEntityDatabaseAdapter';
 
-export default class PostgresEntityDatabaseAdapterProvider
-  implements IEntityDatabaseAdapterProvider
-{
+export class PostgresEntityDatabaseAdapterProvider implements IEntityDatabaseAdapterProvider {
   getDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
     entityConfiguration: EntityConfiguration<TFields, TIDField>,
   ): EntityDatabaseAdapter<TFields, TIDField> {

package/src/PostgresEntityQueryContextProvider.ts

@@ -8,7 +8,7 @@ import { Knex } from 'knex';
 /**
  * Query context provider for knex (postgres).
  */
-export default class PostgresEntityQueryContextProvider extends EntityQueryContextProvider {
+export class PostgresEntityQueryContextProvider extends EntityQueryContextProvider {
   constructor(private readonly knexInstance: Knex) {
     super();
   }

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

@@ -0,0 +1,224 @@
+import { createWithUniqueConstraintRecoveryAsync, ViewerContext } from '@expo/entity';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
+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__/PostgresEntityIntegration-test.ts

@@ -1,13 +1,14 @@
-import { OrderByOrdering, ViewerContext, TransactionIsolationLevel } from '@expo/entity';
+import { OrderByOrdering, TransactionIsolationLevel, ViewerContext } from '@expo/entity';
 import { createUnitTestEntityCompanionProvider } from '@expo/entity-testing-utils';
 import { enforceAsyncResult } from '@expo/results';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, test } from '@jest/globals';
 import { knex, Knex } from 'knex';
 import nullthrows from 'nullthrows';
 import { setTimeout } from 'timers/promises';
 
-import PostgresTestEntity from '../__testfixtures__/PostgresTestEntity';
-import PostgresTriggerTestEntity from '../__testfixtures__/PostgresTriggerTestEntity';
-import PostgresValidatorTestEntity from '../__testfixtures__/PostgresValidatorTestEntity';
+import { PostgresTestEntity } from '../__testfixtures__/PostgresTestEntity';
+import { PostgresTriggerTestEntity } from '../__testfixtures__/PostgresTriggerTestEntity';
+import { PostgresValidatorTestEntity } from '../__testfixtures__/PostgresValidatorTestEntity';
 import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
 
 describe('postgres entity integration', () => {
@@ -561,35 +562,35 @@ describe('postgres entity integration', () => {
 
         await expect(
           PostgresTriggerTestEntity.creator(vc1).setField('name', 'beforeCreate').createAsync(),
-        ).rejects.toThrowError('name cannot have value beforeCreate');
+        ).rejects.toThrow('name cannot have value beforeCreate');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeCreate'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.creator(vc1).setField('name', 'afterCreate').createAsync(),
-        ).rejects.toThrowError('name cannot have value afterCreate');
+        ).rejects.toThrow('name cannot have value afterCreate');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterCreate'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.creator(vc1).setField('name', 'beforeAll').createAsync(),
-        ).rejects.toThrowError('name cannot have value beforeAll');
+        ).rejects.toThrow('name cannot have value beforeAll');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeAll'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.creator(vc1).setField('name', 'afterAll').createAsync(),
-        ).rejects.toThrowError('name cannot have value afterAll');
+        ).rejects.toThrow('name cannot have value afterAll');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterAll'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.creator(vc1).setField('name', 'afterCommit').createAsync(),
-        ).rejects.toThrowError('name cannot have value afterCommit');
+        ).rejects.toThrow('name cannot have value afterCommit');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterCommit'),
         ).resolves.not.toBeNull();
@@ -608,35 +609,35 @@ describe('postgres entity integration', () => {
 
         await expect(
           PostgresTriggerTestEntity.updater(entity).setField('name', 'beforeUpdate').updateAsync(),
-        ).rejects.toThrowError('name cannot have value beforeUpdate');
+        ).rejects.toThrow('name cannot have value beforeUpdate');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeUpdate'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.updater(entity).setField('name', 'afterUpdate').updateAsync(),
-        ).rejects.toThrowError('name cannot have value afterUpdate');
+        ).rejects.toThrow('name cannot have value afterUpdate');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterUpdate'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.updater(entity).setField('name', 'beforeAll').updateAsync(),
-        ).rejects.toThrowError('name cannot have value beforeAll');
+        ).rejects.toThrow('name cannot have value beforeAll');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeAll'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.updater(entity).setField('name', 'afterAll').updateAsync(),
-        ).rejects.toThrowError('name cannot have value afterAll');
+        ).rejects.toThrow('name cannot have value afterAll');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterAll'),
         ).resolves.toBeNull();
 
         await expect(
           PostgresTriggerTestEntity.updater(entity).setField('name', 'afterCommit').updateAsync(),
-        ).rejects.toThrowError('name cannot have value afterCommit');
+        ).rejects.toThrow('name cannot have value afterCommit');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterCommit'),
         ).resolves.not.toBeNull();
@@ -654,7 +655,7 @@ describe('postgres entity integration', () => {
           .createAsync();
         await expect(
           PostgresTriggerTestEntity.deleter(entityBeforeDelete).deleteAsync(),
-        ).rejects.toThrowError('name cannot have value beforeDelete');
+        ).rejects.toThrow('name cannot have value beforeDelete');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'beforeDelete'),
         ).resolves.not.toBeNull();
@@ -664,7 +665,7 @@ describe('postgres entity integration', () => {
           .createAsync();
         await expect(
           PostgresTriggerTestEntity.deleter(entityAfterDelete).deleteAsync(),
-        ).rejects.toThrowError('name cannot have value afterDelete');
+        ).rejects.toThrow('name cannot have value afterDelete');
         await expect(
           PostgresTriggerTestEntity.loader(vc1).loadByFieldEqualingAsync('name', 'afterDelete'),
         ).resolves.not.toBeNull();
@@ -681,7 +682,7 @@ describe('postgres entity integration', () => {
             PostgresValidatorTestEntity.creator(vc1)
               .setField('name', 'beforeCreateAndBeforeUpdate')
               .createAsync(),
-          ).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
+          ).rejects.toThrow('name cannot have value beforeCreateAndBeforeUpdate');
           await expect(
             PostgresValidatorTestEntity.loader(vc1).loadByFieldEqualingAsync(
               'name',
@@ -704,7 +705,7 @@ describe('postgres entity integration', () => {
             PostgresValidatorTestEntity.updater(entity)
               .setField('name', 'beforeCreateAndBeforeUpdate')
               .updateAsync(),
-          ).rejects.toThrowError('name cannot have value beforeCreateAndBeforeUpdate');
+          ).rejects.toThrow('name cannot have value beforeCreateAndBeforeUpdate');
           await expect(
             PostgresValidatorTestEntity.loader(vc1).loadByFieldEqualingAsync(
               'name',
@@ -783,7 +784,7 @@ describe('postgres entity integration', () => {
             throw Error('wat');
           }, 0);
         }),
-      ).rejects.toThrowError('wat');
+      ).rejects.toThrow('wat');
 
       expect(preCommitCallCount).toBe(2);
       expect(preCommitInnerCallCount).toBe(2);

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

@@ -1,9 +1,10 @@
 import { TransactionalDataLoaderMode, ViewerContext } from '@expo/entity';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, test } from '@jest/globals';
 import { knex, Knex } from 'knex';
 import nullthrows from 'nullthrows';
 
-import PostgresEntityQueryContextProvider from '../PostgresEntityQueryContextProvider';
-import PostgresUniqueTestEntity from '../__testfixtures__/PostgresUniqueTestEntity';
+import { PostgresEntityQueryContextProvider } from '../PostgresEntityQueryContextProvider';
+import { PostgresUniqueTestEntity } from '../__testfixtures__/PostgresUniqueTestEntity';
 import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
 
 describe(PostgresEntityQueryContextProvider, () => {

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

@@ -1,9 +1,10 @@
 import { ViewerContext } from '@expo/entity';
 import { enforceAsyncResult } from '@expo/results';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
 import { knex, Knex } from 'knex';
 import nullthrows from 'nullthrows';
 
-import InvalidTestEntity from '../__testfixtures__/InvalidTestEntity';
+import { InvalidTestEntity } from '../__testfixtures__/InvalidTestEntity';
 import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
 
 describe('postgres entity integration', () => {
@@ -47,7 +48,7 @@ describe('postgres entity integration', () => {
           .createAsync(),
       );
 
-      await expect(InvalidTestEntity.deleter(entity1).deleteAsync()).rejects.toThrowError(
+      await expect(InvalidTestEntity.deleter(entity1).deleteAsync()).rejects.toThrow(
         'Excessive deletions from database adapter delete',
       );
     });
@@ -69,7 +70,7 @@ describe('postgres entity integration', () => {
 
       await expect(
         InvalidTestEntity.updater(entity1).setField('name', 'blah').updateAsync(),
-      ).rejects.toThrowError('Excessive results from database adapter update');
+      ).rejects.toThrow('Excessive results from database adapter update');
     });
 
     it('throws after update of no rows', async () => {
@@ -84,7 +85,7 @@ describe('postgres entity integration', () => {
 
       await expect(
         InvalidTestEntity.updater(entity1).setField('name', 'blah').updateAsync(),
-      ).rejects.toThrowError('Empty results from database adapter update');
+      ).rejects.toThrow('Empty results from database adapter update');
     });
   });
 });

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

@@ -1,5 +1,4 @@
 import {
-  ViewerContext,
   EntityDatabaseAdapterCheckConstraintError,
   EntityDatabaseAdapterExclusionConstraintError,
   EntityDatabaseAdapterForeignKeyConstraintError,
@@ -7,11 +6,13 @@ import {
   EntityDatabaseAdapterTransientError,
   EntityDatabaseAdapterUniqueConstraintError,
   EntityDatabaseAdapterUnknownError,
+  ViewerContext,
 } from '@expo/entity';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
 import { knex, Knex } from 'knex';
 import nullthrows from 'nullthrows';
 
-import ErrorsTestEntity from '../__testfixtures__/ErrorsTestEntity';
+import { ErrorsTestEntity } from '../__testfixtures__/ErrorsTestEntity';
 import { createKnexIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createKnexIntegrationTestEntityCompanionProvider';
 
 describe('postgres errors', () => {

package/src/__testfixtures__/ErrorsTestEntity.ts

@@ -1,12 +1,12 @@
 import {
   AlwaysAllowPrivacyPolicyRule,
-  EntityPrivacyPolicy,
-  ViewerContext,
-  StringField,
-  EntityConfiguration,
-  EntityCompanionDefinition,
   Entity,
+  EntityCompanionDefinition,
+  EntityConfiguration,
+  EntityPrivacyPolicy,
   IntField,
+  StringField,
+  ViewerContext,
 } from '@expo/entity';
 import { Knex } from 'knex';
 
@@ -22,7 +22,7 @@ type ErrorsTestEntityFields = {
 
 const foreignTableName = 'foreign_table';
 
-export default class ErrorsTestEntity extends Entity<ErrorsTestEntityFields, 'id', ViewerContext> {
+export class ErrorsTestEntity extends Entity<ErrorsTestEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     ErrorsTestEntityFields,
     'id',

package/src/__testfixtures__/InvalidTestEntity.ts

@@ -1,12 +1,12 @@
 import {
   AlwaysAllowPrivacyPolicyRule,
-  EntityPrivacyPolicy,
-  ViewerContext,
-  StringField,
-  EntityConfiguration,
-  EntityCompanionDefinition,
   Entity,
+  EntityCompanionDefinition,
+  EntityConfiguration,
+  EntityPrivacyPolicy,
   IntField,
+  StringField,
+  ViewerContext,
 } from '@expo/entity';
 import { Knex } from 'knex';
 
@@ -15,11 +15,7 @@ type InvalidTestEntityFields = {
   name: string | null;
 };
 
-export default class InvalidTestEntity extends Entity<
-  InvalidTestEntityFields,
-  'id',
-  ViewerContext
-> {
+export class InvalidTestEntity extends Entity<InvalidTestEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     InvalidTestEntityFields,
     'id',

package/src/__testfixtures__/PostgresTestEntity.ts

@@ -1,16 +1,16 @@
 import {
   AlwaysAllowPrivacyPolicyRule,
-  EntityPrivacyPolicy,
-  ViewerContext,
-  StringField,
   BooleanField,
-  StringArrayField,
-  JSONObjectField,
   DateField,
-  EntityConfiguration,
-  EntityCompanionDefinition,
   Entity,
+  EntityCompanionDefinition,
+  EntityConfiguration,
+  EntityPrivacyPolicy,
+  JSONObjectField,
+  StringArrayField,
+  StringField,
   UUIDField,
+  ViewerContext,
 } from '@expo/entity';
 import { Knex } from 'knex';
 
@@ -31,11 +31,7 @@ type PostgresTestEntityFields = {
   bigintField: string | null;
 };
 
-export default class PostgresTestEntity extends Entity<
-  PostgresTestEntityFields,
-  'id',
-  ViewerContext
-> {
+export class PostgresTestEntity extends Entity<PostgresTestEntityFields, 'id', ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     PostgresTestEntityFields,
     'id',