@expo/entity-cache-adapter-redis 0.41.0 → 0.42.0

package/build/GenericRedisCacher.d.ts

@@ -1,4 +1,4 @@
-import { CacheLoadResult, EntityConfiguration, IEntityGenericCacher } from '@expo/entity';
+import { CacheLoadResult, EntityConfiguration, IEntityGenericCacher, IEntityLoadKey, IEntityLoadValue } from '@expo/entity';
 export interface IRedisTransaction {
     set(key: string, value: string, secondsToken: 'EX', seconds: number): this;
     exec(): Promise<any>;
@@ -8,6 +8,22 @@ export interface IRedis {
     multi(): IRedisTransaction;
     del(...args: [...keys: string[]]): Promise<any>;
 }
+/**
+ * The strategy for generating the set of cache keys to invalidate in the Redis cache after entity mutation.
+ */
+export declare enum RedisCacheInvalidationStrategy {
+    /**
+     * Invalidate just the cache key(s) for the current cacheKeyVersion of the entity.
+     */
+    CURRENT_CACHE_KEY_VERSION = "current-cache-key-version",
+    /**
+     * Invalidate the cache key(s) for the current cacheKeyVersion and the surrounding cache key versions
+     * (e.g. `1`, `2` and `3` if the current version is `2`). This can be useful for deployment safety, where
+     * some machines may be operating on an old version of the code and thus an old cacheKeyVersion, and some the new version.
+     * This strategy generates cache keys for both old and potential future new versions.
+     */
+    SURROUNDING_CACHE_KEY_VERSIONS = "surrounding-cache-key-versions"
+}
 export interface GenericRedisCacheContext {
     /**
      * Instance of ioredis.Redis
@@ -33,14 +49,20 @@ export interface GenericRedisCacheContext {
      * this TTL will be assumed not present in the database (unless invalidated).
      */
     ttlSecondsNegative: number;
+    /**
+     * Invalidation strategy for the cache.
+     */
+    invalidationStrategy: RedisCacheInvalidationStrategy;
 }
-export default class GenericRedisCacher<TFields extends Record<string, any>> implements IEntityGenericCacher<TFields> {
+export default class GenericRedisCacher<TFields extends Record<string, any>, TIDField extends keyof TFields> implements IEntityGenericCacher<TFields, TIDField> {
     private readonly context;
     private readonly entityConfiguration;
-    constructor(context: GenericRedisCacheContext, entityConfiguration: EntityConfiguration<TFields>);
+    constructor(context: GenericRedisCacheContext, entityConfiguration: EntityConfiguration<TFields, TIDField>);
     loadManyAsync(keys: readonly string[]): Promise<ReadonlyMap<string, CacheLoadResult<TFields>>>;
     cacheManyAsync(objectMap: ReadonlyMap<string, Readonly<TFields>>): Promise<void>;
     cacheDBMissesAsync(keys: readonly string[]): Promise<void>;
     invalidateManyAsync(keys: readonly string[]): Promise<void>;
-    makeCacheKey<N extends keyof TFields>(fieldName: N, fieldValue: NonNullable<TFields[N]>): string;
+    private makeCacheKeyForCacheKeyVersion;
+    makeCacheKeyForStorage<TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>, TSerializedLoadValue, TLoadValue extends IEntityLoadValue<TSerializedLoadValue>>(key: TLoadKey, value: TLoadValue): string;
+    makeCacheKeysForInvalidation<TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>, TSerializedLoadValue, TLoadValue extends IEntityLoadValue<TSerializedLoadValue>>(key: TLoadKey, value: TLoadValue): readonly string[];
 }

package/build/GenericRedisCacher.js

@@ -3,13 +3,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCacheInvalidationStrategy = void 0;
 const entity_1 = require("@expo/entity");
-const invariant_1 = __importDefault(require("invariant"));
 const RedisCommon_1 = require("./RedisCommon");
 const wrapNativeRedisCallAsync_1 = __importDefault(require("./errors/wrapNativeRedisCallAsync"));
+const getSurroundingCacheKeyVersionsForInvalidation_1 = require("./utils/getSurroundingCacheKeyVersionsForInvalidation");
 // Sentinel value we store in Redis to negatively cache a database miss.
 // The sentinel value is distinct from any (positively) cached value.
 const DOES_NOT_EXIST_REDIS = '';
+/**
+ * The strategy for generating the set of cache keys to invalidate in the Redis cache after entity mutation.
+ */
+var RedisCacheInvalidationStrategy;
+(function (RedisCacheInvalidationStrategy) {
+    /**
+     * Invalidate just the cache key(s) for the current cacheKeyVersion of the entity.
+     */
+    RedisCacheInvalidationStrategy["CURRENT_CACHE_KEY_VERSION"] = "current-cache-key-version";
+    /**
+     * Invalidate the cache key(s) for the current cacheKeyVersion and the surrounding cache key versions
+     * (e.g. `1`, `2` and `3` if the current version is `2`). This can be useful for deployment safety, where
+     * some machines may be operating on an old version of the code and thus an old cacheKeyVersion, and some the new version.
+     * This strategy generates cache keys for both old and potential future new versions.
+     */
+    RedisCacheInvalidationStrategy["SURROUNDING_CACHE_KEY_VERSIONS"] = "surrounding-cache-key-versions";
+})(RedisCacheInvalidationStrategy || (exports.RedisCacheInvalidationStrategy = RedisCacheInvalidationStrategy = {}));
 class GenericRedisCacher {
     context;
     entityConfiguration;
@@ -71,10 +89,23 @@ class GenericRedisCacher {
         }
         await (0, wrapNativeRedisCallAsync_1.default)(() => this.context.redisClient.del(...keys));
     }
-    makeCacheKey(fieldName, fieldValue) {
-        const columnName = this.entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
-        (0, invariant_1.default)(columnName, `database field mapping missing for ${String(fieldName)}`);
-        return this.context.makeKeyFn(this.context.cacheKeyPrefix, this.entityConfiguration.tableName, `v2.${this.entityConfiguration.cacheKeyVersion}`, columnName, String(fieldValue));
+    makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion) {
+        const cacheKeyType = key.getLoadMethodType();
+        const parts = key.createCacheKeyPartsForLoadValue(this.entityConfiguration, value);
+        return this.context.makeKeyFn(this.context.cacheKeyPrefix, cacheKeyType, this.entityConfiguration.tableName, `v2.${cacheKeyVersion}`, ...parts);
+    }
+    makeCacheKeyForStorage(key, value) {
+        return this.makeCacheKeyForCacheKeyVersion(key, value, this.entityConfiguration.cacheKeyVersion);
+    }
+    makeCacheKeysForInvalidation(key, value) {
+        switch (this.context.invalidationStrategy) {
+            case RedisCacheInvalidationStrategy.CURRENT_CACHE_KEY_VERSION:
+                return [
+                    this.makeCacheKeyForCacheKeyVersion(key, value, this.entityConfiguration.cacheKeyVersion),
+                ];
+            case RedisCacheInvalidationStrategy.SURROUNDING_CACHE_KEY_VERSIONS:
+                return (0, getSurroundingCacheKeyVersionsForInvalidation_1.getSurroundingCacheKeyVersionsForInvalidation)(this.entityConfiguration.cacheKeyVersion).map((cacheKeyVersion) => this.makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion));
+        }
     }
 }
 exports.default = GenericRedisCacher;

package/build/GenericRedisCacher.js.map

@@ -1 +1 @@
-{"version":3,"file":"GenericRedisCacher.js","sourceRoot":"","sources":["../src/GenericRedisCacher.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"GenericRedisCacher.js","sourceRoot":"","sources":["../src/GenericRedisCacher.ts"],"names":[],"mappings":"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"}

package/build/RedisCacheAdapterProvider.d.ts

@@ -3,5 +3,5 @@ import { GenericRedisCacheContext } from './GenericRedisCacher';
 export default class RedisCacheAdapterProvider implements IEntityCacheAdapterProvider {
     private readonly context;
     constructor(context: GenericRedisCacheContext);
-    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/build/RedisCacheAdapterProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"RedisCacheAdapterProvider.js","sourceRoot":"","sources":["../src/RedisCacheAdapterProvider.ts"],"names":[],"mappings":";;;;;AAAA,yCAKsB;AAEtB,8EAAoF;AAEpF,MAAqB,yBAAyB;IACf;IAA7B,YAA6B,OAAiC;QAAjC,YAAO,GAAP,OAAO,CAA0B;IAAG,CAAC;IAElE,eAAe,CACb,mBAAiD;QAEjD,OAAO,IAAI,kCAAyB,CAAC,IAAI,4BAAkB,CAAC,IAAI,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAClG,CAAC;CACF;AARD,4CAQC"}
+{"version":3,"file":"RedisCacheAdapterProvider.js","sourceRoot":"","sources":["../src/RedisCacheAdapterProvider.ts"],"names":[],"mappings":";;;;;AAAA,yCAKsB;AAEtB,8EAAoF;AAEpF,MAAqB,yBAAyB;IACf;IAA7B,YAA6B,OAAiC;QAAjC,YAAO,GAAP,OAAO,CAA0B;IAAG,CAAC;IAElE,eAAe,CACb,mBAA2D;QAE3D,OAAO,IAAI,kCAAyB,CAAC,IAAI,4BAAkB,CAAC,IAAI,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAClG,CAAC;CACF;AARD,4CAQC"}

package/build/index.d.ts

@@ -7,3 +7,4 @@ export * from './GenericRedisCacher';
 export { default as RedisCacheAdapterProvider } from './RedisCacheAdapterProvider';
 export * from './RedisCommon';
 export { default as wrapNativeRedisCallAsync } from './errors/wrapNativeRedisCallAsync';
+export * from './utils/getSurroundingCacheKeyVersionsForInvalidation';

package/build/index.js

@@ -31,4 +31,5 @@ Object.defineProperty(exports, "RedisCacheAdapterProvider", { enumerable: true,
 __exportStar(require("./RedisCommon"), exports);
 var wrapNativeRedisCallAsync_1 = require("./errors/wrapNativeRedisCallAsync");
 Object.defineProperty(exports, "wrapNativeRedisCallAsync", { enumerable: true, get: function () { return __importDefault(wrapNativeRedisCallAsync_1).default; } });
+__exportStar(require("./utils/getSurroundingCacheKeyVersionsForInvalidation"), exports);
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,iCAAiC;AACjC;;;GAGG;;;;;;;;;;;;;;;;;;;;AAEH,2DAAqE;AAA5D,yIAAA,OAAO,OAAsB;AACtC,uDAAqC;AACrC,yEAAmF;AAA1E,uJAAA,OAAO,OAA6B;AAC7C,gDAA8B;AAC9B,8EAAwF;AAA/E,qJAAA,OAAO,OAA4B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,iCAAiC;AACjC;;;GAGG;;;;;;;;;;;;;;;;;;;;AAEH,2DAAqE;AAA5D,yIAAA,OAAO,OAAsB;AACtC,uDAAqC;AACrC,yEAAmF;AAA1E,uJAAA,OAAO,OAA6B;AAC7C,gDAA8B;AAC9B,8EAAwF;AAA/E,qJAAA,OAAO,OAA4B;AAC5C,wFAAsE"}

package/build/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/genericrediscacher.ts","../src/rediscacheadapterprovider.ts","../src/rediscommon.ts","../src/index.ts","../src/errors/wrapnativerediscallasync.ts","../src/utils/getsurroundingcachekeyversionsforinvalidation.ts"],"version":"5.8.3"}

package/build/utils/getSurroundingCacheKeyVersionsForInvalidation.d.ts

@@ -0,0 +1 @@
+export declare function getSurroundingCacheKeyVersionsForInvalidation(cacheKeyVersion: number): readonly number[];

package/build/utils/getSurroundingCacheKeyVersionsForInvalidation.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSurroundingCacheKeyVersionsForInvalidation = getSurroundingCacheKeyVersionsForInvalidation;
+function getSurroundingCacheKeyVersionsForInvalidation(cacheKeyVersion) {
+    return [
+        ...(cacheKeyVersion === 0 ? [] : [cacheKeyVersion - 1]),
+        cacheKeyVersion,
+        cacheKeyVersion + 1,
+    ];
+}
+//# sourceMappingURL=getSurroundingCacheKeyVersionsForInvalidation.js.map

package/build/utils/getSurroundingCacheKeyVersionsForInvalidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSurroundingCacheKeyVersionsForInvalidation.js","sourceRoot":"","sources":["../../src/utils/getSurroundingCacheKeyVersionsForInvalidation.ts"],"names":[],"mappings":";;AAAA,sGAQC;AARD,SAAgB,6CAA6C,CAC3D,eAAuB;IAEvB,OAAO;QACL,GAAG,CAAC,eAAe,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe,GAAG,CAAC,CAAC,CAAC;QACvD,eAAe;QACf,eAAe,GAAG,CAAC;KACpB,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/entity-cache-adapter-redis",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "description": "Redis cache adapter for @expo/entity",
   "files": [
     "build",
@@ -10,6 +10,7 @@
   "types": "build/index.d.ts",
   "scripts": {
     "tsc": "tsc",
+    "build": "tsc -b tsconfig.build.json",
     "clean": "rm -rf build coverage coverage-integration",
     "lint": "eslint src",
     "lint-fix": "eslint src --fix",
@@ -27,26 +28,27 @@
   "author": "Expo",
   "license": "MIT",
   "dependencies": {
-    "@expo/entity": "^0.41.0"
+    "@expo/entity": "^0.42.0"
   },
   "peerDependencies": {
     "ioredis": ">=5"
   },
   "devDependencies": {
     "@expo/batcher": "^1.0.0",
-    "@types/jest": "^29.5.12",
+    "@expo/entity-testing-utils": "^0.42.0",
+    "@types/jest": "^29.5.14",
     "@types/node": "^20.14.1",
     "ctix": "^2.7.0",
     "eslint": "^8.57.1",
     "eslint-config-universe": "^14.0.0",
     "eslint-plugin-tsdoc": "^0.3.0",
-    "ioredis": "^5.4.1",
+    "ioredis": "^5.6.0",
     "jest": "^29.7.0",
     "prettier": "^3.3.3",
     "prettier-plugin-organize-imports": "^4.1.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.3.1",
     "ts-mockito": "^2.6.1",
-    "typescript": "^5.7.3"
+    "typescript": "^5.8.3"
   },
-  "gitHead": "ee4be736a9a0ba580e9af0194e07c9cd36b1c599"
+  "gitHead": "8414d96d948882735687da146e84913397cd8368"
 }

package/src/GenericRedisCacher.ts

@@ -5,11 +5,13 @@ import {
   transformCacheObjectToFields,
   transformFieldsToCacheObject,
   IEntityGenericCacher,
+  IEntityLoadKey,
+  IEntityLoadValue,
 } from '@expo/entity';
-import invariant from 'invariant';
 
 import { redisTransformerMap } from './RedisCommon';
 import wrapNativeRedisCallAsync from './errors/wrapNativeRedisCallAsync';
+import { getSurroundingCacheKeyVersionsForInvalidation } from './utils/getSurroundingCacheKeyVersionsForInvalidation';
 
 // Sentinel value we store in Redis to negatively cache a database miss.
 // The sentinel value is distinct from any (positively) cached value.
@@ -26,6 +28,24 @@ export interface IRedis {
   del(...args: [...keys: string[]]): Promise<any>;
 }
 
+/**
+ * The strategy for generating the set of cache keys to invalidate in the Redis cache after entity mutation.
+ */
+export enum RedisCacheInvalidationStrategy {
+  /**
+   * Invalidate just the cache key(s) for the current cacheKeyVersion of the entity.
+   */
+  CURRENT_CACHE_KEY_VERSION = 'current-cache-key-version',
+
+  /**
+   * Invalidate the cache key(s) for the current cacheKeyVersion and the surrounding cache key versions
+   * (e.g. `1`, `2` and `3` if the current version is `2`). This can be useful for deployment safety, where
+   * some machines may be operating on an old version of the code and thus an old cacheKeyVersion, and some the new version.
+   * This strategy generates cache keys for both old and potential future new versions.
+   */
+  SURROUNDING_CACHE_KEY_VERSIONS = 'surrounding-cache-key-versions',
+}
+
 export interface GenericRedisCacheContext {
   /**
    * Instance of ioredis.Redis
@@ -55,14 +75,21 @@ export interface GenericRedisCacheContext {
    * this TTL will be assumed not present in the database (unless invalidated).
    */
   ttlSecondsNegative: number;
+
+  /**
+   * Invalidation strategy for the cache.
+   */
+  invalidationStrategy: RedisCacheInvalidationStrategy;
 }
 
-export default class GenericRedisCacher<TFields extends Record<string, any>>
-  implements IEntityGenericCacher<TFields>
+export default class GenericRedisCacher<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> implements IEntityGenericCacher<TFields, TIDField>
 {
   constructor(
     private readonly context: GenericRedisCacheContext,
-    private readonly entityConfiguration: EntityConfiguration<TFields>,
+    private readonly entityConfiguration: EntityConfiguration<TFields, TIDField>,
   ) {}
 
   public async loadManyAsync(
@@ -147,18 +174,50 @@ export default class GenericRedisCacher<TFields extends Record<string, any>>
     await wrapNativeRedisCallAsync(() => this.context.redisClient.del(...keys));
   }
 
-  public makeCacheKey<N extends keyof TFields>(
-    fieldName: N,
-    fieldValue: NonNullable<TFields[N]>,
-  ): string {
-    const columnName = this.entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
-    invariant(columnName, `database field mapping missing for ${String(fieldName)}`);
+  private makeCacheKeyForCacheKeyVersion<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, value: TLoadValue, cacheKeyVersion: number): string {
+    const cacheKeyType = key.getLoadMethodType();
+    const parts = key.createCacheKeyPartsForLoadValue(this.entityConfiguration, value);
     return this.context.makeKeyFn(
       this.context.cacheKeyPrefix,
+      cacheKeyType,
       this.entityConfiguration.tableName,
-      `v2.${this.entityConfiguration.cacheKeyVersion}`,
-      columnName,
-      String(fieldValue),
+      `v2.${cacheKeyVersion}`,
+      ...parts,
+    );
+  }
+
+  public makeCacheKeyForStorage<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, value: TLoadValue): string {
+    return this.makeCacheKeyForCacheKeyVersion(
+      key,
+      value,
+      this.entityConfiguration.cacheKeyVersion,
     );
   }
+
+  public makeCacheKeysForInvalidation<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, value: TLoadValue): readonly string[] {
+    switch (this.context.invalidationStrategy) {
+      case RedisCacheInvalidationStrategy.CURRENT_CACHE_KEY_VERSION:
+        return [
+          this.makeCacheKeyForCacheKeyVersion(key, value, this.entityConfiguration.cacheKeyVersion),
+        ];
+      case RedisCacheInvalidationStrategy.SURROUNDING_CACHE_KEY_VERSIONS:
+        return getSurroundingCacheKeyVersionsForInvalidation(
+          this.entityConfiguration.cacheKeyVersion,
+        ).map((cacheKeyVersion) =>
+          this.makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion),
+        );
+    }
+  }
 }

package/src/RedisCacheAdapterProvider.ts

@@ -10,9 +10,9 @@ import GenericRedisCacher, { GenericRedisCacheContext } from './GenericRedisCach
 export default class RedisCacheAdapterProvider implements IEntityCacheAdapterProvider {
   constructor(private readonly context: GenericRedisCacheContext) {}
 
-  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> {
     return new GenericEntityCacheAdapter(new GenericRedisCacher(this.context, entityConfiguration));
   }
 }

package/src/__integration-tests__/BatchedRedisCacheAdapter-integration-test.ts

@@ -1,5 +1,11 @@
 import { Batcher } from '@expo/batcher';
-import { ViewerContext, zipToMap } from '@expo/entity';
+import {
+  IEntityGenericCacher,
+  SingleFieldHolder,
+  SingleFieldValueHolder,
+  ViewerContext,
+  zipToMap,
+} from '@expo/entity';
 import invariant from 'invariant';
 import Redis from 'ioredis';
 import nullthrows from 'nullthrows';
@@ -10,9 +16,10 @@ import GenericRedisCacher, {
   IRedis,
   IRedisTransaction,
   GenericRedisCacheContext,
+  RedisCacheInvalidationStrategy,
 } from '../GenericRedisCacher';
-import RedisTestEntity from '../testfixtures/RedisTestEntity';
-import { createRedisIntegrationTestEntityCompanionProvider } from '../testfixtures/createRedisIntegrationTestEntityCompanionProvider';
+import RedisTestEntity, { RedisTestEntityFields } from '../__testfixtures__/RedisTestEntity';
+import { createRedisIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createRedisIntegrationTestEntityCompanionProvider';
 
 class BatchedRedis implements IRedis {
   private readonly mgetBatcher = new Batcher<string[], (string | null)[]>(
@@ -78,6 +85,7 @@ describe(GenericRedisCacher, () => {
       cacheKeyPrefix: 'test-',
       ttlSecondsPositive: 86400, // 1 day
       ttlSecondsNegative: 600, // 10 minutes
+      invalidationStrategy: RedisCacheInvalidationStrategy.CURRENT_CACHE_KEY_VERSION,
     };
   });
 
@@ -97,11 +105,12 @@ describe(GenericRedisCacher, () => {
 
     const mgetSpy = jest.spyOn(redis, 'mget');
 
-    const genericCacher =
-      viewerContext.entityCompanionProvider.getCompanionForEntity(RedisTestEntity)[
-        'tableDataCoordinator'
-      ]['cacheAdapter']['genericCacher'];
-    const cacheKeyMaker = genericCacher['makeCacheKey'].bind(genericCacher);
+    const genericCacher = viewerContext.entityCompanionProvider.getCompanionForEntity(
+      RedisTestEntity,
+    )['tableDataCoordinator']['cacheAdapter']['genericCacher'] as IEntityGenericCacher<
+      RedisTestEntityFields,
+      'id'
+    >;
 
     const entity1Created = await RedisTestEntity.creator(viewerContext)
       .setField('name', 'blah')
@@ -132,7 +141,10 @@ describe(GenericRedisCacher, () => {
     expect(entity1.getID()).toEqual(entity2.getID());
     expect(entity2.getID()).toEqual(nullthrows(entity3).getID());
 
-    const cacheKeyEntity1 = cacheKeyMaker('id', entity1Created.getID());
+    const cacheKeyEntity1 = genericCacher.makeCacheKeyForStorage(
+      new SingleFieldHolder('id'),
+      new SingleFieldValueHolder(entity1Created.getID()),
+    );
     const cachedJSON = await redis.get(cacheKeyEntity1);
     const cachedValue = JSON.parse(cachedJSON!);
     expect(cachedValue).toMatchObject({
@@ -140,7 +152,10 @@ describe(GenericRedisCacher, () => {
       name: 'blah',
     });
 
-    const cacheKeyEntity1NameField = cacheKeyMaker('name', entity1Created.getField('name'));
+    const cacheKeyEntity1NameField = genericCacher.makeCacheKeyForStorage(
+      new SingleFieldHolder('name'),
+      new SingleFieldValueHolder(entity1Created.getField('name')),
+    );
     await RedisTestEntity.loader(viewerContext).loadByFieldEqualingAsync(
       'name',
       entity1Created.getField('name'),
@@ -154,7 +169,10 @@ describe(GenericRedisCacher, () => {
         nonExistentId,
       );
     expect(entityNonExistentResult.ok).toBe(false);
-    const cacheKeyNonExistent = cacheKeyMaker('id', nonExistentId);
+    const cacheKeyNonExistent = genericCacher.makeCacheKeyForStorage(
+      new SingleFieldHolder('id'),
+      new SingleFieldValueHolder(nonExistentId),
+    );
     const nonExistentCachedValue = await redis.get(cacheKeyNonExistent);
     expect(nonExistentCachedValue).toEqual('');
     // load again through entities framework to ensure it reads negative result

package/src/__integration-tests__/GenericRedisCacher-full-integration-test.ts

@@ -1,12 +1,22 @@
-import { ViewerContext } from '@expo/entity';
+import {
+  CompositeFieldHolder,
+  CompositeFieldValueHolder,
+  IEntityGenericCacher,
+  SingleFieldHolder,
+  SingleFieldValueHolder,
+  ViewerContext,
+} from '@expo/entity';
 import { enforceAsyncResult } from '@expo/results';
 import Redis from 'ioredis';
 import { URL } from 'url';
 import { v4 as uuidv4 } from 'uuid';
 
-import GenericRedisCacher, { GenericRedisCacheContext } from '../GenericRedisCacher';
-import RedisTestEntity from '../testfixtures/RedisTestEntity';
-import { createRedisIntegrationTestEntityCompanionProvider } from '../testfixtures/createRedisIntegrationTestEntityCompanionProvider';
+import GenericRedisCacher, {
+  GenericRedisCacheContext,
+  RedisCacheInvalidationStrategy,
+} from '../GenericRedisCacher';
+import RedisTestEntity, { RedisTestEntityFields } from '../__testfixtures__/RedisTestEntity';
+import { createRedisIntegrationTestEntityCompanionProvider } from '../__testfixtures__/createRedisIntegrationTestEntityCompanionProvider';
 
 class TestViewerContext extends ViewerContext {}
 
@@ -26,6 +36,7 @@ describe(GenericRedisCacher, () => {
       cacheKeyPrefix: 'test-',
       ttlSecondsPositive: 86400, // 1 day
       ttlSecondsNegative: 600, // 10 minutes
+      invalidationStrategy: RedisCacheInvalidationStrategy.CURRENT_CACHE_KEY_VERSION,
     };
   });
 
@@ -40,11 +51,12 @@ describe(GenericRedisCacher, () => {
     const viewerContext = new TestViewerContext(
       createRedisIntegrationTestEntityCompanionProvider(genericRedisCacheContext),
     );
-    const genericCacher =
-      viewerContext.entityCompanionProvider.getCompanionForEntity(RedisTestEntity)[
-        'tableDataCoordinator'
-      ]['cacheAdapter']['genericCacher'];
-    const cacheKeyMaker = genericCacher['makeCacheKey'].bind(genericCacher);
+    const genericCacher = viewerContext.entityCompanionProvider.getCompanionForEntity(
+      RedisTestEntity,
+    )['tableDataCoordinator']['cacheAdapter']['genericCacher'] as IEntityGenericCacher<
+      RedisTestEntityFields,
+      'id'
+    >;
 
     const entity1Created = await RedisTestEntity.creator(viewerContext)
       .setField('name', 'blah')
@@ -55,15 +67,35 @@ describe(GenericRedisCacher, () => {
       entity1Created.getID(),
     );
 
-    const cachedJSON = await (genericRedisCacheContext.redisClient as Redis).get(
-      cacheKeyMaker('id', entity1.getID()),
+    const cachedSingleJSON = await (genericRedisCacheContext.redisClient as Redis).get(
+      genericCacher.makeCacheKeyForStorage(
+        new SingleFieldHolder('id'),
+        new SingleFieldValueHolder(entity1.getID()),
+      ),
     );
-    const cachedValue = JSON.parse(cachedJSON!);
-    expect(cachedValue).toMatchObject({
+    const cachedSingleValue = JSON.parse(cachedSingleJSON!);
+    expect(cachedSingleValue).toMatchObject({
       id: entity1.getID(),
       name: 'blah',
     });
 
+    // loading an entity by composite field should put it in cache
+    const entity2 = await RedisTestEntity.loader(viewerContext).loadByCompositeFieldEqualingAsync(
+      ['name', 'id'],
+      { name: 'blah', id: entity1.getID() },
+    );
+    const cachedCompositeJSON = await (genericRedisCacheContext.redisClient as Redis).get(
+      genericCacher.makeCacheKeyForStorage(
+        new CompositeFieldHolder<RedisTestEntityFields, 'id'>(['id', 'name']),
+        new CompositeFieldValueHolder({ id: entity2!.getID(), name: 'blah' }),
+      ),
+    );
+    const cachedCompositeValue = JSON.parse(cachedCompositeJSON!);
+    expect(cachedCompositeValue).toMatchObject({
+      id: entity2!.getID(),
+      name: 'blah',
+    });
+
     // simulate non existent db fetch, should write negative result ('') to cache
     const nonExistentId = uuidv4();
 
@@ -72,25 +104,58 @@ describe(GenericRedisCacher, () => {
         nonExistentId,
       );
     expect(entityNonExistentResult.ok).toBe(false);
-
     const nonExistentCachedValue = await (genericRedisCacheContext.redisClient as Redis).get(
-      cacheKeyMaker('id', nonExistentId),
+      genericCacher.makeCacheKeyForStorage(
+        new SingleFieldHolder('id'),
+        new SingleFieldValueHolder(nonExistentId),
+      ),
     );
     expect(nonExistentCachedValue).toEqual('');
 
+    const entityNonExistentCompositeResult = await RedisTestEntity.loader(
+      viewerContext,
+    ).loadByCompositeFieldEqualingAsync(['name', 'id'], { name: 'blah', id: nonExistentId });
+    expect(entityNonExistentCompositeResult).toBe(null);
+    const nonExistentCompositeCachedValue = await (
+      genericRedisCacheContext.redisClient as Redis
+    ).get(
+      genericCacher.makeCacheKeyForStorage(
+        new CompositeFieldHolder<RedisTestEntityFields, 'id'>(['id', 'name']),
+        new CompositeFieldValueHolder({ id: nonExistentId, name: 'blah' }),
+      ),
+    );
+    expect(nonExistentCompositeCachedValue).toEqual('');
+
     // load again through entities framework to ensure it reads negative result
     const entityNonExistentResult2 =
       await RedisTestEntity.loaderWithAuthorizationResults(viewerContext).loadByIDAsync(
         nonExistentId,
       );
     expect(entityNonExistentResult2.ok).toBe(false);
+    const entityNonExistentCompositeResult2 = await RedisTestEntity.loader(
+      viewerContext,
+    ).loadByCompositeFieldEqualingAsync(['name', 'id'], { name: 'blah', id: nonExistentId });
+    expect(entityNonExistentCompositeResult2).toBe(null);
 
     // invalidate from cache to ensure it invalidates correctly
     await RedisTestEntity.loaderUtils(viewerContext).invalidateFieldsAsync(entity1.getAllFields());
-    const cachedValueNull = await (genericRedisCacheContext.redisClient as Redis).get(
-      cacheKeyMaker('id', entity1.getID()),
+    const cachedValueNullKeys = genericCacher.makeCacheKeysForInvalidation(
+      new SingleFieldHolder('id'),
+      new SingleFieldValueHolder(entity1.getID()),
+    );
+    const cachedValueNull = await (genericRedisCacheContext.redisClient as Redis).mget(
+      ...cachedValueNullKeys,
+    );
+    expect(cachedValueNull.every((c) => c === null)).toBe(true);
+
+    const cachedValueNullCompositeKeys = genericCacher.makeCacheKeysForInvalidation(
+      new CompositeFieldHolder<RedisTestEntityFields, 'id'>(['id', 'name']),
+      new CompositeFieldValueHolder({ id: entity1.getID(), name: 'blah' }),
+    );
+    const cachedValueNullComposite = await (genericRedisCacheContext.redisClient as Redis).mget(
+      ...cachedValueNullCompositeKeys,
     );
-    expect(cachedValueNull).toBe(null);
+    expect(cachedValueNullComposite.every((c) => c === null)).toBe(true);
   });
 
   it('caches and restores date fields', async () => {