@expo/entity 0.40.0 → 0.42.0

package/src/EntityPrivacyPolicy.ts

@@ -12,10 +12,10 @@ import PrivacyPolicyRule, { RuleEvaluationResult } from './rules/PrivacyPolicyRu
  * Information about the reason this privacy policy is being evaluated.
  */
 export type EntityPrivacyPolicyEvaluationContext<
-  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,
 > = {
   /**
@@ -53,10 +53,10 @@ export enum EntityPrivacyPolicyEvaluationMode {
 }
 
 export type EntityPrivacyPolicyEvaluator<
-  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,
 > =
   | {
@@ -65,13 +65,25 @@ export type EntityPrivacyPolicyEvaluator<
   | {
       mode: EntityPrivacyPolicyEvaluationMode.DRY_RUN;
       denyHandler: (
-        error: EntityNotAuthorizedError<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
+        error: EntityNotAuthorizedError<
+          TFields,
+          TIDField,
+          TViewerContext,
+          TEntity,
+          TSelectedFields
+        >,
       ) => void;
     }
   | {
       mode: EntityPrivacyPolicyEvaluationMode.ENFORCE_AND_LOG;
       denyHandler: (
-        error: EntityNotAuthorizedError<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
+        error: EntityNotAuthorizedError<
+          TFields,
+          TIDField,
+          TViewerContext,
+          TEntity,
+          TSelectedFields
+        >,
       ) => void;
     };
 
@@ -104,36 +116,36 @@ export enum EntityAuthorizationAction {
  * ```
  */
 export default abstract class EntityPrivacyPolicy<
-  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,
 > {
   protected readonly createRules: readonly PrivacyPolicyRule<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >[] = [];
   protected readonly readRules: readonly PrivacyPolicyRule<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >[] = [];
   protected readonly updateRules: readonly PrivacyPolicyRule<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
   >[] = [];
   protected readonly deleteRules: readonly PrivacyPolicyRule<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -149,7 +161,7 @@ export default abstract class EntityPrivacyPolicy<
    */
   protected getPrivacyPolicyEvaluator(
     _viewerContext: TViewerContext,
-  ): EntityPrivacyPolicyEvaluator<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
+  ): EntityPrivacyPolicyEvaluator<TFields, TIDField, TViewerContext, TEntity, TSelectedFields> {
     return {
       mode: EntityPrivacyPolicyEvaluationMode.ENFORCE,
     };
@@ -168,7 +180,7 @@ export default abstract class EntityPrivacyPolicy<
     queryContext: EntityQueryContext,
     evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
@@ -200,7 +212,7 @@ export default abstract class EntityPrivacyPolicy<
     queryContext: EntityQueryContext,
     evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
@@ -232,7 +244,7 @@ export default abstract class EntityPrivacyPolicy<
     queryContext: EntityQueryContext,
     evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
@@ -264,7 +276,7 @@ export default abstract class EntityPrivacyPolicy<
     queryContext: EntityQueryContext,
     evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
@@ -284,12 +296,18 @@ export default abstract class EntityPrivacyPolicy<
   }
 
   private async authorizeForRulesetAsync(
-    ruleset: readonly PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>[],
+    ruleset: readonly PrivacyPolicyRule<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >[],
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
     evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
@@ -393,12 +411,18 @@ export default abstract class EntityPrivacyPolicy<
   }
 
   private async authorizeForRulesetInnerAsync(
-    ruleset: readonly PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields>[],
+    ruleset: readonly PrivacyPolicyRule<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >[],
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
     evaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
@@ -418,7 +442,7 @@ export default abstract class EntityPrivacyPolicy<
         case RuleEvaluationResult.DENY:
           throw new EntityNotAuthorizedError<
             TFields,
-            TID,
+            TIDField,
             TViewerContext,
             TEntity,
             TSelectedFields
@@ -434,7 +458,7 @@ export default abstract class EntityPrivacyPolicy<
       }
     }
 
-    throw new EntityNotAuthorizedError<TFields, TID, TViewerContext, TEntity, TSelectedFields>(
+    throw new EntityNotAuthorizedError<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>(
       entity,
       viewerContext,
       action,

package/src/EntitySecondaryCacheLoader.ts

@@ -10,7 +10,7 @@ import { mapMap } from './utils/collections/maps';
  * An interface that knows how to load many objects from a cache by load params and invalidate
  * those same load params.
  */
-export interface ISecondaryEntityCache<TFields, TLoadParams> {
+export interface ISecondaryEntityCache<TFields extends Record<string, any>, TLoadParams> {
   /**
    * Read-through cache function.
    * @param loadParamsArray - array of loadParams to load from the cache
@@ -45,13 +45,13 @@ export interface ISecondaryEntityCache<TFields, TLoadParams> {
  */
 export default abstract class EntitySecondaryCacheLoader<
   TLoadParams,
-  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>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -62,7 +62,7 @@ export default abstract class EntitySecondaryCacheLoader<
     private readonly secondaryEntityCache: ISecondaryEntityCache<TFields, TLoadParams>,
     protected readonly entityLoader: AuthorizationResultBasedEntityLoader<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,

package/src/EntityUpdater.ts

@@ -10,13 +10,13 @@ import ViewerContext from './ViewerContext';
  * The primary interface for updating entities.
  */
 export default class EntityUpdater<
-  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>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -28,7 +28,7 @@ export default class EntityUpdater<
     private readonly queryContext: EntityQueryContext,
     private readonly entityClass: IEntityClass<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
@@ -42,7 +42,7 @@ export default class EntityUpdater<
    */
   enforcing(): EnforcingEntityUpdater<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TPrivacyPolicy,
@@ -58,7 +58,7 @@ export default class EntityUpdater<
    */
   withAuthorizationResults(): AuthorizationResultBasedUpdateMutator<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TPrivacyPolicy,

package/src/GenericEntityCacheAdapter.ts

@@ -2,64 +2,75 @@ import invariant from 'invariant';
 
 import IEntityCacheAdapter from './IEntityCacheAdapter';
 import IEntityGenericCacher from './IEntityGenericCacher';
+import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 import { CacheLoadResult } from './internal/ReadThroughEntityCache';
 import { mapKeys } from './utils/collections/maps';
 
 /**
  * A standard IEntityCacheAdapter that coordinates caching through an IEntityGenericCacher.
  */
-export default class GenericEntityCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
-  constructor(private readonly genericCacher: IEntityGenericCacher<TFields>) {}
+export default class GenericEntityCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> implements IEntityCacheAdapter<TFields, TIDField>
+{
+  constructor(private readonly genericCacher: IEntityGenericCacher<TFields, TIDField>) {}
 
-  public async loadManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
+  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 redisCacheKeyToFieldValueMapping = new Map(
-      fieldValues.map((fieldValue) => [
-        this.genericCacher.makeCacheKey(fieldName, fieldValue),
-        fieldValue,
-      ]),
+      values.map((value) => [this.genericCacher.makeCacheKeyForStorage(key, value), value]),
     );
     const cacheResults = await this.genericCacher.loadManyAsync(
       Array.from(redisCacheKeyToFieldValueMapping.keys()),
     );
 
-    return mapKeys(cacheResults, (redisCacheKey) => {
+    const result = key.vendNewLoadValueMap<CacheLoadResult<TFields>>();
+    for (const [redisCacheKey, cacheResult] of cacheResults) {
       const fieldValue = redisCacheKeyToFieldValueMapping.get(redisCacheKey);
       invariant(
         fieldValue !== undefined,
         'Unspecified cache key %s returned from generic cacher',
         redisCacheKey,
       );
-      return fieldValue;
-    });
+      result.set(fieldValue, cacheResult);
+    }
+    return result;
   }
 
-  public async cacheManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
-  ): Promise<void> {
+  public async cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>): Promise<void> {
     await this.genericCacher.cacheManyAsync(
-      mapKeys(objectMap, (fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
+      mapKeys(objectMap, (value) => this.genericCacher.makeCacheKeyForStorage(key, value)),
     );
   }
 
-  public async cacheDBMissesAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<void> {
+  public async cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
     await this.genericCacher.cacheDBMissesAsync(
-      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
+      values.map((value) => this.genericCacher.makeCacheKeyForStorage(key, value)),
     );
   }
 
-  public async invalidateManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<void> {
+  public async invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
     await this.genericCacher.invalidateManyAsync(
-      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
+      values.flatMap((value) => this.genericCacher.makeCacheKeysForInvalidation(key, value)),
     );
   }
 }

package/src/GenericSecondaryEntityCache.ts

@@ -10,11 +10,14 @@ import { filterMap, zipToMap } from './utils/collections/maps';
  * single entity load. One common way this may be used is to add a second layer of caching in a hot path that makes
  * a call to EntityLoader.loadManyByFieldEqualityConjunctionAsync is guaranteed to return at most one entity.
  */
-export default abstract class GenericSecondaryEntityCache<TFields, TLoadParams>
-  implements ISecondaryEntityCache<TFields, TLoadParams>
+export default abstract class GenericSecondaryEntityCache<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+  TLoadParams,
+> implements ISecondaryEntityCache<TFields, TLoadParams>
 {
   constructor(
-    protected readonly cacher: IEntityGenericCacher<TFields>,
+    protected readonly cacher: IEntityGenericCacher<TFields, TIDField>,
     protected readonly constructCacheKey: (params: Readonly<TLoadParams>) => string,
   ) {}
 

package/src/IEntityCacheAdapter.ts

@@ -1,49 +1,69 @@
+import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 import { CacheLoadResult } from './internal/ReadThroughEntityCache';
 
 /**
  * A cache adapter is an interface by which objects can be
  * cached, fetched from cache, and removed from cache (invalidated).
  */
-export default interface IEntityCacheAdapter<TFields> {
+export default interface IEntityCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> {
   /**
    * Load many objects from cache.
-   * @param fieldName - object field being queried
-   * @param fieldValues - fieldName field values being queried
-   * @returns map from all field values to a CacheLoadResult for each input value
+   * @param key - load key to load
+   * @param values - load values to load for the key
+   * @returns map from all load values to a CacheLoadResult for that value
    */
-  loadManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>>;
+  loadManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, CacheLoadResult<TFields>>>;
 
   /**
    * Cache many objects fetched from the DB.
-   * @param fieldName - object field being queried
-   * @param objectMap - map from field value to object to cache
+   * @param key - load key to cache
+   * @param objectMap - map from load value to object to cache for the key
    */
-  cacheManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
+  cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>,
   ): Promise<void>;
 
   /**
    * Negatively cache objects that could not be found in the cache or DB.
-   * @param fieldName - object field being queried
-   * @param fieldValues - fieldValues for objects reported as CacheStatus.NEGATIVE
-   *                    in the cache and not found in the DB.
+   * @param key - load key to cache misses for
+   * @param values - load values for objects reported as CacheStatus.NEGATIVE
+   *                 in the cache and not found in the DB.
    */
-  cacheDBMissesAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
+  cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
   ): Promise<void>;
 
   /**
-   * Invalidate the cache for objects cached by (fieldName, fieldValue).
-   * @param fieldName - object field being queried
-   * @param fieldValues - fieldName field values to be invalidated
+   * Invalidate the cache for objects cached by (key, value).
+   * @param key - load key to invalidate
+   * @param values - load values to be invalidated for the key
    */
-  invalidateManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
+  invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
   ): Promise<void>;
 }

package/src/IEntityCacheAdapterProvider.ts

@@ -9,7 +9,7 @@ export default interface IEntityCacheAdapterProvider {
   /**
    * Vend a cache adapter for an entity configuration.
    */
-  getCacheAdapter<TFields extends Record<string, any>>(
-    entityConfiguration: EntityConfiguration<TFields>,
-  ): IEntityCacheAdapter<TFields>;
+  getCacheAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): IEntityCacheAdapter<TFields, TIDField>;
 }

package/src/IEntityDatabaseAdapterProvider.ts

@@ -9,7 +9,7 @@ export default interface IEntityDatabaseAdapterProvider {
   /**
    * Vend a database adapter.
    */
-  getDatabaseAdapter<TFields extends Record<string, any>>(
-    entityConfiguration: EntityConfiguration<TFields>,
-  ): EntityDatabaseAdapter<TFields>;
+  getDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): EntityDatabaseAdapter<TFields, TIDField>;
 }

package/src/IEntityGenericCacher.ts

@@ -1,10 +1,14 @@
+import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 import { CacheLoadResult } from './internal/ReadThroughEntityCache';
 
 /**
  * A generic cacher stores and loads key-value pairs. It also supports negative caching - it stores the absence
  * of keys that don't exist in the backing datastore. It is also responsible for cache key creation.
  */
-export default interface IEntityGenericCacher<TFields> {
+export default interface IEntityGenericCacher<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> {
   /**
    * Load many keys from the cache. Return info in a format that is useful for read-through caching and
    * negative caching.
@@ -36,10 +40,34 @@ export default interface IEntityGenericCacher<TFields> {
   invalidateManyAsync(keys: readonly string[]): Promise<void>;
 
   /**
-   * Create a cache key for a field and value of a object being cached or invalidated.
+   * Create a cache key for a load key and load value of an object being cached (or negatively cached).
    *
-   * @param fieldName - name of the object field for this cache key
-   * @param fieldValue - value of the obejct field for this cache key
+   * @param key - load key of the cache key
+   * @param value - load value of the cache key
    */
-  makeCacheKey<N extends keyof TFields>(fieldName: N, fieldValue: NonNullable<TFields[N]>): string;
+  makeCacheKeyForStorage<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    value: TLoadValue,
+  ): string;
+
+  /**
+   * Create a cache key for a load key and load values of an object being invalidated. This is separate
+   * from makeCacheKeyForStorage because invalidation can optionally be configured to invalidate a larger set of keys than
+   * the one for just the current cache version, which can be useful for things like push safety.
+   *
+   * @param key - load key of the cache key
+   * @param values - load values of the cache key
+   */
+  makeCacheKeysForInvalidation<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    value: TLoadValue,
+  ): readonly string[];
 }