@expo/entity 0.41.0 → 0.42.0

package/src/rules/AlwaysSkipPrivacyPolicyRule.ts

@@ -8,18 +8,18 @@ import ViewerContext from '../ViewerContext';
  * A no-op policy rule that always skips.
  */
 export default class AlwaysSkipPrivacyPolicyRule<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
-> extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+> extends PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
     _evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields

package/src/rules/PrivacyPolicyRule.ts

@@ -37,10 +37,10 @@ export enum RuleEvaluationResult {
  *   would be named something like `DenyIfViewerHasBeenBlockedPrivacyPolicyRule`.
  */
 export default abstract class PrivacyPolicyRule<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
 > {
   abstract evaluateAsync(
@@ -48,7 +48,7 @@ export default abstract class PrivacyPolicyRule<
     queryContext: EntityQueryContext,
     evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields

package/src/rules/__tests__/AlwaysAllowPrivacyPolicyRule-test.ts

@@ -3,7 +3,7 @@ import { mock, instance, anything } from 'ts-mockito';
 import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
 import ViewerContext from '../../ViewerContext';
-import { describePrivacyPolicyRule } from '../../utils/testing/PrivacyPolicyRuleTestUtils';
+import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
 import AlwaysAllowPrivacyPolicyRule from '../AlwaysAllowPrivacyPolicyRule';
 
 describePrivacyPolicyRule(new AlwaysAllowPrivacyPolicyRule(), {

package/src/rules/__tests__/AlwaysDenyPrivacyPolicyRule-test.ts

@@ -3,7 +3,7 @@ import { mock, instance, anything } from 'ts-mockito';
 import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
 import ViewerContext from '../../ViewerContext';
-import { describePrivacyPolicyRule } from '../../utils/testing/PrivacyPolicyRuleTestUtils';
+import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
 import AlwaysDenyPrivacyPolicyRule from '../AlwaysDenyPrivacyPolicyRule';
 
 describePrivacyPolicyRule(new AlwaysDenyPrivacyPolicyRule(), {

package/src/rules/__tests__/AlwaysSkipPrivacyPolicyRule-test.ts

@@ -3,7 +3,7 @@ import { mock, instance, anything } from 'ts-mockito';
 import { EntityPrivacyPolicyEvaluationContext } from '../../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../../EntityQueryContext';
 import ViewerContext from '../../ViewerContext';
-import { describePrivacyPolicyRule } from '../../utils/testing/PrivacyPolicyRuleTestUtils';
+import { describePrivacyPolicyRule } from '../../utils/__testfixtures__/PrivacyPolicyRuleTestUtils';
 import AlwaysSkipPrivacyPolicyRule from '../AlwaysSkipPrivacyPolicyRule';
 
 describePrivacyPolicyRule(new AlwaysSkipPrivacyPolicyRule(), {

package/src/utils/EntityPrivacyUtils.ts

@@ -43,20 +43,27 @@ export type EntityPrivacyEvaluationResult =
  * @param queryContext - query context in which to perform the check
  */
 export async function canViewerUpdateAsync<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
   sourceEntity: TEntity,
   queryContext: EntityQueryContext = sourceEntity
     .getViewerContext()
@@ -83,20 +90,27 @@ export async function canViewerUpdateAsync<
  * @param queryContext - query context in which to perform the check
  */
 export async function getCanViewerUpdateResultAsync<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
   sourceEntity: TEntity,
   queryContext: EntityQueryContext = sourceEntity
     .getViewerContext()
@@ -113,20 +127,27 @@ export async function getCanViewerUpdateResultAsync<
 }
 
 async function canViewerUpdateInternalAsync<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
   sourceEntity: TEntity,
   cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   queryContext: EntityQueryContext,
@@ -165,20 +186,27 @@ async function canViewerUpdateInternalAsync<
  * @param queryContext - query context in which to perform the check
  */
 export async function canViewerDeleteAsync<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
   sourceEntity: TEntity,
   queryContext: EntityQueryContext = sourceEntity
     .getViewerContext()
@@ -205,20 +233,27 @@ export async function canViewerDeleteAsync<
  * @param queryContext - query context in which to perform the check
  */
 export async function getCanViewerDeleteResultAsync<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
   sourceEntity: TEntity,
   queryContext: EntityQueryContext = sourceEntity
     .getViewerContext()
@@ -235,20 +270,27 @@ export async function getCanViewerDeleteResultAsync<
 }
 
 async function canViewerDeleteInternalAsync<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  entityClass: IEntityClass<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
   sourceEntity: TEntity,
   cascadingDeleteCause: EntityCascadingDeletionInfo | null,
   queryContext: EntityQueryContext,

package/src/utils/{testing → __testfixtures__}/PrivacyPolicyRuleTestUtils.ts

@@ -5,17 +5,17 @@ import ViewerContext from '../../ViewerContext';
 import PrivacyPolicyRule, { RuleEvaluationResult } from '../../rules/PrivacyPolicyRule';
 
 export interface Case<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields,
 > {
   viewerContext: TViewerContext;
   queryContext: EntityQueryContext;
   evaluationContext: EntityPrivacyPolicyEvaluationContext<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -24,32 +24,32 @@ export interface Case<
 }
 
 export type CaseMap<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields,
-> = Map<string, () => Promise<Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>>>;
+> = Map<string, () => Promise<Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>>>;
 
 /**
  * Useful for defining test cases that have async preconditions.
  */
 export const describePrivacyPolicyRuleWithAsyncTestCase = <
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  privacyPolicyRule: PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
+  privacyPolicyRule: PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>,
   {
     allowCases = new Map(),
     skipCases = new Map(),
     denyCases = new Map(),
   }: {
-    allowCases?: CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields>;
-    skipCases?: CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields>;
-    denyCases?: CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields>;
+    allowCases?: CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>;
+    skipCases?: CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>;
+    denyCases?: CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>;
   },
 ): void => {
   describe(privacyPolicyRule.constructor.name, () => {
@@ -95,30 +95,30 @@ export const describePrivacyPolicyRuleWithAsyncTestCase = <
  * For test simple privacy rules that don't have complex async preconditions.
  */
 export const describePrivacyPolicyRule = <
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
 >(
-  privacyPolicyRule: PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
+  privacyPolicyRule: PrivacyPolicyRule<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>,
   {
     allowCases = [],
     skipCases = [],
     denyCases = [],
   }: {
-    allowCases?: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[];
-    skipCases?: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[];
-    denyCases?: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[];
+    allowCases?: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[];
+    skipCases?: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[];
+    denyCases?: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[];
   },
 ): void => {
   const makeCasesMap = (
-    cases: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>[],
-  ): CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields> =>
+    cases: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[],
+  ): CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> =>
     cases.reduce(
       (
-        acc: CaseMap<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
-        testCase: Case<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
+        acc: CaseMap<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>,
+        testCase: Case<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>,
         index,
       ) => {
         acc.set(`case ${index}`, async () => testCase);

package/src/{testfixtures → utils/__testfixtures__}/SimpleTestEntity.ts

@@ -1,10 +1,10 @@
-import Entity from '../Entity';
-import { EntityCompanionDefinition } from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
-import { UUIDField } from '../EntityFields';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
-import ViewerContext from '../ViewerContext';
-import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
+import Entity from '../../Entity';
+import { EntityCompanionDefinition } from '../../EntityCompanionProvider';
+import EntityConfiguration from '../../EntityConfiguration';
+import { UUIDField } from '../../EntityFields';
+import EntityPrivacyPolicy from '../../EntityPrivacyPolicy';
+import ViewerContext from '../../ViewerContext';
+import AlwaysAllowPrivacyPolicyRule from '../../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type SimpleTestFields = {
   id: string;
@@ -12,12 +12,13 @@ export type SimpleTestFields = {
 
 export type SimpleTestFieldSelection = keyof SimpleTestFields;
 
-export const simpleTestEntityConfiguration = new EntityConfiguration<SimpleTestFields>({
+export const simpleTestEntityConfiguration = new EntityConfiguration<SimpleTestFields, 'id'>({
   idField: 'id',
   tableName: 'simple_test_entity_should_not_write_to_db',
   schema: {
     id: new UUIDField({
       columnName: 'custom_id',
+      cache: true,
     }),
   },
   databaseAdapterFlavor: 'postgres',
@@ -26,7 +27,7 @@ export const simpleTestEntityConfiguration = new EntityConfiguration<SimpleTestF
 
 export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   SimpleTestFields,
-  string,
+  'id',
   ViewerContext,
   SimpleTestEntity,
   SimpleTestFieldSelection
@@ -34,7 +35,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
-      string,
+      'id',
       ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
@@ -43,7 +44,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
-      string,
+      'id',
       ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
@@ -52,7 +53,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
-      string,
+      'id',
       ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
@@ -61,7 +62,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
-      string,
+      'id',
       ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
@@ -71,13 +72,13 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
 
 export default class SimpleTestEntity extends Entity<
   SimpleTestFields,
-  string,
+  'id',
   ViewerContext,
   SimpleTestFieldSelection
 > {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     SimpleTestFields,
-    string,
+    'id',
     ViewerContext,
     SimpleTestEntity,
     SimpleTestEntityPrivacyPolicy,

package/src/utils/__testfixtures__/StubCacheAdapter.ts

@@ -0,0 +1,164 @@
+import invariant from 'invariant';
+
+import EntityConfiguration from '../../EntityConfiguration';
+import IEntityCacheAdapter from '../../IEntityCacheAdapter';
+import IEntityCacheAdapterProvider from '../../IEntityCacheAdapterProvider';
+import { IEntityLoadKey, IEntityLoadValue } from '../../internal/EntityLoadInterfaces';
+import { CacheStatus, CacheLoadResult } from '../../internal/ReadThroughEntityCache';
+
+export class NoCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvider {
+  getCacheAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    _entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): IEntityCacheAdapter<TFields, TIDField> {
+    return new NoCacheStubCacheAdapter();
+  }
+}
+
+export class NoCacheStubCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> implements IEntityCacheAdapter<TFields, TIDField>
+{
+  public async loadManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, CacheLoadResult<TFields>>> {
+    return values.reduce((acc: Map<TLoadValue, CacheLoadResult<TFields>>, v) => {
+      acc.set(v, {
+        status: CacheStatus.MISS,
+      });
+      return acc;
+    }, key.vendNewLoadValueMap<CacheLoadResult<TFields>>());
+  }
+
+  public async cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>): Promise<void> {}
+
+  public async cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _values: readonly TLoadValue[]): Promise<void> {}
+
+  public async invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _values: readonly TLoadValue[]): Promise<void> {}
+}
+
+// Sentinel value we store in the in-memory cache to negatively cache a database miss.
+// The sentinel value is distinct from any (positively) cached value.
+export const DOES_NOT_EXIST = Symbol('inMemoryCacheDoesNotExistValue');
+
+export class InMemoryFullCacheStubCacheAdapterProvider implements IEntityCacheAdapterProvider {
+  private readonly cache: Map<string, Readonly<object> | typeof DOES_NOT_EXIST> = new Map();
+
+  getCacheAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): IEntityCacheAdapter<TFields, TIDField> {
+    return new InMemoryFullCacheStubCacheAdapter(
+      entityConfiguration,
+      this.cache as Map<string, Readonly<TFields>>,
+    );
+  }
+}
+
+export class InMemoryFullCacheStubCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> implements IEntityCacheAdapter<TFields, TIDField>
+{
+  constructor(
+    private readonly entityConfiguration: EntityConfiguration<TFields, TIDField>,
+    private readonly cache: Map<string, Readonly<TFields> | typeof DOES_NOT_EXIST>,
+  ) {}
+
+  public async loadManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, CacheLoadResult<TFields>>> {
+    const results = key.vendNewLoadValueMap<CacheLoadResult<TFields>>();
+    values.forEach((value) => {
+      const cacheKey = this.createCacheKey(key, value);
+      if (!this.cache.has(cacheKey)) {
+        results.set(value, {
+          status: CacheStatus.MISS,
+        });
+      } else {
+        const objectForFieldValue = this.cache.get(cacheKey);
+        invariant(objectForFieldValue !== undefined, 'should have set value for key');
+        if (objectForFieldValue === DOES_NOT_EXIST) {
+          results.set(value, {
+            status: CacheStatus.NEGATIVE,
+          });
+        } else {
+          results.set(value, {
+            status: CacheStatus.HIT,
+            item: objectForFieldValue,
+          });
+        }
+      }
+    });
+    return results;
+  }
+
+  public async cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>): Promise<void> {
+    objectMap.forEach((obj, value) => {
+      const cacheKey = this.createCacheKey(key, value);
+      this.cache.set(cacheKey, obj);
+    });
+  }
+
+  public async cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
+    values.forEach((value) => {
+      const cacheKey = this.createCacheKey(key, value);
+      this.cache.set(cacheKey, DOES_NOT_EXIST);
+    });
+  }
+
+  public async invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
+    values.forEach((value) => {
+      const cacheKey = this.createCacheKey(key, value);
+      this.cache.delete(cacheKey);
+    });
+  }
+
+  private createCacheKey<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, value: TLoadValue): string {
+    const cacheKeyType = key.getLoadMethodType();
+    const parts = key.createCacheKeyPartsForLoadValue(this.entityConfiguration, value);
+    return [
+      this.entityConfiguration.tableName,
+      cacheKeyType,
+      `v${this.entityConfiguration.cacheKeyVersion}`,
+      ...parts,
+    ].join(':');
+  }
+}