v0.12.0 (#112 )

chore: upgrade more packages (#111 )
chore: upgrade typescript to 4.1 (#110 )
2026-11-13 20:28:06 -10:00 · 2021-01-22 09:28:24 -08:00 · 2021-01-20 12:53:31 -08:00 · 2021-01-20 12:37:15 -08:00 · 2021-01-20 11:49:45 -08:00 · 2021-01-20 10:07:13 -08:00
100 changed files with 2132 additions and 1207 deletions
@@ -10,7 +10,8 @@
  "rules": {
    "no-restricted-imports": ["error",{ "paths": [".", "..", "../.."] }],
    "tsdoc/syntax": "warn",
-    "no-console": "warn"
+    "no-console": "warn",
+    "handle-callback-err": "off"
  },
  "overrides": [
    {
@@ -3,6 +3,42 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

+# [0.12.0](https://github.com/expo/entity/compare/v0.11.0...v0.12.0) (2021-01-22)
+
+
+### Bug Fixes
+
+* move runInTransaction to ViewerContext ([#108](https://github.com/expo/entity/issues/108)) ([b7309e1](https://github.com/expo/entity/commit/b7309e18a2dd780b64cd306d566de1f12bf8df3a))
+* remove cache and database adaptor flavor enums ([#109](https://github.com/expo/entity/issues/109)) ([72a77f8](https://github.com/expo/entity/commit/72a77f8b6893a4b76d3b1cce16659bdf3ce473ee))
+
+
+### Features
+
+* better typing on filterMap for use with predicates ([#106](https://github.com/expo/entity/issues/106)) ([01b3bfe](https://github.com/expo/entity/commit/01b3bfef7c6da55e7d89d8cccb52a0050187aee8))
+
+
+
+
+
+# [0.11.0](https://github.com/expo/entity/compare/v0.10.0...v0.11.0) (2020-12-24)
+
+
+### Bug Fixes
+
+* add type generic default in test utils ([#104](https://github.com/expo/entity/issues/104)) ([fe2917e](https://github.com/expo/entity/commit/fe2917e6b5af808f166aa354d476e168c41e6d21))
+* maps utils invariants for collections containing undefined values ([#103](https://github.com/expo/entity/issues/103)) ([29c1a43](https://github.com/expo/entity/commit/29c1a434ab6cd8d30e9f0e7c742065c8d46d8d8a))
+* remove any cast from EntityLoader ([#100](https://github.com/expo/entity/issues/100)) ([b8e07f9](https://github.com/expo/entity/commit/b8e07f9ddc4077768980c000d61f5ddcc824e2e3))
+
+
+### Features
+
+* better cache adapter error handling ([#102](https://github.com/expo/entity/issues/102)) ([15546aa](https://github.com/expo/entity/commit/15546aad97734ab9ac67f1c012485f096a0e94f1))
+* better database adapter error handling ([#101](https://github.com/expo/entity/issues/101)) ([5208aee](https://github.com/expo/entity/commit/5208aeedb0192f0460ba3d575770a04175f5c3aa))
+
+
+
+
+
 # [0.10.0](https://github.com/expo/entity/compare/v0.9.1...v0.10.0) (2020-11-17)


@@ -4,5 +4,5 @@
  ],
  "npmClient": "yarn",
  "useWorkspaces": true,
-  "version": "0.10.0"
+  "version": "0.12.0"
 }
@@ -20,21 +20,21 @@
    "@types/jest": "^26.0.10",
    "@types/node": "^14.6.0",
    "@types/uuid": "^8.3.0",
-    "@typescript-eslint/eslint-plugin": "^3.10.1",
-    "@typescript-eslint/parser": "^3.10.1",
+    "@typescript-eslint/eslint-plugin": "^4.14.0",
+    "@typescript-eslint/parser": "^4.14.0",
    "barrelsby": "^2.2.0",
    "eslint": "^7.7.0",
-    "eslint-config-universe": "^4.0.0",
+    "eslint-config-universe": "^7.0.0",
    "eslint-plugin-tsdoc": "^0.2.6",
-    "jest": "^26.4.2",
+    "jest": "^26.6.3",
    "lerna": "^3.22.1",
    "pg": "^8.3.2",
    "prettier": "^2.1.0",
-    "ts-jest": "~26.2.0",
+    "ts-jest": "~26.4.4",
    "ts-mockito": "^2.6.1",
    "typedoc": "^0.17.6",
-    "typedoc-plugin-lerna-packages": "^0.3.0",
-    "typescript": "^4.0.2",
+    "typedoc-plugin-lerna-packages": "^0.3.1",
+    "typescript": "^4.1.3",
    "uuid": "^8.3.0"
  },
  "dependencies": {
@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

+# [0.12.0](https://github.com/expo/entity/compare/v0.11.0...v0.12.0) (2021-01-22)
+
+
+### Bug Fixes
+
+* remove cache and database adaptor flavor enums ([#109](https://github.com/expo/entity/issues/109)) ([72a77f8](https://github.com/expo/entity/commit/72a77f8b6893a4b76d3b1cce16659bdf3ce473ee))
+
+
+
+
+
+# [0.11.0](https://github.com/expo/entity/compare/v0.10.0...v0.11.0) (2020-12-24)
+
+
+### Features
+
+* better cache adapter error handling ([#102](https://github.com/expo/entity/issues/102)) ([15546aa](https://github.com/expo/entity/commit/15546aad97734ab9ac67f1c012485f096a0e94f1))
+
+
+
+
+
 # [0.10.0](https://github.com/expo/entity/compare/v0.9.1...v0.10.0) (2020-11-17)

 **Note:** Version bump only for package @expo/entity-cache-adapter-redis
@@ -35,7 +35,7 @@ export const createDefaultEntityCompanionProvider = (
      ...
    },
    {
-      [CacheAdapterFlavor.REDIS]: {
+      ['redis']: {
        cacheAdapterProvider: new RedisCacheAdapterProvider(redisCacheAdapterContext),
      },
    }
@@ -1,6 +1,6 @@
 {
  "name": "@expo/entity-cache-adapter-redis",
-  "version": "0.10.0",
+  "version": "0.12.0",
  "description": "Redis cache adapter for @expo/entity",
  "files": [
    "build",
@@ -32,6 +32,6 @@
    "ioredis": "^4.17.3"
  },
  "devDependencies": {
-    "@expo/entity": "^0.10.0"
+    "@expo/entity": "^0.12.0"
  }
 }
@@ -8,6 +8,7 @@ import {
 import { Redis } from 'ioredis';

 import { redisTransformerMap } from './RedisCommon';
+import wrapNativeRedisCall from './errors/wrapNativeRedisCall';

 // Sentinel value we store in Redis to negatively cache a database miss.
 // The sentinel value is distinct from any (positively) cached value.
@@ -71,7 +72,9 @@ export default class RedisCacheAdapter<TFields> extends EntityCacheAdapter<TFiel
    }

    const redisKeys = fieldValues.map((fieldValue) => this.makeCacheKey(fieldName, fieldValue));
-    const redisResults = await this.context.redisClient.mget(...redisKeys);
+    const redisResults = await wrapNativeRedisCall(() =>
+      this.context.redisClient.mget(...redisKeys)
+    );

    const results = new Map<NonNullable<TFields[N]>, CacheLoadResult>();
    for (let i = 0; i < fieldValues.length; i++) {
@@ -114,7 +117,7 @@ export default class RedisCacheAdapter<TFields> extends EntityCacheAdapter<TFiel
        this.context.ttlSecondsPositive
      );
    });
-    await redisTransaction.exec();
+    await wrapNativeRedisCall(() => redisTransaction.exec());
  }

  public async cacheDBMissesAsync<N extends keyof TFields>(
@@ -135,7 +138,7 @@ export default class RedisCacheAdapter<TFields> extends EntityCacheAdapter<TFiel
        this.context.ttlSecondsNegative
      );
    });
-    await redisTransaction.exec();
+    await wrapNativeRedisCall(() => redisTransaction.exec());
  }

  public async invalidateManyAsync<N extends keyof TFields>(
@@ -147,7 +150,7 @@ export default class RedisCacheAdapter<TFields> extends EntityCacheAdapter<TFiel
    }

    const redisKeys = fieldValues.map((fieldValue) => this.makeCacheKey(fieldName, fieldValue));
-    await this.context.redisClient.del(...redisKeys);
+    await wrapNativeRedisCall(() => this.context.redisClient.del(...redisKeys));
  }

  private makeCacheKey<N extends keyof TFields>(
@@ -0,0 +1,46 @@
+import { EntityCacheAdapterTransientError, ViewerContext } from '@expo/entity';
+import Redis from 'ioredis';
+import { URL } from 'url';
+
+import RedisCacheAdapter, { RedisCacheAdapterContext } from '../RedisCacheAdapter';
+import RedisTestEntity from '../testfixtures/RedisTestEntity';
+import { createRedisIntegrationTestEntityCompanionProvider } from '../testfixtures/createRedisIntegrationTestEntityCompanionProvider';
+
+class TestViewerContext extends ViewerContext {}
+
+describe(RedisCacheAdapter, () => {
+  let redisCacheAdapterContext: RedisCacheAdapterContext;
+
+  beforeAll(() => {
+    redisCacheAdapterContext = {
+      redisClient: new Redis(new URL(process.env.REDIS_URL!).toString()),
+      makeKeyFn(...parts: string[]): string {
+        const delimiter = ':';
+        const escapedParts = parts.map((part) =>
+          part.replace('\\', '\\\\').replace(delimiter, `\\${delimiter}`)
+        );
+        return escapedParts.join(delimiter);
+      },
+      cacheKeyPrefix: 'test-',
+      cacheKeyVersion: 1,
+      ttlSecondsPositive: 86400, // 1 day
+      ttlSecondsNegative: 600, // 10 minutes
+    };
+  });
+
+  beforeEach(async () => {
+    await redisCacheAdapterContext.redisClient.flushdb();
+  });
+
+  it('throws when redis is disconnected', async () => {
+    redisCacheAdapterContext.redisClient.disconnect();
+
+    const vc1 = new TestViewerContext(
+      createRedisIntegrationTestEntityCompanionProvider(redisCacheAdapterContext)
+    );
+
+    await expect(
+      RedisTestEntity.creator(vc1).setField('name', 'blah').enforceCreateAsync()
+    ).rejects.toThrow(EntityCacheAdapterTransientError);
+  });
+});
@@ -1,10 +1,4 @@
-import {
-  CacheStatus,
-  UUIDField,
-  EntityConfiguration,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-} from '@expo/entity';
+import { CacheStatus, UUIDField, EntityConfiguration } from '@expo/entity';
 import { Redis, Pipeline } from 'ioredis';
 import { mock, when, instance, anything, verify } from 'ts-mockito';

@@ -20,8 +14,8 @@ const entityConfiguration = new EntityConfiguration<BlahFields>({
  schema: {
    id: new UUIDField({ columnName: 'id', cache: true }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 describe(RedisCacheAdapter, () => {
@@ -0,0 +1,11 @@
+import { EntityCacheAdapterTransientError } from '@expo/entity';
+
+export default async function wrapNativeRedisCall<T>(fn: () => Promise<T>): Promise<T> {
+  try {
+    return await fn();
+  } catch (e) {
+    const error = new EntityCacheAdapterTransientError(e.message, e);
+    error.stack = e.stack;
+    throw error;
+  }
+}
@@ -6,8 +6,6 @@ import {
  DateField,
  StringField,
  EntityConfiguration,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
  EntityCompanionDefinition,
  Entity,
 } from '@expo/entity';
@@ -85,8 +83,8 @@ export const redisTestEntityConfiguration = new EntityConfiguration<RedisTestEnt
      columnName: 'date_field',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 const redisTestEntityCompanionDefinition = new EntityCompanionDefinition({
@@ -2,8 +2,6 @@ import {
  NoOpEntityMetricsAdapter,
  IEntityMetricsAdapter,
  EntityCompanionProvider,
-  CacheAdapterFlavor,
-  DatabaseAdapterFlavor,
  StubQueryContextProvider,
  StubDatabaseAdapterProvider,
 } from '@expo/entity';
@@ -17,16 +15,22 @@ export const createRedisIntegrationTestEntityCompanionProvider = (
 ): EntityCompanionProvider => {
  return new EntityCompanionProvider(
    metricsAdapter,
-    {
-      [DatabaseAdapterFlavor.POSTGRES]: {
-        adapterProvider: new StubDatabaseAdapterProvider(),
-        queryContextProvider: StubQueryContextProvider,
-      },
-    },
-    {
-      [CacheAdapterFlavor.REDIS]: {
-        cacheAdapterProvider: new RedisCacheAdapterProvider(redisCacheAdapterContext),
-      },
-    }
+    new Map([
+      [
+        'postgres',
+        {
+          adapterProvider: new StubDatabaseAdapterProvider(),
+          queryContextProvider: StubQueryContextProvider,
+        },
+      ],
+    ]),
+    new Map([
+      [
+        'redis',
+        {
+          cacheAdapterProvider: new RedisCacheAdapterProvider(redisCacheAdapterContext),
+        },
+      ],
+    ])
  );
 };
@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

+# [0.12.0](https://github.com/expo/entity/compare/v0.11.0...v0.12.0) (2021-01-22)
+
+
+### Bug Fixes
+
+* move runInTransaction to ViewerContext ([#108](https://github.com/expo/entity/issues/108)) ([b7309e1](https://github.com/expo/entity/commit/b7309e18a2dd780b64cd306d566de1f12bf8df3a))
+* remove cache and database adaptor flavor enums ([#109](https://github.com/expo/entity/issues/109)) ([72a77f8](https://github.com/expo/entity/commit/72a77f8b6893a4b76d3b1cce16659bdf3ce473ee))
+
+
+
+
+
+# [0.11.0](https://github.com/expo/entity/compare/v0.10.0...v0.11.0) (2020-12-24)
+
+
+### Features
+
+* better cache adapter error handling ([#102](https://github.com/expo/entity/issues/102)) ([15546aa](https://github.com/expo/entity/commit/15546aad97734ab9ac67f1c012485f096a0e94f1))
+* better database adapter error handling ([#101](https://github.com/expo/entity/issues/101)) ([5208aee](https://github.com/expo/entity/commit/5208aeedb0192f0460ba3d575770a04175f5c3aa))
+
+
+
+
+
 # [0.10.0](https://github.com/expo/entity/compare/v0.9.1...v0.10.0) (2020-11-17)

 **Note:** Version bump only for package @expo/entity-database-adapter-knex
@@ -29,7 +29,7 @@ export const createDefaultEntityCompanionProvider = (
    metricsAdapter,
    {
      // add the knex database adapter flavor
-      [DatabaseAdapterFlavor.POSTGRES]: {
+      ['postgres']: {
        adapter: PostgresEntityDatabaseAdapter,
        queryContextProvider: new PostgresEntityQueryContextProvider(knexInstance),
      },
@@ -1,6 +1,6 @@
 {
  "name": "@expo/entity-database-adapter-knex",
-  "version": "0.10.0",
+  "version": "0.12.0",
  "description": "Knex database adapter for @expo/entity",
  "files": [
    "build",
@@ -32,6 +32,6 @@
    "knex": "^0.21.5"
  },
  "devDependencies": {
-    "@expo/entity": "^0.10.0"
+    "@expo/entity": "^0.12.0"
  }
 }
@@ -10,6 +10,8 @@ import {
 } from '@expo/entity';
 import Knex from 'knex';

+import wrapNativePostgresCall from './errors/wrapNativePostgresCall';
+
 export default class PostgresEntityDatabaseAdapter<TFields> extends EntityDatabaseAdapter<TFields> {
  protected getFieldTransformerMap(): FieldTransformerMap {
    return new Map<string, FieldTransformer<any>>([
@@ -43,10 +45,12 @@ export default class PostgresEntityDatabaseAdapter<TFields> extends EntityDataba
    tableField: string,
    tableValues: readonly any[]
  ): Promise<object[]> {
-    return await queryInterface
-      .select()
-      .from(tableName)
-      .whereRaw('?? = ANY(?)', [tableField, tableValues as any[]]);
+    return await wrapNativePostgresCall(() =>
+      queryInterface
+        .select()
+        .from(tableName)
+        .whereRaw('?? = ANY(?)', [tableField, tableValues as any[]])
+    );
  }

  private applyQueryModifiersToQuery(
@@ -98,7 +102,7 @@ export default class PostgresEntityDatabaseAdapter<TFields> extends EntityDataba
    }

    query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
-    return await query;
+    return await wrapNativePostgresCall(() => query);
  }

  protected async fetchManyByRawWhereClauseInternalAsync(
@@ -113,7 +117,7 @@ export default class PostgresEntityDatabaseAdapter<TFields> extends EntityDataba
      .from(tableName)
      .whereRaw(rawWhereClause, bindings as any);
    query = this.applyQueryModifiersToQuery(query, querySelectionModifiers);
-    return await query;
+    return await wrapNativePostgresCall(() => query);
  }

  protected async insertInternalAsync(
@@ -121,7 +125,9 @@ export default class PostgresEntityDatabaseAdapter<TFields> extends EntityDataba
    tableName: string,
    object: object
  ): Promise<object[]> {
-    return await queryInterface.insert(object).into(tableName).returning('*');
+    return await wrapNativePostgresCall(() =>
+      queryInterface.insert(object).into(tableName).returning('*')
+    );
  }

  protected async updateInternalAsync(
@@ -131,11 +137,9 @@ export default class PostgresEntityDatabaseAdapter<TFields> extends EntityDataba
    id: any,
    object: object
  ): Promise<object[]> {
-    return await queryInterface
-      .update(object)
-      .into(tableName)
-      .where(tableIdField, id)
-      .returning('*');
+    return await wrapNativePostgresCall(() =>
+      queryInterface.update(object).into(tableName).where(tableIdField, id).returning('*')
+    );
  }

  protected async deleteInternalAsync(
@@ -144,6 +148,8 @@ export default class PostgresEntityDatabaseAdapter<TFields> extends EntityDataba
    tableIdField: string,
    id: any
  ): Promise<number> {
-    return await queryInterface.into(tableName).where(tableIdField, id).del();
+    return await wrapNativePostgresCall(() =>
+      queryInterface.into(tableName).where(tableIdField, id).del()
+    );
  }
 }
@@ -94,7 +94,7 @@ describe('postgres entity integration', () => {
    const errorToThrow = new Error('Intentional error');

    await expect(
-      PostgresTestEntity.runInTransactionAsync(vc1, async (queryContext) => {
+      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()
@@ -0,0 +1,170 @@
+import { ViewerContext } from '@expo/entity';
+import {
+  EntityDatabaseAdapterCheckConstraintError,
+  EntityDatabaseAdapterExclusionConstraintError,
+  EntityDatabaseAdapterForeignKeyConstraintError,
+  EntityDatabaseAdapterNotNullConstraintError,
+  EntityDatabaseAdapterTransientError,
+  EntityDatabaseAdapterUniqueConstraintError,
+  EntityDatabaseAdapterUnknownError,
+} from '@expo/entity/build/errors/EntityDatabaseAdapterError';
+import Knex from 'knex';
+
+import ErrorsTestEntity from '../testfixtures/ErrorsTestEntity';
+import { createKnexIntegrationTestEntityCompanionProvider } from '../testfixtures/createKnexIntegrationTestEntityCompanionProvider';
+
+describe('postgres errors', () => {
+  let knexInstance: Knex;
+
+  beforeAll(() => {
+    knexInstance = Knex({
+      client: 'pg',
+      connection: {
+        user: process.env.PGUSER,
+        password: process.env.PGPASSWORD,
+        host: 'localhost',
+        port: parseInt(process.env.PGPORT!, 10),
+        database: process.env.PGDATABASE,
+      },
+    });
+  });
+
+  beforeEach(async () => {
+    await ErrorsTestEntity.createOrTruncatePostgresTable(knexInstance);
+  });
+
+  afterAll(async () => {
+    await ErrorsTestEntity.dropPostgresTable(knexInstance);
+    await knexInstance.destroy();
+  });
+
+  it('throws EntityDatabaseAdapterTransientError on Knex timeout', async () => {
+    const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+    await ErrorsTestEntity.creator(vc)
+      .setField('id', 1)
+      .setField('fieldNonNull', 'hello')
+      .enforceCreateAsync();
+
+    const shortTimeoutKnexInstance = Knex({
+      client: 'pg',
+      connection: {
+        user: process.env.PGUSER,
+        password: process.env.PGPASSWORD,
+        host: 'localhost',
+        port: parseInt(process.env.PGPORT!, 10),
+        database: process.env.PGDATABASE,
+      },
+      acquireConnectionTimeout: 1,
+    });
+    const vc2 = new ViewerContext(
+      createKnexIntegrationTestEntityCompanionProvider(shortTimeoutKnexInstance)
+    );
+    await expect(ErrorsTestEntity.loader(vc2).enforcing().loadByIDAsync(1)).rejects.toThrow(
+      EntityDatabaseAdapterTransientError
+    );
+    await shortTimeoutKnexInstance.destroy();
+  });
+
+  it('throws EntityDatabaseAdapterNotNullConstraintError when not null is violated', async () => {
+    const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 1)
+        .setField('fieldNonNull', null as any)
+        .enforceCreateAsync()
+    ).rejects.toThrow(EntityDatabaseAdapterNotNullConstraintError);
+  });
+
+  it('throws EntityDatabaseAdapterForeignKeyConstraintError when foreign key is violated', async () => {
+    const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 1)
+        .setField('fieldNonNull', 'hello')
+        .setField('fieldForeignKey', 2)
+        .enforceCreateAsync()
+    ).rejects.toThrow(EntityDatabaseAdapterForeignKeyConstraintError);
+  });
+
+  it('throws EntityDatabaseAdapterUniqueConstraintError when primary key unique constraint is violated', async () => {
+    const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+
+    await ErrorsTestEntity.creator(vc)
+      .setField('id', 1)
+      .setField('fieldNonNull', 'hello')
+      .enforceCreateAsync();
+
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 1)
+        .setField('fieldNonNull', 'hello')
+        .enforceCreateAsync()
+    ).rejects.toThrow(EntityDatabaseAdapterUniqueConstraintError);
+  });
+
+  it('throws EntityDatabaseAdapterUniqueConstraintError when unique constraint is violated', async () => {
+    const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+    await ErrorsTestEntity.creator(vc)
+      .setField('id', 2)
+      .setField('fieldNonNull', 'hello')
+      .setField('fieldUnique', 'hello')
+      .enforceCreateAsync();
+
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 1)
+        .setField('fieldNonNull', 'hello')
+        .setField('fieldUnique', 'hello')
+        .enforceCreateAsync()
+    ).rejects.toThrow(EntityDatabaseAdapterUniqueConstraintError);
+  });
+
+  it('throws EntityDatabaseAdapterCheckConstraintError when check constraint is violated', async () => {
+    const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 1)
+        .setField('fieldNonNull', 'hello')
+        .setField('checkLessThan5', 2)
+        .enforceCreateAsync()
+    ).resolves.toBeTruthy();
+
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 2)
+        .setField('fieldNonNull', 'hello')
+        .setField('checkLessThan5', 10)
+        .enforceCreateAsync()
+    ).rejects.toThrow(EntityDatabaseAdapterCheckConstraintError);
+  });
+
+  it('throws EntityDatabaseAdapterExclusionConstraintError when exclusion constraint is violated', async () => {
+    const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 1)
+        .setField('fieldNonNull', 'hello')
+        .setField('fieldExclusion', 'what')
+        .enforceCreateAsync()
+    ).resolves.toBeTruthy();
+
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 2)
+        .setField('fieldNonNull', 'hello')
+        .setField('fieldExclusion', 'what')
+        .enforceCreateAsync()
+    ).rejects.toThrow(EntityDatabaseAdapterExclusionConstraintError);
+  });
+
+  it('throws EntityDatabaseAdapterUnknownError otherwise', async () => {
+    const vc = new ViewerContext(createKnexIntegrationTestEntityCompanionProvider(knexInstance));
+    await expect(
+      ErrorsTestEntity.creator(vc)
+        .setField('id', 1)
+        .setField('fieldNonNull', 'hello')
+        .setField('nonExistentColumn', 'what')
+        .enforceCreateAsync()
+    ).rejects.toThrow(EntityDatabaseAdapterUnknownError);
+  });
+});
@@ -0,0 +1,50 @@
+import {
+  EntityDatabaseAdapterError,
+  EntityDatabaseAdapterCheckConstraintError,
+  EntityDatabaseAdapterExclusionConstraintError,
+  EntityDatabaseAdapterForeignKeyConstraintError,
+  EntityDatabaseAdapterNotNullConstraintError,
+  EntityDatabaseAdapterTransientError,
+  EntityDatabaseAdapterUniqueConstraintError,
+  EntityDatabaseAdapterUnknownError,
+} from '@expo/entity';
+import { KnexTimeoutError } from 'knex';
+
+function wrapNativePostgresError(
+  error: Error & { code: string | undefined }
+): EntityDatabaseAdapterError & Error {
+  const ret = translatePostgresError(error);
+  ret.stack = error.stack;
+  return ret;
+}
+
+function translatePostgresError(
+  error: Error & { code: string | undefined }
+): EntityDatabaseAdapterError & Error {
+  if (error instanceof KnexTimeoutError) {
+    return new EntityDatabaseAdapterTransientError(error.message, error);
+  }
+
+  switch (error.code) {
+    case '23502':
+      return new EntityDatabaseAdapterNotNullConstraintError(error.message, error);
+    case '23503':
+      return new EntityDatabaseAdapterForeignKeyConstraintError(error.message, error);
+    case '23505':
+      return new EntityDatabaseAdapterUniqueConstraintError(error.message, error);
+    case '23514':
+      return new EntityDatabaseAdapterCheckConstraintError(error.message, error);
+    case '23P01':
+      return new EntityDatabaseAdapterExclusionConstraintError(error.message, error);
+    default:
+      return new EntityDatabaseAdapterUnknownError(error.message, error);
+  }
+}
+
+export default async function wrapNativePostgresCall<T>(fn: () => Promise<T>): Promise<T> {
+  try {
+    return await fn();
+  } catch (e) {
+    throw wrapNativePostgresError(e);
+  }
+}
@@ -0,0 +1,177 @@
+import {
+  AlwaysAllowPrivacyPolicyRule,
+  EntityPrivacyPolicy,
+  ViewerContext,
+  StringField,
+  EntityConfiguration,
+  EntityCompanionDefinition,
+  Entity,
+  NumberField,
+} from '@expo/entity';
+import Knex from 'knex';
+
+type ErrorsTestEntityFields = {
+  id: number;
+  fieldNonNull: string;
+  fieldForeignKey: number | null;
+  fieldUnique: string | null;
+  checkLessThan5: number | null;
+  fieldExclusion: string | null;
+  nonExistentColumn: string | null;
+};
+
+const foreignTableName = 'foreign_table';
+
+export default class ErrorsTestEntity extends Entity<
+  ErrorsTestEntityFields,
+  number,
+  ViewerContext
+> {
+  static getCompanionDefinition(): EntityCompanionDefinition<
+    ErrorsTestEntityFields,
+    number,
+    ViewerContext,
+    ErrorsTestEntity,
+    ErrorsTestEntityPrivacyPolicy
+  > {
+    return errorsTestEntityCompanionDefinition;
+  }
+
+  public static async createOrTruncatePostgresTable(knex: Knex): Promise<void> {
+    await knex.raw('CREATE EXTENSION IF NOT EXISTS "btree_gist"'); // for gist exclusion on varchar
+
+    const tableName = this.getCompanionDefinition().entityConfiguration.tableName;
+
+    const hasForeignTable = await knex.schema.hasTable(foreignTableName);
+    if (!hasForeignTable) {
+      await knex.schema.createTable(foreignTableName, (table) => {
+        table.integer('id').primary();
+      });
+    }
+
+    const hasTable = await knex.schema.hasTable(tableName);
+    if (!hasTable) {
+      await knex.schema.createTable(tableName, (table) => {
+        table.integer('id').primary();
+        table.string('field_non_null').notNullable();
+        table.integer('field_foreign_key').references(`${foreignTableName}.id`);
+        table.string('field_unique').unique();
+        table.integer('check_less_than_5');
+        table.string('field_exclusion');
+      });
+
+      await knex.raw(
+        `
+        ALTER TABLE :tableName:
+        ADD CONSTRAINT check_less_than_5_check_constraint
+        CHECK (check_less_than_5 IS NULL OR check_less_than_5 < 5);`,
+        {
+          tableName,
+        }
+      );
+
+      await knex.raw(
+        `
+        ALTER TABLE :tableName:
+        ADD CONSTRAINT field_exclusion_exclusion_constraint
+        EXCLUDE USING gist (field_exclusion WITH =);
+        `,
+        {
+          tableName,
+        }
+      );
+    }
+
+    await knex(tableName).delete();
+    await knex(foreignTableName).delete();
+  }
+
+  public static async dropPostgresTable(knex: Knex): Promise<void> {
+    const tableName = this.getCompanionDefinition().entityConfiguration.tableName;
+    const hasTable = await knex.schema.hasTable(tableName);
+    if (hasTable) {
+      await knex.schema.dropTable(tableName);
+    }
+
+    const hasForeignTable = await knex.schema.hasTable(foreignTableName);
+    if (hasForeignTable) {
+      await knex.schema.dropTable(foreignTableName);
+    }
+  }
+}
+
+class ErrorsTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
+  ErrorsTestEntityFields,
+  number,
+  ViewerContext,
+  ErrorsTestEntity
+> {
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      ErrorsTestEntityFields,
+      number,
+      ViewerContext,
+      ErrorsTestEntity
+    >(),
+  ];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      ErrorsTestEntityFields,
+      number,
+      ViewerContext,
+      ErrorsTestEntity
+    >(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      ErrorsTestEntityFields,
+      number,
+      ViewerContext,
+      ErrorsTestEntity
+    >(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      ErrorsTestEntityFields,
+      number,
+      ViewerContext,
+      ErrorsTestEntity
+    >(),
+  ];
+}
+
+export const ErrorsTestEntityConfiguration = new EntityConfiguration<ErrorsTestEntityFields>({
+  idField: 'id',
+  tableName: 'postgres_test_entities',
+  schema: {
+    id: new NumberField({
+      columnName: 'id',
+    }),
+    fieldNonNull: new StringField({
+      columnName: 'field_non_null',
+    }),
+    fieldForeignKey: new NumberField({
+      columnName: 'field_foreign_key',
+    }),
+    fieldUnique: new StringField({
+      columnName: 'field_unique',
+    }),
+    checkLessThan5: new NumberField({
+      columnName: 'check_less_than_5',
+    }),
+    fieldExclusion: new StringField({
+      columnName: 'field_exclusion',
+    }),
+    nonExistentColumn: new StringField({
+      columnName: 'non_existent_column',
+    }),
+  },
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
+});
+
+const errorsTestEntityCompanionDefinition = new EntityCompanionDefinition({
+  entityClass: ErrorsTestEntity,
+  entityConfiguration: ErrorsTestEntityConfiguration,
+  privacyPolicyClass: ErrorsTestEntityPrivacyPolicy,
+});
@@ -4,8 +4,6 @@ import {
  ViewerContext,
  StringField,
  EntityConfiguration,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
  EntityCompanionDefinition,
  Entity,
  NumberField,
@@ -104,8 +102,8 @@ export const invalidTestEntityConfiguration = new EntityConfiguration<InvalidTes
      columnName: 'name',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 const invalidTestEntityCompanionDefinition = new EntityCompanionDefinition({
@@ -11,8 +11,6 @@ import {
  DateField,
  MaybeJSONArrayField,
  EntityConfiguration,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
  EntityCompanionDefinition,
  Entity,
 } from '@expo/entity';
@@ -150,8 +148,8 @@ export const postgresTestEntityConfiguration = new EntityConfiguration<PostgresT
      columnName: 'maybe_json_array_field',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 const postgresTestEntityCompanionDefinition = new EntityCompanionDefinition({
@@ -5,8 +5,6 @@ import {
  UUIDField,
  StringField,
  EntityConfiguration,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
  EntityCompanionDefinition,
  Entity,
  EntityMutationTrigger,
@@ -153,8 +151,8 @@ export const postgresTestEntityConfiguration = new EntityConfiguration<
      columnName: 'name',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 const postgresTestEntityCompanionDefinition = new EntityCompanionDefinition({
@@ -5,8 +5,6 @@ import {
  UUIDField,
  StringField,
  EntityConfiguration,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
  EntityCompanionDefinition,
  Entity,
  EntityMutationTrigger,
@@ -135,8 +133,8 @@ export const postgresTestEntityConfiguration = new EntityConfiguration<
      columnName: 'name',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 const postgresTestEntityCompanionDefinition = new EntityCompanionDefinition({
@@ -2,8 +2,6 @@ import {
  NoOpEntityMetricsAdapter,
  IEntityMetricsAdapter,
  EntityCompanionProvider,
-  CacheAdapterFlavor,
-  DatabaseAdapterFlavor,
  InMemoryFullCacheStubCacheAdapterProvider,
 } from '@expo/entity';
 import Knex from 'knex';
@@ -17,16 +15,22 @@ export const createKnexIntegrationTestEntityCompanionProvider = (
 ): EntityCompanionProvider => {
  return new EntityCompanionProvider(
    metricsAdapter,
-    {
-      [DatabaseAdapterFlavor.POSTGRES]: {
-        adapterProvider: new PostgresEntityDatabaseAdapterProvider(),
-        queryContextProvider: new PostgresEntityQueryContextProvider(knex),
-      },
-    },
-    {
-      [CacheAdapterFlavor.REDIS]: {
-        cacheAdapterProvider: new InMemoryFullCacheStubCacheAdapterProvider(),
-      },
-    }
+    new Map([
+      [
+        'postgres',
+        {
+          adapterProvider: new PostgresEntityDatabaseAdapterProvider(),
+          queryContextProvider: new PostgresEntityQueryContextProvider(knex),
+        },
+      ],
+    ]),
+    new Map([
+      [
+        'redis',
+        {
+          cacheAdapterProvider: new InMemoryFullCacheStubCacheAdapterProvider(),
+        },
+      ],
+    ])
  );
 };
@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

+# [0.12.0](https://github.com/expo/entity/compare/v0.11.0...v0.12.0) (2021-01-22)
+
+
+### Bug Fixes
+
+* remove cache and database adaptor flavor enums ([#109](https://github.com/expo/entity/issues/109)) ([72a77f8](https://github.com/expo/entity/commit/72a77f8b6893a4b76d3b1cce16659bdf3ce473ee))
+
+
+
+
+
+# [0.11.0](https://github.com/expo/entity/compare/v0.10.0...v0.11.0) (2020-12-24)
+
+
+### Bug Fixes
+
+* remove any cast from EntityLoader ([#100](https://github.com/expo/entity/issues/100)) ([b8e07f9](https://github.com/expo/entity/commit/b8e07f9ddc4077768980c000d61f5ddcc824e2e3))
+
+
+
+
+
 # [0.10.0](https://github.com/expo/entity/compare/v0.9.1...v0.10.0) (2020-11-17)

 **Note:** Version bump only for package @expo/entity-example
@@ -1,7 +1,7 @@
 {
  "name": "@expo/entity-example",
  "private": true,
-  "version": "0.10.0",
+  "version": "0.12.0",
  "description": "An example integration of the @expo/entity framework",
  "scripts": {
    "tsc": "tsc",
@@ -22,7 +22,7 @@
  "author": "Expo",
  "license": "MIT",
  "dependencies": {
-    "@expo/entity": "^0.10.0",
+    "@expo/entity": "^0.12.0",
    "apollo-server-koa": "^2.16.1",
    "graphql": "^15.3.0",
    "koa": "^2.13.0",
@@ -3,8 +3,6 @@ import {
  NoOpEntityMetricsAdapter,
  EntityCompanionProvider,
  InMemoryFullCacheStubCacheAdapterProvider,
-  CacheAdapterFlavor,
-  DatabaseAdapterFlavor,
 } from '@expo/entity';

 import { InMemoryDatabaseAdapterProvider } from './adapters/InMemoryDatabaseAdapter';
@@ -21,20 +19,26 @@ export const createEntityCompanionProvider = (
 ): EntityCompanionProvider => {
  return new EntityCompanionProvider(
    metricsAdapter,
-    {
-      // An in-memory DB is used for demonstration purposes, but generally this would be
-      // instantiated with PostgresEntityDatabaseAdapter and PostgresEntityQueryContextProvider
-      [DatabaseAdapterFlavor.POSTGRES]: {
-        adapterProvider: new InMemoryDatabaseAdapterProvider(),
-        queryContextProvider: new InMemoryQueryContextProvider(),
-      },
-    },
-    {
-      // An in-memory cache is used for demonstration purposes, but generally this would be
-      // instantiated with a RedisCacheAdapterProvider
-      [CacheAdapterFlavor.REDIS]: {
-        cacheAdapterProvider: new InMemoryFullCacheStubCacheAdapterProvider(),
-      },
-    }
+    new Map([
+      [
+        'postgres',
+        // An in-memory DB is used for demonstration purposes, but generally this would be
+        // instantiated with PostgresEntityDatabaseAdapter and PostgresEntityQueryContextProvider
+        {
+          adapterProvider: new InMemoryDatabaseAdapterProvider(),
+          queryContextProvider: new InMemoryQueryContextProvider(),
+        },
+      ],
+    ]),
+    new Map([
+      [
+        'redis',
+        // An in-memory cache is used for demonstration purposes, but generally this would be
+        // instantiated with a RedisCacheAdapterProvider
+        {
+          cacheAdapterProvider: new InMemoryFullCacheStubCacheAdapterProvider(),
+        },
+      ],
+    ])
  );
 };
@@ -23,8 +23,9 @@ import { ExampleViewerContext } from '../viewerContexts';
 */
 export default class AllowIfUserOwnerPrivacyRule<
  TFields,
-  TID,
-  TEntity extends ReadonlyEntity<TFields, TID, ExampleViewerContext>
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TEntity extends ReadonlyEntity<TFields, TID, ExampleViewerContext>,
+  TSelectedFields extends keyof TFields = keyof TFields
 > extends PrivacyPolicyRule<TFields, TID, ExampleViewerContext, TEntity> {
  constructor(private readonly entityOwnerField: keyof TFields) {
    super();
@@ -3,8 +3,6 @@ import {
  EntityCompanionDefinition,
  EntityConfiguration,
  UUIDField,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
  StringField,
 } from '@expo/entity';

@@ -57,8 +55,8 @@ export const noteEntityCompanion = new EntityCompanionDefinition({
        columnName: 'body',
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  }),
  privacyPolicyClass: NotePrivacyPolicy,
 });
@@ -3,6 +3,29 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

+# [0.12.0](https://github.com/expo/entity/compare/v0.11.0...v0.12.0) (2021-01-22)
+
+
+### Bug Fixes
+
+* move runInTransaction to ViewerContext ([#108](https://github.com/expo/entity/issues/108)) ([b7309e1](https://github.com/expo/entity/commit/b7309e18a2dd780b64cd306d566de1f12bf8df3a))
+* remove cache and database adaptor flavor enums ([#109](https://github.com/expo/entity/issues/109)) ([72a77f8](https://github.com/expo/entity/commit/72a77f8b6893a4b76d3b1cce16659bdf3ce473ee))
+
+
+
+
+
+# [0.11.0](https://github.com/expo/entity/compare/v0.10.0...v0.11.0) (2020-12-24)
+
+
+### Bug Fixes
+
+* remove any cast from EntityLoader ([#100](https://github.com/expo/entity/issues/100)) ([b8e07f9](https://github.com/expo/entity/commit/b8e07f9ddc4077768980c000d61f5ddcc824e2e3))
+
+
+
+
+
 # [0.10.0](https://github.com/expo/entity/compare/v0.9.1...v0.10.0) (2020-11-17)

 **Note:** Version bump only for package @expo/entity-full-integration-tests
@@ -1,7 +1,7 @@
 {
  "name": "@expo/entity-full-integration-tests",
  "private": true,
-  "version": "0.10.0",
+  "version": "0.12.0",
  "description": "Full redis and knex integration tests for the entity framework",
  "scripts": {
    "tsc": "tsc",
@@ -26,8 +26,8 @@
    "@expo/entity-database-adapter-knex": "*"
  },
  "devDependencies": {
-    "@expo/entity": "^0.10.0",
-    "@expo/entity-cache-adapter-redis": "^0.10.0",
-    "@expo/entity-database-adapter-knex": "^0.10.0"
+    "@expo/entity": "^0.12.0",
+    "@expo/entity-cache-adapter-redis": "^0.12.0",
+    "@expo/entity-database-adapter-knex": "^0.12.0"
  }
 }
@@ -5,8 +5,6 @@ import {
  Entity,
  EntityCompanionDefinition,
  EntityConfiguration,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
  UUIDField,
 } from '@expo/entity';
 import { RedisCacheAdapterContext } from '@expo/entity-cache-adapter-redis';
@@ -28,10 +26,18 @@ class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
  ViewerContext,
  TestEntity
 > {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
+  ];
 }

 class TestEntity extends Entity<TestFields, string, ViewerContext> {
@@ -62,8 +68,8 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
      columnName: 'third_string',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 const testEntityCompanion = new EntityCompanionDefinition({
@@ -151,12 +157,12 @@ describe('Entity cache inconsistency', () => {
      .loadByFieldEqualingAsync('other_string', 'hello');

    let openBarrier1: () => void;
-    const barrier1 = new Promise((resolve) => {
+    const barrier1 = new Promise<void>((resolve) => {
      openBarrier1 = resolve;
    });

    let openBarrier2: () => void;
-    const barrier2 = new Promise((resolve) => {
+    const barrier2 = new Promise<void>((resolve) => {
      openBarrier2 = resolve;
    });

@@ -175,16 +181,19 @@ describe('Entity cache inconsistency', () => {

        openBarrier2!();
      })(),
-      TestEntity.runInTransactionAsync(viewerContext, async (queryContext) => {
-        await TestEntity.updater(entity1, queryContext)
-          .setField('third_string', 'updated')
-          .enforceUpdateAsync();
+      viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          await TestEntity.updater(entity1, queryContext)
+            .setField('third_string', 'updated')
+            .enforceUpdateAsync();

-        openBarrier1();
+          openBarrier1();

-        // wait for to ensure the transaction isn't committed until after load above occurs
-        await barrier2;
-      }),
+          // wait for to ensure the transaction isn't committed until after load above occurs
+          await barrier2;
+        }
+      ),
    ]);

    // ensure cache consistency
@@ -5,8 +5,6 @@ import {
  Entity,
  EntityCompanionDefinition,
  EntityConfiguration,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
  UUIDField,
  EntityEdgeDeletionBehavior,
 } from '@expo/entity';
@@ -29,10 +27,18 @@ interface OtherFields {
 }

 class PrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any> {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any>(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any>(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any>(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any>(),
+  ];
 }

 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -82,8 +88,8 @@ const makeEntityClasses = async (knex: Knex, edgeDeletionBehavior: EntityEdgeDel
        },
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  });

  const categoryEntityCompanion = new EntityCompanionDefinition({
@@ -110,8 +116,8 @@ const makeEntityClasses = async (knex: Knex, edgeDeletionBehavior: EntityEdgeDel
        },
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  });

  const otherEntityCompanion = new EntityCompanionDefinition({
@@ -1,7 +1,5 @@
 import {
  AlwaysAllowPrivacyPolicyRule,
-  CacheAdapterFlavor,
-  DatabaseAdapterFlavor,
  Entity,
  EntityCompanionDefinition,
  EntityConfiguration,
@@ -19,10 +17,18 @@ interface ChildFields {
 }

 class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
 }

 export default class ChildEntity extends Entity<ChildFields, string, ViewerContext> {
@@ -54,8 +60,8 @@ const childEntityConfiguration = new EntityConfiguration<ChildFields>({
      },
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 const childEntityCompanion = new EntityCompanionDefinition({
@@ -1,7 +1,5 @@
 import {
  AlwaysAllowPrivacyPolicyRule,
-  CacheAdapterFlavor,
-  DatabaseAdapterFlavor,
  Entity,
  EntityCompanionDefinition,
  EntityConfiguration,
@@ -17,10 +15,18 @@ interface ParentFields {
 }

 class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
 }

 export default class ParentEntity extends Entity<ParentFields, string, ViewerContext> {
@@ -45,8 +51,8 @@ const parentEntityConfiguration = new EntityConfiguration<ParentFields>({
      cache: true,
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 const parentEntityCompanion = new EntityCompanionDefinition({
@@ -2,8 +2,6 @@ import {
  NoOpEntityMetricsAdapter,
  IEntityMetricsAdapter,
  EntityCompanionProvider,
-  CacheAdapterFlavor,
-  DatabaseAdapterFlavor,
 } from '@expo/entity';
 import {
  RedisCacheAdapterContext,
@@ -22,16 +20,22 @@ export const createFullIntegrationTestEntityCompanionProvider = (
 ): EntityCompanionProvider => {
  return new EntityCompanionProvider(
    metricsAdapter,
-    {
-      [DatabaseAdapterFlavor.POSTGRES]: {
-        adapterProvider: new PostgresEntityDatabaseAdapterProvider(),
-        queryContextProvider: new PostgresEntityQueryContextProvider(knex),
-      },
-    },
-    {
-      [CacheAdapterFlavor.REDIS]: {
-        cacheAdapterProvider: new RedisCacheAdapterProvider(redisCacheAdapterContext),
-      },
-    }
+    new Map([
+      [
+        'postgres',
+        {
+          adapterProvider: new PostgresEntityDatabaseAdapterProvider(),
+          queryContextProvider: new PostgresEntityQueryContextProvider(knex),
+        },
+      ],
+    ]),
+    new Map([
+      [
+        'redis',
+        {
+          cacheAdapterProvider: new RedisCacheAdapterProvider(redisCacheAdapterContext),
+        },
+      ],
+    ])
  );
 };
@@ -3,6 +3,42 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

+# [0.12.0](https://github.com/expo/entity/compare/v0.11.0...v0.12.0) (2021-01-22)
+
+
+### Bug Fixes
+
+* move runInTransaction to ViewerContext ([#108](https://github.com/expo/entity/issues/108)) ([b7309e1](https://github.com/expo/entity/commit/b7309e18a2dd780b64cd306d566de1f12bf8df3a))
+* remove cache and database adaptor flavor enums ([#109](https://github.com/expo/entity/issues/109)) ([72a77f8](https://github.com/expo/entity/commit/72a77f8b6893a4b76d3b1cce16659bdf3ce473ee))
+
+
+### Features
+
+* better typing on filterMap for use with predicates ([#106](https://github.com/expo/entity/issues/106)) ([01b3bfe](https://github.com/expo/entity/commit/01b3bfef7c6da55e7d89d8cccb52a0050187aee8))
+
+
+
+
+
+# [0.11.0](https://github.com/expo/entity/compare/v0.10.0...v0.11.0) (2020-12-24)
+
+
+### Bug Fixes
+
+* add type generic default in test utils ([#104](https://github.com/expo/entity/issues/104)) ([fe2917e](https://github.com/expo/entity/commit/fe2917e6b5af808f166aa354d476e168c41e6d21))
+* maps utils invariants for collections containing undefined values ([#103](https://github.com/expo/entity/issues/103)) ([29c1a43](https://github.com/expo/entity/commit/29c1a434ab6cd8d30e9f0e7c742065c8d46d8d8a))
+* remove any cast from EntityLoader ([#100](https://github.com/expo/entity/issues/100)) ([b8e07f9](https://github.com/expo/entity/commit/b8e07f9ddc4077768980c000d61f5ddcc824e2e3))
+
+
+### Features
+
+* better cache adapter error handling ([#102](https://github.com/expo/entity/issues/102)) ([15546aa](https://github.com/expo/entity/commit/15546aad97734ab9ac67f1c012485f096a0e94f1))
+* better database adapter error handling ([#101](https://github.com/expo/entity/issues/101)) ([5208aee](https://github.com/expo/entity/commit/5208aeedb0192f0460ba3d575770a04175f5c3aa))
+
+
+
+
+
 # [0.10.0](https://github.com/expo/entity/compare/v0.9.1...v0.10.0) (2020-11-17)


@@ -1,6 +1,6 @@
 {
  "name": "@expo/entity",
-  "version": "0.10.0",
+  "version": "0.12.0",
  "description": "A privacy-first data model",
  "files": [
    "build",
@@ -11,7 +11,7 @@ import { mapMap } from './utils/collections/maps';
 */
 export default class EnforcingEntityLoader<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -27,7 +27,7 @@ import ViewerContext from './ViewerContext';
 */
 export default abstract class Entity<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TSelectedFields extends keyof TFields = keyof TFields
 > extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields> {
@@ -39,7 +39,7 @@ export default abstract class Entity<
   */
  static creator<
    TMFields,
-    TMID,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
    TMViewerContext extends ViewerContext,
    TMViewerContext2 extends TMViewerContext,
    TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
@@ -80,7 +80,7 @@ export default abstract class Entity<
   */
  static updater<
    TMFields,
-    TMID,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
    TMViewerContext extends ViewerContext,
    TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
    TMPrivacyPolicy extends EntityPrivacyPolicy<
@@ -121,7 +121,7 @@ export default abstract class Entity<
   */
  static deleteAsync<
    TMFields,
-    TMID,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
    TMViewerContext extends ViewerContext,
    TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
    TMPrivacyPolicy extends EntityPrivacyPolicy<
@@ -163,7 +163,7 @@ export default abstract class Entity<
   */
  static enforceDeleteAsync<
    TMFields,
-    TMID,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
    TMViewerContext extends ViewerContext,
    TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
    TMPrivacyPolicy extends EntityPrivacyPolicy<
@@ -216,7 +216,7 @@ export default abstract class Entity<
   */
  static async canViewerUpdateAsync<
    TMFields,
-    TMID,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
    TMViewerContext extends ViewerContext,
    TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
    TMPrivacyPolicy extends EntityPrivacyPolicy<
@@ -265,7 +265,7 @@ export default abstract class Entity<
   */
  static async canViewerDeleteAsync<
    TMFields,
-    TMID,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
    TMViewerContext extends ViewerContext,
    TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
    TMPrivacyPolicy extends EntityPrivacyPolicy<
@@ -309,7 +309,7 @@ export default abstract class Entity<
 */
 export interface IEntityClass<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -8,7 +8,7 @@ import ViewerContext from './ViewerContext';

 export default class EntityAssociationLoader<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields
@@ -25,7 +25,7 @@ export default class EntityAssociationLoader<
  async loadAssociatedEntityAsync<
    TIdentifyingField extends keyof Pick<TFields, TSelectedFields>,
    TAssociatedFields,
-    TAssociatedID,
+    TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>,
    TAssociatedEntity extends ReadonlyEntity<
      TAssociatedFields,
      TAssociatedID,
@@ -87,7 +87,7 @@ export default class EntityAssociationLoader<
   */
  async loadManyAssociatedEntitiesAsync<
    TAssociatedFields,
-    TAssociatedID,
+    TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>,
    TAssociatedEntity extends ReadonlyEntity<
      TAssociatedFields,
      TAssociatedID,
@@ -140,7 +140,7 @@ export default class EntityAssociationLoader<
   */
  async loadAssociatedEntityByFieldEqualingAsync<
    TAssociatedFields,
-    TAssociatedID,
+    TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>,
    TAssociatedEntity extends ReadonlyEntity<
      TAssociatedFields,
      TAssociatedID,
@@ -197,7 +197,7 @@ export default class EntityAssociationLoader<
   */
  async loadManyAssociatedEntitiesByFieldEqualingAsync<
    TAssociatedFields,
-    TAssociatedID,
+    TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>,
    TAssociatedEntity extends ReadonlyEntity<
      TAssociatedFields,
      TAssociatedID,
@@ -253,7 +253,7 @@ export default class EntityAssociationLoader<
   */
  async loadAssociatedEntityThroughAsync<
    TFields2,
-    TID2,
+    TID2 extends NonNullable<TFields2[TSelectedFields2]>,
    TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>,
    TPrivacyPolicy2 extends EntityPrivacyPolicy<
      TFields2,
@@ -287,7 +287,7 @@ export default class EntityAssociationLoader<
   */
  async loadAssociatedEntityThroughAsync<
    TFields2,
-    TID2,
+    TID2 extends NonNullable<TFields2[TSelectedFields2]>,
    TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>,
    TPrivacyPolicy2 extends EntityPrivacyPolicy<
      TFields2,
@@ -297,7 +297,7 @@ export default class EntityAssociationLoader<
      TSelectedFields2
    >,
    TFields3,
-    TID3,
+    TID3 extends NonNullable<TFields3[TSelectedFields3]>,
    TEntity3 extends ReadonlyEntity<TFields3, TID3, TViewerContext, TSelectedFields3>,
    TPrivacyPolicy3 extends EntityPrivacyPolicy<
      TFields3,
@@ -342,7 +342,7 @@ export default class EntityAssociationLoader<
   */
  async loadAssociatedEntityThroughAsync<
    TFields2,
-    TID2,
+    TID2 extends NonNullable<TFields2[TSelectedFields2]>,
    TEntity2 extends ReadonlyEntity<TFields2, TID2, TViewerContext, TSelectedFields2>,
    TPrivacyPolicy2 extends EntityPrivacyPolicy<
      TFields2,
@@ -352,7 +352,7 @@ export default class EntityAssociationLoader<
      TSelectedFields2
    >,
    TFields3,
-    TID3,
+    TID3 extends NonNullable<TFields3[TSelectedFields3]>,
    TEntity3 extends ReadonlyEntity<TFields3, TID3, TViewerContext, TSelectedFields3>,
    TPrivacyPolicy3 extends EntityPrivacyPolicy<
      TFields3,
@@ -362,7 +362,7 @@ export default class EntityAssociationLoader<
      TSelectedFields3
    >,
    TFields4,
-    TID4,
+    TID4 extends NonNullable<TFields4[TSelectedFields4]>,
    TEntity4 extends ReadonlyEntity<TFields4, TID4, TViewerContext, TSelectedFields4>,
    TPrivacyPolicy4 extends EntityPrivacyPolicy<
      TFields4,
@@ -478,7 +478,7 @@ export interface EntityLoadThroughDirective<
  TViewerContext extends ViewerContext,
  TFields,
  TAssociatedFields,
-  TAssociatedID,
+  TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>,
  TAssociatedEntity extends ReadonlyEntity<
    TAssociatedFields,
    TAssociatedID,
@@ -19,7 +19,7 @@ export interface IPrivacyPolicyClass<TPrivacyPolicy> {
 */
 export default class EntityCompanion<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -1,3 +1,5 @@
+import invariant from 'invariant';
+
 import { IEntityClass } from './Entity';
 import EntityCompanion, { IPrivacyPolicyClass } from './EntityCompanion';
 import EntityConfiguration from './EntityConfiguration';
@@ -16,25 +18,14 @@ import { computeIfAbsent } from './utils/collections/maps';
 /**
 * Backing database and transaction type for an entity. The definitions and implementations
 * are provided by injection in the root EntityCompanionProvider to allow for mocking and sharing.
- *
- * Note: this enum will likely be modified soon to be more flexible.
 */
-export enum DatabaseAdapterFlavor {
-  /**
-   * Knex postgres adapter, using postgres table and postgres transactions.
-   */
-  POSTGRES = 'postgres',
-}
+export type DatabaseAdapterFlavor = string;

 /**
 * Cache system for an entity. The definitions and implementations are provided by injection
 * in the root EntityCompanionProvider to allow for mocking and sharing.
- *
- * Note: this enum will likely be modified soon to be more flexible.
 */
-export enum CacheAdapterFlavor {
-  REDIS = 'redis',
-}
+export type CacheAdapterFlavor = string;

 /**
 * Defines a set interfaces for a entity database adapter flavor. An entity that uses a flavor
@@ -60,7 +51,7 @@ export interface CacheAdapterFlavorDefinition {
 */
 export class EntityCompanionDefinition<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -168,8 +159,11 @@ export default class EntityCompanionProvider {
   */
  constructor(
    private metricsAdapter: IEntityMetricsAdapter,
-    private databaseAdapterFlavors: Record<DatabaseAdapterFlavor, DatabaseAdapterFlavorDefinition>,
-    private cacheAdapterFlavors: Record<CacheAdapterFlavor, CacheAdapterFlavorDefinition>
+    private databaseAdapterFlavors: ReadonlyMap<
+      DatabaseAdapterFlavor,
+      DatabaseAdapterFlavorDefinition
+    >,
+    private cacheAdapterFlavors: ReadonlyMap<CacheAdapterFlavor, CacheAdapterFlavorDefinition>
  ) {}

  /**
@@ -181,7 +175,7 @@ export default class EntityCompanionProvider {
   */
  getCompanionForEntity<
    TFields,
-    TID,
+    TID extends NonNullable<TFields[TSelectedFields]>,
    TViewerContext extends ViewerContext,
    TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
    TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -226,17 +220,39 @@ export default class EntityCompanionProvider {
    });
  }

+  getQueryContextProviderForDatabaseAdaptorFlavor(
+    databaseAdapterFlavor: DatabaseAdapterFlavor
+  ): EntityQueryContextProvider {
+    const entityDatabaseAdapterFlavor = this.databaseAdapterFlavors.get(databaseAdapterFlavor);
+    invariant(
+      entityDatabaseAdapterFlavor,
+      `No database adaptor configuration found for flavor: ${databaseAdapterFlavor}`
+    );
+
+    return entityDatabaseAdapterFlavor.queryContextProvider;
+  }
+
  private getTableDataCoordinatorForEntity<TFields>(
    entityConfiguration: EntityConfiguration<TFields>,
    entityClassName: string
  ): EntityTableDataCoordinator<TFields> {
    return computeIfAbsent(this.tableDataCoordinatorMap, entityConfiguration.tableName, () => {
-      const entityDatabaseAdapterFlavor = this.databaseAdapterFlavors[
+      const entityDatabaseAdapterFlavor = this.databaseAdapterFlavors.get(
        entityConfiguration.databaseAdapterFlavor
-      ];
-      const entityCacheAdapterFlavor = this.cacheAdapterFlavors[
+      );
+      invariant(
+        entityDatabaseAdapterFlavor,
+        `No database adaptor configuration found for flavor: ${entityConfiguration.databaseAdapterFlavor}`
+      );
+
+      const entityCacheAdapterFlavor = this.cacheAdapterFlavors.get(
        entityConfiguration.cacheAdapterFlavor
-      ];
+      );
+      invariant(
+        entityCacheAdapterFlavor,
+        `No cache adaptor configuration found for flavor: ${entityConfiguration.cacheAdapterFlavor}`
+      );
+
      return new EntityTableDataCoordinator(
        entityConfiguration,
        entityDatabaseAdapterFlavor.adapterProvider,
@@ -1,61 +0,0 @@
-import ES6Error from 'es6-error';
-
-import { IEntityClass } from './Entity';
-import EntityPrivacyPolicy, { EntityAuthorizationAction } from './EntityPrivacyPolicy';
-import ReadonlyEntity from './ReadonlyEntity';
-import ViewerContext from './ViewerContext';
-
-export abstract class EntityError extends ES6Error {}
-
-export class EntityNotFoundError<
-  TFields,
-  TID,
-  TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TPrivacyPolicy extends EntityPrivacyPolicy<
-    TFields,
-    TID,
-    TViewerContext,
-    TEntity,
-    TSelectedFields
-  >,
-  N extends keyof TFields,
-  TSelectedFields extends keyof TFields = keyof TFields
-> extends EntityError {
-  constructor(
-    entityClass: IEntityClass<
-      TFields,
-      TID,
-      TViewerContext,
-      TEntity,
-      TPrivacyPolicy,
-      TSelectedFields
-    >,
-    fieldName: N,
-    fieldValue: TFields[N]
-  ) {
-    super(`Entity not found: ${entityClass.name} (${fieldName} = ${fieldValue})`);
-  }
-}
-
-export class EntityNotAuthorizedError<
-  TFields,
-  TID,
-  TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
-> extends EntityError {
-  public readonly entityClassName: string;
-
-  constructor(
-    entity: TEntity,
-    viewerContext: TViewerContext,
-    action: EntityAuthorizationAction,
-    ruleIndex: number
-  ) {
-    super(
-      `Entity not authorized: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${ruleIndex})`
-    );
-    this.entityClassName = entity.constructor.name;
-  }
-}
@@ -31,7 +31,7 @@ export enum EntityEdgeDeletionBehavior {
 export interface EntityAssociationDefinition<
  TViewerContext extends ViewerContext,
  TAssociatedFields,
-  TAssociatedID,
+  TAssociatedID extends NonNullable<TAssociatedFields[TAssociatedSelectedFields]>,
  TAssociatedEntity extends ReadonlyEntity<
    TAssociatedFields,
    TAssociatedID,
@@ -4,11 +4,11 @@ import invariant from 'invariant';
 import EnforcingEntityLoader from './EnforcingEntityLoader';
 import { IEntityClass } from './Entity';
 import { FieldEqualityCondition, QuerySelectionModifiers } from './EntityDatabaseAdapter';
-import { EntityNotFoundError } from './EntityErrors';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerContext from './ViewerContext';
+import EntityNotFoundError from './errors/EntityNotFoundError';
 import EntityDataManager from './internal/EntityDataManager';
 import { mapMap, mapMapAsync } from './utils/collections/maps';

@@ -18,7 +18,7 @@ import { mapMap, mapMapAsync } from './utils/collections/maps';
 */
 export default class EntityLoader<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -150,7 +150,7 @@ export default class EntityLoader<
    const entityResults = await this.loadManyByIDsAsync([id]);
    const entityResult = entityResults.get(id);
    if (entityResult === undefined) {
-      return result(new EntityNotFoundError(this.entityClass, this.idField, id as any));
+      return result(new EntityNotFoundError(this.entityClass, this.idField, id));
    }
    return entityResult;
  }
@@ -161,7 +161,7 @@ export default class EntityLoader<
   * @returns entity result for matching ID, or null if no entity exists for ID.
   */
  async loadByIDNullableAsync(id: TID): Promise<Result<TEntity> | null> {
-    return await this.loadByFieldEqualingAsync(this.idField, id as any);
+    return await this.loadByFieldEqualingAsync(this.idField, id);
  }

  /**
@@ -171,15 +171,13 @@ export default class EntityLoader<
   * @returns map from ID to corresponding entity result, where result error can be UnauthorizedError or EntityNotFoundError.
   */
  async loadManyByIDsAsync(ids: readonly TID[]): Promise<ReadonlyMap<TID, Result<TEntity>>> {
-    const entityResults = ((await this.loadManyByFieldEqualingManyAsync(
+    const entityResults = (await this.loadManyByFieldEqualingManyAsync(
      this.idField,
-      ids as any
-    )) as any) as ReadonlyMap<TID, readonly Result<TEntity>[]>;
+      ids
+    )) as ReadonlyMap<TID, readonly Result<TEntity>[]>;
    return mapMap(entityResults, (entityResultsForId, id) => {
      const entityResult = entityResultsForId[0];
-      return (
-        entityResult ?? result(new EntityNotFoundError(this.entityClass, this.idField, id as any))
-      );
+      return entityResult ?? result(new EntityNotFoundError(this.entityClass, this.idField, id));
    });
  }

@@ -284,13 +282,6 @@ export default class EntityLoader<
    await this.dataManager.invalidateObjectFieldsAsync(objectFields);
  }

-  async invalidateFieldsTransactionalAsync(objectFields: Readonly<TFields>): Promise<void> {
-    await this.dataManager.invalidateObjectFieldsTransactionalAsync(
-      this.queryContext,
-      objectFields
-    );
-  }
-
  /**
   * Invalidate all caches for an entity. One potential use case would be to keep the entity
   * framework in sync with changes made to data outside of the framework.
@@ -11,7 +11,7 @@ import EntityDataManager from './internal/EntityDataManager';
 */
 export default class EntityLoaderFactory<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -7,7 +7,7 @@ import ViewerContext from './ViewerContext';
 */
 export default interface EntityMutationTriggerConfiguration<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
@@ -70,12 +70,12 @@ export default interface EntityMutationTriggerConfiguration<
 */
 export abstract class EntityMutationTrigger<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
 > {
-  abstract async executeAsync(
+  abstract executeAsync(
    viewerContext: TViewerContext,
    queryContext: EntityQueryContext,
    entity: TEntity
@@ -88,10 +88,10 @@ export abstract class EntityMutationTrigger<
 */
 export abstract class EntityNonTransactionalMutationTrigger<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
 > {
-  abstract async executeAsync(viewerContext: TViewerContext, entity: TEntity): Promise<void>;
+  abstract executeAsync(viewerContext: TViewerContext, entity: TEntity): Promise<void>;
 }
@@ -8,12 +8,12 @@ import ViewerContext from './ViewerContext';
 */
 export default abstract class EntityMutationValidator<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
 > {
-  abstract async executeAsync(
+  abstract executeAsync(
    viewerContext: TViewerContext,
    queryContext: EntityQueryContext,
    entity: TEntity
@@ -21,7 +21,7 @@ import { mapMapAsync } from './utils/collections/maps';

 abstract class BaseMutator<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -114,7 +114,7 @@ abstract class BaseMutator<
 */
 export class CreateMutator<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -205,7 +205,6 @@ export class CreateMutator<
    queryContext.appendPostCommitCallback(
      entityLoader.invalidateFieldsAsync.bind(entityLoader, insertResult)
    );
-    await entityLoader.invalidateFieldsTransactionalAsync(insertResult);

    const unauthorizedEntityAfterInsert = new this.entityClass(this.viewerContext, insertResult);
    const newEntity = await entityLoader
@@ -240,7 +239,7 @@ export class CreateMutator<
 */
 export class UpdateMutator<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -396,11 +395,6 @@ export class UpdateMutator<
      entityLoader.invalidateFieldsAsync.bind(entityLoader, this.fieldsForEntity)
    );

-    await Promise.all([
-      entityLoader.invalidateFieldsTransactionalAsync(this.originalFieldsForEntity),
-      entityLoader.invalidateFieldsTransactionalAsync(this.fieldsForEntity),
-    ]);
-
    const unauthorizedEntityAfterUpdate = new this.entityClass(this.viewerContext, updateResult);
    const updatedEntity = await entityLoader
      .enforcing()
@@ -434,7 +428,7 @@ export class UpdateMutator<
 */
 export class DeleteMutator<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -543,7 +537,7 @@ export class DeleteMutator<
      return authorizeDeleteResult;
    }

-    await DeleteMutator.processEntityDeletionForInboundEdgesAsync(
+    await this.processEntityDeletionForInboundEdgesAsync(
      this.entity,
      queryContext,
      processedEntityIdentifiersFromTransitiveDeletions
@@ -572,7 +566,6 @@ export class DeleteMutator<
    queryContext.appendPostCommitCallback(
      entityLoader.invalidateFieldsAsync.bind(entityLoader, this.entity.getAllDatabaseFields())
    );
-    await entityLoader.invalidateFieldsTransactionalAsync(this.entity.getAllDatabaseFields());

    await this.executeMutationTriggersOrValidatorsAsync(
      this.mutationTriggers.afterDelete,
@@ -610,14 +603,8 @@ export class DeleteMutator<
   *
   * @param entity - entity to find all references to
   */
-  private static async processEntityDeletionForInboundEdgesAsync<
-    TMFields,
-    TMID,
-    TMViewerContext extends ViewerContext,
-    TMEntity extends Entity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
-    TMSelectedFields extends keyof TMFields
-  >(
-    entity: TMEntity,
+  private async processEntityDeletionForInboundEdgesAsync(
+    entity: TEntity,
    queryContext: EntityTransactionalQueryContext,
    processedEntityIdentifiers: Set<string>
  ): Promise<void> {
@@ -628,12 +615,12 @@ export class DeleteMutator<
    processedEntityIdentifiers.add(entity.getUniqueIdentifier());

    const companionDefinition = (entity.constructor as any).getCompanionDefinition() as EntityCompanionDefinition<
-      TMFields,
-      TMID,
-      TMViewerContext,
-      TMEntity,
-      EntityPrivacyPolicy<TMFields, TMID, TMViewerContext, TMEntity, TMSelectedFields>,
-      TMSelectedFields
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TPrivacyPolicy,
+      TSelectedFields
    >;
    const entityConfiguration = companionDefinition.entityConfiguration;
    const inboundEdges = entityConfiguration.getInboundEdges();
@@ -15,7 +15,7 @@ import IEntityMetricsAdapter from './metrics/IEntityMetricsAdapter';
 */
 export default class EntityMutatorFactory<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -1,7 +1,7 @@
-import { EntityNotAuthorizedError } from './EntityErrors';
 import { EntityQueryContext } from './EntityQueryContext';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerContext from './ViewerContext';
+import EntityNotAuthorizedError from './errors/EntityNotAuthorizedError';
 import PrivacyPolicyRule, { RuleEvaluationResult } from './rules/PrivacyPolicyRule';

 export enum EntityPrivacyPolicyEvaluationMode {
@@ -12,7 +12,7 @@ export enum EntityPrivacyPolicyEvaluationMode {

 export type EntityPrivacyPolicyEvaluator<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
@@ -63,7 +63,7 @@ export enum EntityAuthorizationAction {
 */
 export default abstract class EntityPrivacyPolicy<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
@@ -265,7 +265,13 @@ export default abstract class EntityPrivacyPolicy<
      const ruleEvaluationResult = await rule.evaluateAsync(viewerContext, queryContext, entity);
      switch (ruleEvaluationResult) {
        case RuleEvaluationResult.DENY:
-          throw new EntityNotAuthorizedError(entity, viewerContext, action, i);
+          throw new EntityNotAuthorizedError<
+            TFields,
+            TID,
+            TViewerContext,
+            TEntity,
+            TSelectedFields
+          >(entity, viewerContext, action, i);
        case RuleEvaluationResult.SKIP:
          continue;
        case RuleEvaluationResult.ALLOW:
@@ -275,6 +281,11 @@ export default abstract class EntityPrivacyPolicy<
      }
    }

-    throw new EntityNotAuthorizedError(entity, viewerContext, action, -1);
+    throw new EntityNotAuthorizedError<TFields, TID, TViewerContext, TEntity, TSelectedFields>(
+      entity,
+      viewerContext,
+      action,
+      -1
+    );
  }
 }
@@ -1,5 +1,3 @@
-import { v4 as uuidv4 } from 'uuid';
-
 import EntityQueryContextProvider from './EntityQueryContextProvider';

 export type PostCommitCallback = (...args: any) => Promise<any>;
@@ -14,13 +12,13 @@ export type PostCommitCallback = (...args: any) => Promise<any>;
 export abstract class EntityQueryContext {
  constructor(private readonly queryInterface: any) {}

-  abstract isInTransaction(): this is EntityTransactionalQueryContext;
+  abstract isInTransaction(): boolean;

  getQueryInterface(): any {
    return this.queryInterface;
  }

-  abstract async runInTransactionIfNotInTransactionAsync<T>(
+  abstract runInTransactionIfNotInTransactionAsync<T>(
    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>
  ): Promise<T>;
 }
@@ -33,7 +31,7 @@ export class EntityNonTransactionalQueryContext extends EntityQueryContext {
    super(queryInterface);
  }

-  isInTransaction(): this is EntityTransactionalQueryContext {
+  isInTransaction(): boolean {
    return false;
  }

@@ -45,8 +43,6 @@ export class EntityNonTransactionalQueryContext extends EntityQueryContext {
 }

 export class EntityTransactionalQueryContext extends EntityQueryContext {
-  public readonly transactionID = uuidv4();
-
  private readonly postCommitCallbacks: PostCommitCallback[] = [];

  public appendPostCommitCallback(callback: PostCommitCallback): void {
@@ -59,7 +55,7 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
    await Promise.all(callbacks.map((callback) => callback()));
  }

-  isInTransaction(): this is EntityTransactionalQueryContext {
+  isInTransaction(): boolean {
    return true;
  }

@@ -5,7 +5,7 @@ import EntityAssociationLoader from './EntityAssociationLoader';
 import { EntityCompanionDefinition } from './EntityCompanionProvider';
 import EntityLoader from './EntityLoader';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
-import { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext';
+import { EntityQueryContext } from './EntityQueryContext';
 import ViewerContext from './ViewerContext';
 import { pick } from './entityUtils';

@@ -19,7 +19,7 @@ import { pick } from './entityUtils';
 */
 export default abstract class ReadonlyEntity<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TSelectedFields extends keyof TFields = keyof TFields
 > {
@@ -118,80 +118,6 @@ export default abstract class ReadonlyEntity<
    return { ...this.databaseFields };
  }

-  /**
-   * Get the regular (non-transactional) query context for this entity.
-   * @param viewerContext - viewer context of calling user
-   */
-  static getQueryContext<
-    TMFields,
-    TMID,
-    TMViewerContext extends ViewerContext,
-    TMViewerContext2 extends TMViewerContext,
-    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
-    TMPrivacyPolicy extends EntityPrivacyPolicy<
-      TMFields,
-      TMID,
-      TMViewerContext,
-      TMEntity,
-      TMSelectedFields
-    >,
-    TMSelectedFields extends keyof TMFields = keyof TMFields
-  >(
-    this: IEntityClass<
-      TMFields,
-      TMID,
-      TMViewerContext,
-      TMEntity,
-      TMPrivacyPolicy,
-      TMSelectedFields
-    >,
-    viewerContext: TMViewerContext2
-  ): EntityQueryContext {
-    return viewerContext
-      .getViewerScopedEntityCompanionForClass(this)
-      .getQueryContextProvider()
-      .getQueryContext();
-  }
-
-  /**
-   * Start a transaction and execute the provided transaction-scoped closure within the transaction.
-   * @param viewerContext - viewer context of calling user
-   * @param transactionScope - async callback to execute within the transaction
-   */
-  static async runInTransactionAsync<
-    TResult,
-    TMFields,
-    TMID,
-    TMViewerContext extends ViewerContext,
-    TMViewerContext2 extends TMViewerContext,
-    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
-    TMPrivacyPolicy extends EntityPrivacyPolicy<
-      TMFields,
-      TMID,
-      TMViewerContext,
-      TMEntity,
-      TMSelectedFields
-    >,
-    TMSelectedFields extends keyof TMFields = keyof TMFields
-  >(
-    this: IEntityClass<
-      TMFields,
-      TMID,
-      TMViewerContext,
-      TMEntity,
-      TMPrivacyPolicy,
-      TMSelectedFields
-    >,
-    viewerContext: TMViewerContext2,
-    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<TResult>
-  ): Promise<TResult> {
-    return await viewerContext
-      .getViewerScopedEntityCompanionForClass(this)
-      .getQueryContextProvider()
-      .getQueryContext()
-      .runInTransactionIfNotInTransactionAsync(transactionScope);
-  }
-
  /**
   * Vend loader for loading an entity in a given query context.
   * @param viewerContext - viewer context of loading user
@@ -199,7 +125,7 @@ export default abstract class ReadonlyEntity<
   */
  static loader<
    TMFields,
-    TMID,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
    TMViewerContext extends ViewerContext,
    TMViewerContext2 extends TMViewerContext,
    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
@@ -1,6 +1,7 @@
 import { IEntityClass } from './Entity';
-import EntityCompanionProvider from './EntityCompanionProvider';
+import EntityCompanionProvider, { DatabaseAdapterFlavor } from './EntityCompanionProvider';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
+import { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerScopedEntityCompanion from './ViewerScopedEntityCompanion';
 import ViewerScopedEntityCompanionProvider from './ViewerScopedEntityCompanionProvider';
@@ -27,7 +28,7 @@ export default class ViewerContext {

  getViewerScopedEntityCompanionForClass<
    TMFields,
-    TMID,
+    TMID extends NonNullable<TMFields[TMSelectedFields]>,
    TMViewerContext extends ViewerContext,
    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
    TMPrivacyPolicy extends EntityPrivacyPolicy<
@@ -60,4 +61,32 @@ export default class ViewerContext {
      entityClass.getCompanionDefinition()
    );
  }
+
+  /**
+   * Get the regular (non-transactional) query context for a database adaptor flavor.
+   * @param databaseAdaptorFlavor - database adaptor flavor
+   */
+  getQueryContextForDatabaseAdaptorFlavor(
+    databaseAdaptorFlavor: DatabaseAdapterFlavor
+  ): EntityQueryContext {
+    return this.entityCompanionProvider
+      .getQueryContextProviderForDatabaseAdaptorFlavor(databaseAdaptorFlavor)
+      .getQueryContext();
+  }
+
+  /**
+   * Run a transaction of specified database adaptor flavor and execute the provided
+   * transaction-scoped closure within the transaction.
+   * @param databaseAdaptorFlavor - databaseAdaptorFlavor
+   * @param transactionScope - async callback to execute within the transaction
+   */
+  async runInTransactionForDatabaseAdaptorFlavorAsync<TResult>(
+    databaseAdaptorFlavor: DatabaseAdapterFlavor,
+    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<TResult>
+  ): Promise<TResult> {
+    return await this.entityCompanionProvider
+      .getQueryContextProviderForDatabaseAdaptorFlavor(databaseAdaptorFlavor)
+      .getQueryContext()
+      .runInTransactionIfNotInTransactionAsync(transactionScope);
+  }
 }
@@ -12,7 +12,7 @@ import ViewerScopedEntityMutatorFactory from './ViewerScopedEntityMutatorFactory
 */
 export default class ViewerScopedEntityCompanion<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -23,7 +23,7 @@ export default class ViewerScopedEntityCompanionProvider {
   */
  getViewerScopedCompanionForEntity<
    TFields,
-    TID,
+    TID extends NonNullable<TFields[TSelectedFields]>,
    TViewerContext extends ViewerContext,
    TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
    TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -10,7 +10,7 @@ import ViewerContext from './ViewerContext';
 */
 export default class ViewerScopedEntityLoaderFactory<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -10,7 +10,7 @@ import ViewerContext from './ViewerContext';
 */
 export default class ViewerScopedEntityMutatorFactory<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TPrivacyPolicy extends EntityPrivacyPolicy<
@@ -287,7 +287,6 @@ describe(EnforcingEntityLoader, () => {
      'enforcing',
      'invalidateFieldsAsync',
      'invalidateEntityAsync',
-      'invalidateFieldsTransactionalAsync',
      'tryConstructEntities',
    ];
    expect(loaderProperties).toEqual(expect.arrayContaining(knownLoaderOnlyDifferences));
@@ -1,9 +1,5 @@
 import Entity from '../Entity';
-import {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
 import { CreateMutator, UpdateMutator } from '../EntityMutator';
@@ -96,8 +92,8 @@ const testEntityConfiguration = new EntityConfiguration<TestEntityFields>({
      columnName: 'custom_id',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 class SimpleTestDenyUpdateEntityPrivacyPolicy extends EntityPrivacyPolicy<
@@ -106,10 +102,38 @@ class SimpleTestDenyUpdateEntityPrivacyPolicy extends EntityPrivacyPolicy<
  ViewerContext,
  SimpleTestDenyUpdateEntity
 > {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysDenyPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestEntityFields,
+      string,
+      ViewerContext,
+      SimpleTestDenyUpdateEntity
+    >(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestEntityFields,
+      string,
+      ViewerContext,
+      SimpleTestDenyUpdateEntity
+    >(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysDenyPrivacyPolicyRule<
+      TestEntityFields,
+      string,
+      ViewerContext,
+      SimpleTestDenyUpdateEntity
+    >(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestEntityFields,
+      string,
+      ViewerContext,
+      SimpleTestDenyUpdateEntity
+    >(),
+  ];
 }

 class SimpleTestDenyDeleteEntityPrivacyPolicy extends EntityPrivacyPolicy<
@@ -118,10 +142,38 @@ class SimpleTestDenyDeleteEntityPrivacyPolicy extends EntityPrivacyPolicy<
  ViewerContext,
  SimpleTestDenyDeleteEntity
 > {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysDenyPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestEntityFields,
+      string,
+      ViewerContext,
+      SimpleTestDenyDeleteEntity
+    >(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestEntityFields,
+      string,
+      ViewerContext,
+      SimpleTestDenyDeleteEntity
+    >(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestEntityFields,
+      string,
+      ViewerContext,
+      SimpleTestDenyDeleteEntity
+    >(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysDenyPrivacyPolicyRule<
+      TestEntityFields,
+      string,
+      ViewerContext,
+      SimpleTestDenyDeleteEntity
+    >(),
+  ];
 }

 class SimpleTestDenyUpdateEntity extends Entity<TestEntityFields, string, ViewerContext> {
@@ -1,18 +1,14 @@
 import { enforceAsyncResult } from '@expo/results';

 import Entity from '../Entity';
-import EntityCompanionProvider, {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import EntityCompanionProvider, { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
-import { EntityNotAuthorizedError } from '../EntityErrors';
 import { UUIDField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
 import ViewerContext from '../ViewerContext';
 import { enforceResultsAsync } from '../entityUtils';
+import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
 import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
 import AlwaysDenyPrivacyPolicyRule from '../rules/AlwaysDenyPrivacyPolicyRule';
 import PrivacyPolicyRule, { RuleEvaluationResult } from '../rules/PrivacyPolicyRule';
@@ -100,8 +96,8 @@ const blahCompanion = new EntityCompanionDefinition({
        columnName: 'owner_id',
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  }),
  privacyPolicyClass: BlahEntityPrivacyPolicy,
 });
@@ -8,11 +8,12 @@ import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
 import TestEntity, {
  TestEntityPrivacyPolicy,
  testEntityConfiguration,
+  TestFields,
 } from '../testfixtures/TestEntity';

 describe(EntityCompanion, () => {
  it('correctly instantiates mutator and loader factories', () => {
-    const tableDataCoordinatorMock = mock(EntityTableDataCoordinator);
+    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestFields>>();
    when(tableDataCoordinatorMock.entityConfiguration).thenReturn(testEntityConfiguration);

    const companion = new EntityCompanion(
@@ -1,9 +1,5 @@
 import Entity from '../Entity';
-import EntityCompanionProvider, {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import EntityCompanionProvider, { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { StringField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
@@ -22,8 +18,8 @@ const blahConfiguration = new EntityConfiguration<BlahFields>({
      columnName: 'hello',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 class Blah1Entity extends Entity<BlahFields, string, ViewerContext> {
@@ -1,4 +1,3 @@
-import { DatabaseAdapterFlavor, CacheAdapterFlavor } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField, StringField } from '../EntityFields';

@@ -28,15 +27,15 @@ describe(EntityConfiguration, () => {
        columnName: 'unique_but_not_cacheable',
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  });

  it('returns correct fields', () => {
    expect(blahEntityConfiguration.idField).toEqual('id');
    expect(blahEntityConfiguration.tableName).toEqual('blah_table');
-    expect(blahEntityConfiguration.databaseAdapterFlavor).toEqual(DatabaseAdapterFlavor.POSTGRES);
-    expect(blahEntityConfiguration.cacheAdapterFlavor).toEqual(CacheAdapterFlavor.REDIS);
+    expect(blahEntityConfiguration.databaseAdapterFlavor).toEqual('postgres');
+    expect(blahEntityConfiguration.cacheAdapterFlavor).toEqual('redis');
  });

  it('filters cacheable fields', () => {
@@ -53,8 +52,8 @@ describe(EntityConfiguration, () => {
            columnName: 'id',
          }),
        },
-        databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-        cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+        databaseAdapterFlavor: 'postgres',
+        cacheAdapterFlavor: 'redis',
      });
      expect(entityConfiguration.cacheKeyVersion).toEqual(0);
    });
@@ -68,8 +67,8 @@ describe(EntityConfiguration, () => {
            columnName: 'id',
          }),
        },
-        databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-        cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+        databaseAdapterFlavor: 'postgres',
+        cacheAdapterFlavor: 'redis',
        cacheKeyVersion: 100,
      });
      expect(entityConfiguration.cacheKeyVersion).toEqual(100);
@@ -1,9 +1,5 @@
 import Entity from '../Entity';
-import {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField, EntityEdgeDeletionBehavior } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
@@ -34,10 +30,18 @@ class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
  any,
  any
 > {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, TestViewerContext, any, any>(),
+  ];
 }

 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -88,8 +92,8 @@ const makeEntityClasses = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) =>
        cache: true,
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  });

  const childEntityConfiguration = new EntityConfiguration<ChildFields>({
@@ -110,8 +114,8 @@ const makeEntityClasses = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) =>
        },
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  });

  const grandChildEntityConfiguration = new EntityConfiguration<GrandChildFields>({
@@ -131,8 +135,8 @@ const makeEntityClasses = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) =>
        },
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  });

  const parentEntityCompanion = new EntityCompanionDefinition({
@@ -227,7 +227,7 @@ describe(EntityLoader, () => {
    const viewerContext = instance(mock(ViewerContext));
    const queryContext = StubQueryContextProvider.getQueryContext();
    const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
-    const dataManagerMock = mock(EntityDataManager);
+    const dataManagerMock = mock<EntityDataManager<TestFields>>();
    const dataManagerInstance = instance(dataManagerMock);

    const entityLoader = new EntityLoader(
@@ -241,7 +241,7 @@ describe(EntityLoader, () => {
    await entityLoader.invalidateFieldsAsync({ customIdField: 'hello' } as any);

    verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: 'hello' }))
+      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: 'hello' } as any))
    ).once();
  });

@@ -249,7 +249,7 @@ describe(EntityLoader, () => {
    const viewerContext = instance(mock(ViewerContext));
    const queryContext = StubQueryContextProvider.getQueryContext();
    const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
-    const dataManagerMock = mock(EntityDataManager);
+    const dataManagerMock = mock<EntityDataManager<TestFields>>();
    const dataManagerInstance = instance(dataManagerMock);

    const entityLoader = new EntityLoader(
@@ -262,7 +262,7 @@ describe(EntityLoader, () => {
    );
    await entityLoader.invalidateFieldsAsync({ customIdField: 'hello' } as any);
    verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: 'hello' }))
+      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: 'hello' } as any))
    ).once();
  });

@@ -270,7 +270,7 @@ describe(EntityLoader, () => {
    const viewerContext = instance(mock(ViewerContext));
    const queryContext = StubQueryContextProvider.getQueryContext();
    const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
-    const dataManagerMock = mock(EntityDataManager);
+    const dataManagerMock = mock<EntityDataManager<TestFields>>();
    const dataManagerInstance = instance(dataManagerMock);

    const entityMock = mock(TestEntity);
@@ -287,7 +287,7 @@ describe(EntityLoader, () => {
    );
    await entityLoader.invalidateEntityAsync(entityInstance);
    verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: 'hello' }))
+      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: 'hello' } as any))
    ).once();
  });

@@ -295,7 +295,7 @@ describe(EntityLoader, () => {
    const viewerContext = instance(mock(ViewerContext));
    const queryContext = StubQueryContextProvider.getQueryContext();
    const privacyPolicyMock = mock(TestEntityPrivacyPolicy);
-    const dataManagerMock = mock(EntityDataManager);
+    const dataManagerMock = mock<EntityDataManager<TestFields>>();

    when(
      dataManagerMock.loadManyByFieldEqualingAsync(anything(), anything(), anything())
@@ -329,7 +329,7 @@ describe(EntityLoader, () => {
    const viewerContext = instance(mock(ViewerContext));
    const queryContext = StubQueryContextProvider.getQueryContext();
    const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
-    const dataManagerMock = mock(EntityDataManager);
+    const dataManagerMock = mock<EntityDataManager<TestFields>>();

    const error = new Error();

@@ -784,7 +784,7 @@ describe(EntityMutatorFactory, () => {
    const viewerContext = instance(mock(ViewerContext));
    const queryContext = StubQueryContextProvider.getQueryContext();
    const privacyPolicyMock = mock(SimpleTestEntityPrivacyPolicy);
-    const databaseAdapter = instance(mock(EntityDatabaseAdapter));
+    const databaseAdapter = instance(mock<EntityDatabaseAdapter<SimpleTestFields>>());
    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
    const entityLoaderFactory = instance(
      mock<
@@ -864,7 +864,7 @@ describe(EntityMutatorFactory, () => {
    const viewerContext = instance(mock(ViewerContext));
    const queryContext = StubQueryContextProvider.getQueryContext();
    const privacyPolicy = instance(mock(SimpleTestEntityPrivacyPolicy));
-    const databaseAdapterMock = mock(EntityDatabaseAdapter);
+    const databaseAdapterMock = mock<EntityDatabaseAdapter<SimpleTestFields>>();
    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
    const entityLoaderFactory = instance(
      mock<
@@ -1,13 +1,8 @@
 import { mock, instance, spy, verify, anyOfClass } from 'ts-mockito';

 import Entity from '../Entity';
-import {
-  EntityCompanionDefinition,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
-import { EntityNotAuthorizedError } from '../EntityErrors';
 import { UUIDField } from '../EntityFields';
 import EntityPrivacyPolicy, {
  EntityPrivacyPolicyEvaluator,
@@ -15,6 +10,7 @@ import EntityPrivacyPolicy, {
 } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
 import ViewerContext from '../ViewerContext';
+import EntityNotAuthorizedError from '../errors/EntityNotAuthorizedError';
 import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
 import AlwaysDenyPrivacyPolicyRule from '../rules/AlwaysDenyPrivacyPolicyRule';
 import AlwaysSkipPrivacyPolicyRule from '../rules/AlwaysSkipPrivacyPolicyRule';
@@ -234,8 +230,8 @@ const blahEntityCompanionDefinition = new EntityCompanionDefinition({
        columnName: 'id',
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  }),
  privacyPolicyClass: AlwaysDenyPolicy,
 });
@@ -1,9 +1,5 @@
 import Entity from '../Entity';
-import {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField, EntityEdgeDeletionBehavior } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
@@ -25,10 +21,18 @@ class CategoryPrivacyPolicy extends EntityPrivacyPolicy<
  any,
  any
 > {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<CategoryFields, string, TestViewerContext, any, any>(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<CategoryFields, string, TestViewerContext, any, any>(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<CategoryFields, string, TestViewerContext, any, any>(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<CategoryFields, string, TestViewerContext, any, any>(),
+  ];
 }

 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
@@ -63,8 +67,8 @@ const makeEntityClass = (edgeDeletionBehavior: EntityEdgeDeletionBehavior) => {
        },
      }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  });

  const categoryEntityCompanion = new EntityCompanionDefinition({
@@ -2,7 +2,6 @@ import { instance, mock } from 'ts-mockito';

 import EntityAssociationLoader from '../EntityAssociationLoader';
 import EntityLoader from '../EntityLoader';
-import { EntityQueryContext } from '../EntityQueryContext';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
 import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
@@ -108,30 +107,6 @@ describe(ReadonlyEntity, () => {
    });
  });

-  describe('getRegularEntityQueryContext', () => {
-    it('creates a new regular query context', () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new ViewerContext(companionProvider);
-      const queryContext = SimpleTestEntity.getQueryContext(viewerContext);
-      expect(queryContext).toBeInstanceOf(EntityQueryContext);
-      expect(queryContext.isInTransaction()).toBe(false);
-    });
-  });
-
-  describe('runInTransactionAsync', () => {
-    it('creates a new transactional query context', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new ViewerContext(companionProvider);
-      const didCreateTransaction = await SimpleTestEntity.runInTransactionAsync(
-        viewerContext,
-        async (queryContext) => {
-          return queryContext.isInTransaction();
-        }
-      );
-      expect(didCreateTransaction).toBe(true);
-    });
-  });
-
  describe('loader', () => {
    it('creates a new EntityLoader', async () => {
      const companionProvider = createUnitTestEntityCompanionProvider();
@@ -0,0 +1,29 @@
+import { EntityQueryContext } from '../EntityQueryContext';
+import ViewerContext from '../ViewerContext';
+import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
+
+describe(ViewerContext, () => {
+  describe('getQueryContextForDatabaseAdaptorFlavor', () => {
+    it('creates a new regular query context', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const queryContext = viewerContext.getQueryContextForDatabaseAdaptorFlavor('postgres');
+      expect(queryContext).toBeInstanceOf(EntityQueryContext);
+      expect(queryContext.isInTransaction()).toBe(false);
+    });
+  });
+
+  describe('runInTransactionForDatabaseAdaptorFlavorAsync', () => {
+    it('creates a new transactional query context', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const didCreateTransaction = await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          return queryContext.isInTransaction();
+        }
+      );
+      expect(didCreateTransaction).toBe(true);
+    });
+  });
+});
@@ -1,9 +1,5 @@
 import Entity from '../../Entity';
-import {
-  EntityCompanionDefinition,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-} from '../../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
 import { UUIDField, EnumField, StringField } from '../../EntityFields';
 import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
@@ -106,15 +102,23 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
      columnName: 'entity_type',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
 }

 class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
@@ -1,9 +1,5 @@
 import Entity from '../../Entity';
-import {
-  EntityCompanionDefinition,
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-} from '../../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
 import { UUIDField, StringField } from '../../EntityFields';
 import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
@@ -114,15 +110,23 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
      cache: true,
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
-  protected readonly readRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly createRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly updateRules = [new AlwaysAllowPrivacyPolicyRule()];
-  protected readonly deleteRules = [new AlwaysAllowPrivacyPolicyRule()];
+  protected readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
+  protected readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
+  ];
 }

 class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
@@ -0,0 +1,8 @@
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
+
+export default abstract class EntityCacheAdapterError extends EntityError {}
+
+export class EntityCacheAdapterTransientError extends EntityCacheAdapterError {
+  public readonly state = EntityErrorState.TRANSIENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_CACHE_ADAPTER_TRANSIENT;
+}
@@ -0,0 +1,38 @@
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
+
+export default abstract class EntityDatabaseAdapterError extends EntityError {}
+
+export class EntityDatabaseAdapterTransientError extends EntityDatabaseAdapterError {
+  public readonly state = EntityErrorState.TRANSIENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT;
+}
+
+export class EntityDatabaseAdapterUnknownError extends EntityDatabaseAdapterError {
+  public readonly state = EntityErrorState.UNKNOWN;
+  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN;
+}
+
+export class EntityDatabaseAdapterCheckConstraintError extends EntityDatabaseAdapterError {
+  public readonly state = EntityErrorState.PERMANENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT;
+}
+
+export class EntityDatabaseAdapterExclusionConstraintError extends EntityDatabaseAdapterError {
+  public readonly state = EntityErrorState.PERMANENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT;
+}
+
+export class EntityDatabaseAdapterForeignKeyConstraintError extends EntityDatabaseAdapterError {
+  public readonly state = EntityErrorState.PERMANENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT;
+}
+
+export class EntityDatabaseAdapterNotNullConstraintError extends EntityDatabaseAdapterError {
+  public readonly state = EntityErrorState.PERMANENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT;
+}
+
+export class EntityDatabaseAdapterUniqueConstraintError extends EntityDatabaseAdapterError {
+  public readonly state = EntityErrorState.PERMANENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT;
+}
@@ -0,0 +1,29 @@
+import ES6Error from 'es6-error';
+
+export enum EntityErrorState {
+  UNKNOWN,
+  TRANSIENT,
+  PERMANENT,
+}
+
+export enum EntityErrorCode {
+  ERR_ENTITY_NOT_AUTHORIZED = 'ERR_ENTITY_NOT_AUTHORIZED',
+  ERR_ENTITY_NOT_FOUND = 'ERR_ENTITY_NOT_FOUND',
+  ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT = 'ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT',
+  ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN = 'ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN',
+  ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT = 'ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT',
+  ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT = 'ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT',
+  ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT = 'ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT',
+  ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT = 'ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT',
+  ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT = 'ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT',
+  ERR_ENTITY_CACHE_ADAPTER_TRANSIENT = 'ERR_ENTITY_CACHE_ADAPTER_TRANSIENT',
+}
+
+export default abstract class EntityError extends ES6Error {
+  public abstract readonly state: EntityErrorState;
+  public abstract readonly code: EntityErrorCode;
+
+  constructor(message: string, public readonly cause?: Error) {
+    super(message);
+  }
+}
@@ -0,0 +1,29 @@
+import { EntityAuthorizationAction } from '../EntityPrivacyPolicy';
+import ReadonlyEntity from '../ReadonlyEntity';
+import ViewerContext from '../ViewerContext';
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
+
+export default class EntityNotAuthorizedError<
+  TFields,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields = keyof TFields
+> extends EntityError {
+  public readonly state = EntityErrorState.PERMANENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED;
+
+  public readonly entityClassName: string;
+
+  constructor(
+    entity: TEntity,
+    viewerContext: TViewerContext,
+    action: EntityAuthorizationAction,
+    ruleIndex: number
+  ) {
+    super(
+      `Entity not authorized: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${ruleIndex})`
+    );
+    this.entityClassName = entity.constructor.name;
+  }
+}
@@ -0,0 +1,39 @@
+import { IEntityClass } from '../Entity';
+import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import ReadonlyEntity from '../ReadonlyEntity';
+import ViewerContext from '../ViewerContext';
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
+
+export default class EntityNotFoundError<
+  TFields,
+  TID extends NonNullable<TFields[TSelectedFields]>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TID,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
+  N extends keyof TFields,
+  TSelectedFields extends keyof TFields = keyof TFields
+> extends EntityError {
+  public readonly state = EntityErrorState.PERMANENT;
+  public readonly code = EntityErrorCode.ERR_ENTITY_NOT_FOUND;
+
+  constructor(
+    entityClass: IEntityClass<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TPrivacyPolicy,
+      TSelectedFields
+    >,
+    fieldName: N,
+    fieldValue: TFields[N]
+  ) {
+    super(`Entity not found: ${entityClass.name} (${fieldName} = ${fieldValue})`);
+  }
+}
@@ -11,7 +11,14 @@ export * from './EntityCompanionProvider';
 export { default as EntityConfiguration } from './EntityConfiguration';
 export { default as EntityDatabaseAdapter } from './EntityDatabaseAdapter';
 export * from './EntityDatabaseAdapter';
-export * from './EntityErrors';
+export { default as EntityDatabaseAdapterError } from './errors/EntityDatabaseAdapterError';
+export * from './errors/EntityDatabaseAdapterError';
+export { default as EntityCacheAdapterError } from './errors/EntityCacheAdapterError';
+export * from './errors/EntityCacheAdapterError';
+export * from './errors/EntityError';
+export { default as EntityError } from './errors/EntityError';
+export { default as EntityNotAuthorizedError } from './errors/EntityNotAuthorizedError';
+export { default as EntityNotFoundError } from './errors/EntityNotFoundError';
 export * from './EntityFields';
 export { default as EntityLoader } from './EntityLoader';
 export { default as EntityLoaderFactory } from './EntityLoaderFactory';
@@ -4,7 +4,7 @@ import EntityDatabaseAdapter, {
  FieldEqualityCondition,
  QuerySelectionModifiers,
 } from '../EntityDatabaseAdapter';
-import { EntityQueryContext, EntityTransactionalQueryContext } from '../EntityQueryContext';
+import { EntityQueryContext } from '../EntityQueryContext';
 import EntityQueryContextProvider from '../EntityQueryContextProvider';
 import { partitionErrors } from '../entityUtils';
 import {
@@ -15,13 +15,6 @@ import IEntityMetricsAdapter, { EntityMetricsLoadType } from '../metrics/IEntity
 import { computeIfAbsent, zipToMap } from '../utils/collections/maps';
 import ReadThroughEntityCache from './ReadThroughEntityCache';

-type FieldDataLoader<TFields> = DataLoader<
-  NonNullable<TFields[keyof TFields]>,
-  readonly Readonly<TFields>[]
->;
-
-type FieldDataLoadersMap<TFields> = Map<keyof TFields, FieldDataLoader<TFields>>;
-
 /**
 * A data manager is responsible for orchestrating multiple sources of entity
 * data including local caches, {@link EntityCacheAdapter}, and {@link EntityDatabaseAdapter}.
@@ -29,11 +22,9 @@ type FieldDataLoadersMap<TFields> = Map<keyof TFields, FieldDataLoader<TFields>>
 * It is also responsible for invalidating all sources of data when mutated using {@link EntityMutator}.
 */
 export default class EntityDataManager<TFields> {
-  private readonly regularFieldDataLoaders: FieldDataLoadersMap<TFields> = new Map();
-
-  private readonly transactionalFieldDataLoaders: Map<
-    string,
-    FieldDataLoadersMap<TFields>
+  private readonly fieldDataLoaders: Map<
+    keyof TFields,
+    DataLoader<NonNullable<TFields[keyof TFields]>, readonly Readonly<TFields>[]>
  > = new Map();

  constructor(
@@ -44,10 +35,10 @@ export default class EntityDataManager<TFields> {
    private readonly entityClassName: string
  ) {}

-  private getRegularFieldDataLoderForFieldName<N extends keyof TFields>(
+  private getFieldDataLoaderForFieldName<N extends keyof TFields>(
    fieldName: N
-  ): FieldDataLoader<TFields> {
-    return computeIfAbsent(this.regularFieldDataLoaders, fieldName, () => {
+  ): DataLoader<NonNullable<TFields[N]>, readonly Readonly<TFields>[]> {
+    return computeIfAbsent(this.fieldDataLoaders, fieldName, () => {
      return new DataLoader(
        async (
          fieldValues: readonly NonNullable<TFields[N]>[]
@@ -62,43 +53,6 @@ export default class EntityDataManager<TFields> {
    });
  }

-  private getTransactionalFieldDataLoaderForFieldName<N extends keyof TFields>(
-    queryContext: EntityTransactionalQueryContext,
-    fieldName: N
-  ): FieldDataLoader<TFields> {
-    const fieldDataLoaderMap = computeIfAbsent(
-      this.transactionalFieldDataLoaders,
-      queryContext.transactionID,
-      () => new Map<keyof TFields, FieldDataLoader<TFields>>()
-    );
-    return computeIfAbsent(fieldDataLoaderMap, fieldName, () => {
-      return new DataLoader(
-        async (
-          fieldValues: readonly NonNullable<TFields[N]>[]
-        ): Promise<readonly (readonly TFields[])[]> => {
-          const objectMap = await this.loadManyForTransactionalDataLoaderByFieldEqualingAsync(
-            fieldName,
-            fieldValues,
-            queryContext
-          );
-          return fieldValues.map((fv) => objectMap.get(fv) ?? []);
-        }
-      );
-    });
-  }
-
-  private async loadManyForTransactionalDataLoaderByFieldEqualingAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-    queryContext: EntityTransactionalQueryContext
-  ): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
-    this.metricsAdapter.incrementDataManagerDatabaseLoadCount({
-      fieldValueCount: fieldValues.length,
-      entityClassName: this.entityClassName,
-    });
-    return await this.databaseAdapter.fetchManyWhereAsync(queryContext, fieldName, fieldValues);
-  }
-
  private async loadManyForDataLoaderByFieldEqualingAsync<N extends keyof TFields>(
    fieldName: N,
    fieldValues: readonly NonNullable<TFields[N]>[]
@@ -107,11 +61,10 @@ export default class EntityDataManager<TFields> {
      fieldValueCount: fieldValues.length,
      entityClassName: this.entityClassName,
    });
-
    return await this.entityCache.readManyThroughAsync(
      fieldName,
      fieldValues,
-      async (fetcherValues: readonly NonNullable<TFields[N]>[]) => {
+      async (fetcherValues) => {
        this.metricsAdapter.incrementDataManagerDatabaseLoadCount({
          fieldValueCount: fieldValues.length,
          entityClassName: this.entityClassName,
@@ -159,13 +112,16 @@ export default class EntityDataManager<TFields> {
      );
    }

+    // don't cache when in transaction, as rollbacks complicate things significantly
+    if (queryContext.isInTransaction()) {
+      return await this.databaseAdapter.fetchManyWhereAsync(queryContext, fieldName, fieldValues);
+    }
+
    this.metricsAdapter.incrementDataManagerDataloaderLoadCount({
      fieldValueCount: fieldValues.length,
      entityClassName: this.entityClassName,
    });
-    const dataLoader = queryContext.isInTransaction()
-      ? this.getTransactionalFieldDataLoaderForFieldName(queryContext, fieldName)
-      : this.getRegularFieldDataLoderForFieldName(fieldName);
+    const dataLoader = this.getFieldDataLoaderForFieldName(fieldName);
    const results = await dataLoader.loadMany(fieldValues);
    const [values, errors] = partitionErrors(results);
    if (errors.length > 0) {
@@ -236,20 +192,7 @@ export default class EntityDataManager<TFields> {
    fieldValues: readonly NonNullable<TFields[N]>[]
  ): Promise<void> {
    await this.entityCache.invalidateManyAsync(fieldName, fieldValues);
-    const dataLoader = this.getRegularFieldDataLoderForFieldName(fieldName);
-    fieldValues.forEach((fieldValue) => dataLoader.clear(fieldValue));
-  }
-
-  private async invalidateManyByFieldEqualingTransactionalAsync<N extends keyof TFields>(
-    queryContext: EntityQueryContext,
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
-  ): Promise<void> {
-    if (!queryContext.isInTransaction()) {
-      return;
-    }
-
-    const dataLoader = this.getTransactionalFieldDataLoaderForFieldName(queryContext, fieldName);
+    const dataLoader = this.getFieldDataLoaderForFieldName(fieldName);
    fieldValues.forEach((fieldValue) => dataLoader.clear(fieldValue));
  }

@@ -272,21 +215,4 @@ export default class EntityDataManager<TFields> {
      })
    );
  }
-
-  async invalidateObjectFieldsTransactionalAsync(
-    queryContext: EntityQueryContext,
-    objectFields: Readonly<TFields>
-  ): Promise<void> {
-    const keys = Object.keys(objectFields) as (keyof TFields)[];
-    await Promise.all(
-      keys.map(async (fieldName: keyof TFields) => {
-        const value = objectFields[fieldName];
-        if (value !== undefined) {
-          await this.invalidateManyByFieldEqualingTransactionalAsync(queryContext, fieldName, [
-            value as NonNullable<TFields[keyof TFields]>,
-          ]);
-        }
-      })
-    );
-  }
 }
@@ -442,12 +442,12 @@ describe(EntityDataManager, () => {
  });

  it('handles DB errors as expected', async () => {
-    const databaseAdapterMock = mock(EntityDatabaseAdapter);
+    const databaseAdapterMock = mock<EntityDatabaseAdapter<TestFields>>();
    when(databaseAdapterMock.fetchManyWhereAsync(anything(), anything(), anything())).thenReject(
      new Error('DB query failed')
    );

-    const databaseAdapter: EntityDatabaseAdapter<TestFields> = instance(databaseAdapterMock);
+    const databaseAdapter = instance(databaseAdapterMock);
    const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
@@ -1,4 +1,3 @@
-import { DatabaseAdapterFlavor, CacheAdapterFlavor } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
 import { UUIDField, StringField } from '../../EntityFields';
 import {
@@ -38,8 +37,8 @@ const blahEntityConfiguration = new EntityConfiguration<BlahT>({
      columnName: 'transform_write',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 describe(getDatabaseFieldForEntityField, () => {
@@ -1,7 +1,6 @@
 import { verify, deepEqual, mock, instance, when, anything } from 'ts-mockito';

 import EntityCacheAdapter from '../../EntityCacheAdapter';
-import { DatabaseAdapterFlavor, CacheAdapterFlavor } from '../../EntityCompanionProvider';
 import EntityConfiguration from '../../EntityConfiguration';
 import { UUIDField } from '../../EntityFields';
 import ReadThroughEntityCache, { CacheStatus } from '../ReadThroughEntityCache';
@@ -17,8 +16,8 @@ const makeEntityConfiguration = (cacheIdField: boolean): EntityConfiguration<Bla
    schema: {
      id: new UUIDField({ columnName: 'id', cache: cacheIdField }),
    },
-    databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-    cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+    databaseAdapterFlavor: 'postgres',
+    cacheAdapterFlavor: 'redis',
  });

 const createIdFetcher = (ids: string[]) => async <N extends keyof BlahFields>(
@@ -8,7 +8,7 @@ import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 */
 export default class AlwaysAllowPrivacyPolicyRule<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
@@ -8,7 +8,7 @@ import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 */
 export default class AlwaysDenyPrivacyPolicyRule<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
@@ -8,7 +8,7 @@ import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 */
 export default class AlwaysSkipPrivacyPolicyRule<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
@@ -37,12 +37,12 @@ export enum RuleEvaluationResult {
 */
 export default abstract class PrivacyPolicyRule<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields = keyof TFields
 > {
-  abstract async evaluateAsync(
+  abstract evaluateAsync(
    viewerContext: TViewerContext,
    queryContext: EntityQueryContext,
    entity: TEntity
@@ -1,9 +1,5 @@
 import Entity from '../Entity';
-import {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { DateField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
@@ -22,8 +18,8 @@ export const dateIDTestEntityConfiguration = new EntityConfiguration<DateIDTestF
      columnName: 'custom_id',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 export class DateIDTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
@@ -1,9 +1,5 @@
 import Entity from '../Entity';
-import {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
@@ -24,8 +20,8 @@ export const simpleTestEntityConfiguration = new EntityConfiguration<SimpleTestF
      columnName: 'custom_id',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
@@ -1,11 +1,7 @@
 import { result, Result } from '@expo/results';

 import Entity from '../Entity';
-import {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField, StringField, DateField, NumberField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
@@ -45,8 +41,8 @@ export const testEntityConfiguration = new EntityConfiguration<TestFields>({
      columnName: 'nullable_field',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 export class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
@@ -1,9 +1,5 @@
 import Entity from '../Entity';
-import {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
@@ -26,8 +22,8 @@ export const testEntity2Configuration = new EntityConfiguration<Test2Fields>({
      columnName: 'foreign_key',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 export class TestEntity2PrivacyPolicy extends EntityPrivacyPolicy<
@@ -1,9 +1,5 @@
 import Entity from '../Entity';
-import {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-  EntityCompanionDefinition,
-} from '../EntityCompanionProvider';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { NumberField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
@@ -22,8 +18,8 @@ export const numberKeyEntityConfiguration = new EntityConfiguration<NumberKeyFie
      columnName: 'custom_id',
    }),
  },
-  databaseAdapterFlavor: DatabaseAdapterFlavor.POSTGRES,
-  cacheAdapterFlavor: CacheAdapterFlavor.REDIS,
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
 });

 export class NumberKeyPrivacyPolicy extends EntityPrivacyPolicy<
@@ -117,4 +117,18 @@ describe(filterMap, () => {
    expect(filteredMap.get('a')).toBeUndefined();
    expect(filteredMap.get('b')).toBe(true);
  });
+
+  it('can use predicates', () => {
+    function truthy<TValue>(value: TValue | null | undefined): value is TValue {
+      return !!value;
+    }
+
+    const map = new Map<string, string | null>([
+      ['a', 'yes'],
+      ['b', null],
+    ]);
+
+    const filteredMap: Map<string, string> = filterMap(map, truthy);
+    expect(filteredMap.size).toBe(1);
+  });
 });
@@ -9,9 +9,7 @@ export const computeIfAbsent = <K, V>(
    const value = mappingFunction(key);
    map.set(key, value);
  }
-  const value = map.get(key);
-  invariant(value !== undefined, 'should always be present');
-  return value!;
+  return map.get(key)!;
 };

 export const mapMap = <K, V, M>(
@@ -32,8 +30,8 @@ export const mapMapAsync = async function <K, V, M>(
  const resultingMap: Map<K, M> = new Map();
  await Promise.all(
    Array.from(map.keys()).map(async (k) => {
-      const initialValue = map.get(k) ?? invariant(false, 'cannot be undefined here');
-      const result = await mapper(initialValue!, k);
+      const initialValue = map.get(k) as V;
+      const result = await mapper(initialValue, k);
      resultingMap.set(k, result);
    })
  );
@@ -85,10 +83,18 @@ export const reduceMapAsync = async <K, V, A>(
  return newAccumulator;
 };

-export const filterMap = <K, V>(
+export function filterMap<K, V, S extends V>(
+  map: ReadonlyMap<K, V>,
+  predicate: (value: V, key: K) => value is S
+): Map<K, S>;
+export function filterMap<K, V>(
  map: ReadonlyMap<K, V>,
  predicate: (value: V, key: K) => boolean
-): Map<K, V> => {
+): Map<K, V>;
+export function filterMap<K, V>(
+  map: ReadonlyMap<K, V>,
+  predicate: (value: V, key: K) => unknown
+): Map<K, V> {
  const resultingMap = new Map();
  map.forEach((v, k) => {
    if (predicate(v, k)) {
@@ -96,4 +102,4 @@ export const filterMap = <K, V>(
    }
  });
  return resultingMap;
-};
+}
@@ -5,7 +5,7 @@ import PrivacyPolicyRule, { RuleEvaluationResult } from '../../rules/PrivacyPoli

 export interface Case<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields
@@ -17,7 +17,7 @@ export interface Case<

 type CaseMap<
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
  TSelectedFields extends keyof TFields
@@ -28,10 +28,10 @@ type CaseMap<
 */
 export const describePrivacyPolicyRuleWithAsyncTestCase = <
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields
 >(
  privacyPolicyRule: PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
  {
@@ -85,10 +85,10 @@ export const describePrivacyPolicyRuleWithAsyncTestCase = <
 */
 export const describePrivacyPolicyRule = <
  TFields,
-  TID,
+  TID extends NonNullable<TFields[TSelectedFields]>,
  TViewerContext extends ViewerContext,
  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields
 >(
  privacyPolicyRule: PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
  {
@@ -1,7 +1,4 @@
-import EntityCompanionProvider, {
-  DatabaseAdapterFlavor,
-  CacheAdapterFlavor,
-} from '../../EntityCompanionProvider';
+import EntityCompanionProvider from '../../EntityCompanionProvider';
 import IEntityMetricsAdapter from '../../metrics/IEntityMetricsAdapter';
 import NoOpEntityMetricsAdapter from '../../metrics/NoOpEntityMetricsAdapter';
 import { InMemoryFullCacheStubCacheAdapterProvider } from './StubCacheAdapter';
@@ -17,16 +14,22 @@ export const createUnitTestEntityCompanionProvider = (
 ): EntityCompanionProvider => {
  return new EntityCompanionProvider(
    metricsAdapter,
-    {
-      [DatabaseAdapterFlavor.POSTGRES]: {
-        adapterProvider: new StubDatabaseAdapterProvider(),
-        queryContextProvider: StubQueryContextProvider,
-      },
-    },
-    {
-      [CacheAdapterFlavor.REDIS]: {
-        cacheAdapterProvider: new InMemoryFullCacheStubCacheAdapterProvider(),
-      },
-    }
+    new Map([
+      [
+        'postgres',
+        {
+          adapterProvider: new StubDatabaseAdapterProvider(),
+          queryContextProvider: StubQueryContextProvider,
+        },
+      ],
+    ]),
+    new Map([
+      [
+        'redis',
+        {
+          cacheAdapterProvider: new InMemoryFullCacheStubCacheAdapterProvider(),
+        },
+      ],
+    ])
  );
 };
Author	SHA1	Message	Date
Will Schurman	5a8479f3d9	v0.12.0 (#112 )	2021-01-22 09:28:24 -08:00
Will Schurman	045c575713	chore: upgrade more packages (#111 )	2021-01-20 12:53:31 -08:00
Will Schurman	a032141fbf	chore: upgrade typescript to 4.1 (#110 )	2021-01-20 12:37:15 -08:00
Will Schurman	72a77f8b68	fix: remove cache and database adaptor flavor enums (#109 )	2021-01-20 11:49:45 -08:00
Will Schurman	b7309e18a2	fix: move runInTransaction to ViewerContext (#108 )	2021-01-20 10:07:13 -08:00
Will Schurman	01b3bfef7c	feat: better typing on filterMap for use with predicates (#106 )	2021-01-08 10:02:02 -08:00
Will Schurman	83547412a2	v0.11.0 (#105 )	2020-12-23 16:49:06 -08:00
Will Schurman	fe2917e6b5	fix: add type generic default in test utils (#104 )	2020-12-23 16:18:57 -08:00
Will Schurman	29c1a434ab	fix: maps utils invariants for collections containing undefined values (#103 )	2020-12-23 14:01:20 -08:00
Will Schurman	15546aad97	feat: better cache adapter error handling (#102 )	2020-12-23 13:47:22 -08:00
Will Schurman	5208aeedb0	feat: better database adapter error handling (#101 )	2020-12-22 18:01:12 -08:00
Will Schurman	b8e07f9ddc	fix: remove any cast from EntityLoader (#100 )	2020-12-21 16:28:28 -08:00