@expo/entity-cache-adapter-redis 0.62.0 → 0.64.0

package/README.md

@@ -13,13 +13,7 @@ import Redis from 'ioredis';
 
 const genericRedisCacherContext = {
   redisClient: new Redis(new URL(process.env['REDIS_URL']!).toString()),
-  makeKeyFn(...parts: string[]): string {
-    const delimiter = ':';
-    const escapedParts = parts.map((part) =>
-      part.replaceAll('\\', '\\\\').replaceAll(delimiter, `\\${delimiter}`)
-    );
-    return escapedParts.join(delimiter);
-  },
+  cacheKeyDelimiter: ':',
   cacheKeyPrefix: 'ent-',
   ttlSecondsPositive: 86400, // 1 day
   ttlSecondsNegative: 600, // 10 minutes
@@ -40,4 +34,4 @@ export const createDefaultEntityCompanionProvider = (
     }
   );
 };
-```
+```

package/build/src/GenericRedisCacher.d.ts

@@ -55,10 +55,15 @@ export interface GenericRedisCacheContext {
      */
     redisClient: IRedis;
     /**
-     * Create a key string for key parts (cache key prefix, versions, entity name, etc).
-     * Most commonly a simple `parts.join(':')`. See integration test for example.
+     * Delimiter used to join the parts of a Redis cache key (cache key prefix,
+     * versions, entity name, field values, etc). Typically `:`.
+     *
+     * The cacher escapes occurrences of this delimiter (and the escape character `\`)
+     * within each part before joining, so the encoding is injective regardless of
+     * what the parts contain. This prevents a value that happens to contain the
+     * delimiter from colliding with a different (key, value) pair.
      */
-    makeKeyFn: (...parts: string[]) => string;
+    cacheKeyDelimiter: string;
     /**
      * Prefix prepended to all entity cache keys. Useful for adding a short, human-readable
      * distintion for entity keys, e.g. `ent-`

package/build/src/GenericRedisCacher.js

@@ -27,12 +27,27 @@ export var RedisCacheInvalidationStrategy;
      */
     RedisCacheInvalidationStrategy["CUSTOM"] = "custom";
 })(RedisCacheInvalidationStrategy || (RedisCacheInvalidationStrategy = {}));
+function validateGenericRedisCacheContext(context) {
+    if (context.cacheKeyDelimiter.length === 0) {
+        throw new Error('GenericRedisCacheContext.cacheKeyDelimiter must be a non-empty string');
+    }
+    if (context.cacheKeyDelimiter.includes('\\')) {
+        throw new Error(`GenericRedisCacheContext.cacheKeyDelimiter must not contain the escape character "\\" (got ${JSON.stringify(context.cacheKeyDelimiter)})`);
+    }
+    if (!Number.isInteger(context.ttlSecondsPositive) || context.ttlSecondsPositive <= 0) {
+        throw new Error(`GenericRedisCacheContext.ttlSecondsPositive must be a positive integer (got ${context.ttlSecondsPositive})`);
+    }
+    if (!Number.isInteger(context.ttlSecondsNegative) || context.ttlSecondsNegative <= 0) {
+        throw new Error(`GenericRedisCacheContext.ttlSecondsNegative must be a positive integer (got ${context.ttlSecondsNegative})`);
+    }
+}
 export class GenericRedisCacher {
     context;
     entityConfiguration;
     constructor(context, entityConfiguration) {
         this.context = context;
         this.entityConfiguration = entityConfiguration;
+        validateGenericRedisCacheContext(context);
     }
     async loadManyAsync(keys) {
         if (keys.length === 0) {
@@ -90,8 +105,18 @@ export class GenericRedisCacher {
     }
     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, `v3.${cacheKeyVersion}`, ...parts);
+        const keyAndValueParts = key.createCacheKeyPartsForLoadValue(this.entityConfiguration, value);
+        const allParts = [
+            this.context.cacheKeyPrefix,
+            cacheKeyType,
+            this.entityConfiguration.tableName,
+            `v4.${cacheKeyVersion}`,
+            ...keyAndValueParts,
+        ];
+        const delimiter = this.context.cacheKeyDelimiter;
+        return allParts
+            .map((part) => part.replaceAll('\\', '\\\\').replaceAll(delimiter, `\\${delimiter}`))
+            .join(delimiter);
     }
     makeCacheKeyForStorage(key, value) {
         return this.makeCacheKeyForCacheKeyVersion(key, value, this.entityConfiguration.cacheKeyVersion);
@@ -104,10 +129,13 @@ export class GenericRedisCacher {
                 ];
             case RedisCacheInvalidationStrategy.SURROUNDING_CACHE_KEY_VERSIONS:
                 return getSurroundingCacheKeyVersionsForInvalidation(this.entityConfiguration.cacheKeyVersion).map((cacheKeyVersion) => this.makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion));
-            case RedisCacheInvalidationStrategy.CUSTOM:
-                return this.context.invalidationConfig
-                    .cacheKeyVersionsToInvalidateFn(this.entityConfiguration.cacheKeyVersion)
-                    .map((cacheKeyVersion) => this.makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion));
+            case RedisCacheInvalidationStrategy.CUSTOM: {
+                const cacheKeyVersions = this.context.invalidationConfig.cacheKeyVersionsToInvalidateFn(this.entityConfiguration.cacheKeyVersion);
+                if (cacheKeyVersions.length === 0) {
+                    throw new Error(`GenericRedisCacheContext.invalidationConfig.cacheKeyVersionsToInvalidateFn returned an empty list for cacheKeyVersion ${this.entityConfiguration.cacheKeyVersion}; this would silently disable invalidation`);
+                }
+                return cacheKeyVersions.map((cacheKeyVersion) => this.makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion));
+            }
         }
     }
 }

package/package.json

@@ -1,46 +1,46 @@
 {
   "name": "@expo/entity-cache-adapter-redis",
-  "version": "0.62.0",
+  "version": "0.64.0",
   "description": "Redis cache adapter for @expo/entity",
+  "keywords": [
+    "entity"
+  ],
+  "license": "MIT",
+  "author": "Expo",
   "files": [
     "build",
     "!*.tsbuildinfo",
     "!__*",
     "src"
   ],
+  "type": "module",
   "main": "build/src/index.js",
   "types": "build/src/index.d.ts",
   "scripts": {
     "build": "tsc --build",
     "prepack": "rm -rf build && yarn build",
     "clean": "yarn build --clean",
-    "lint": "yarn run --top-level eslint src",
+    "lint": "yarn run --top-level oxlint --type-aware src",
     "lint-fix": "yarn lint --fix",
     "test": "yarn test:all --rootDir $(pwd)",
     "integration": "yarn integration:all --rootDir $(pwd)"
   },
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "entity"
-  ],
-  "author": "Expo",
-  "license": "MIT",
-  "type": "module",
   "dependencies": {
-    "@expo/entity": "^0.62.0"
-  },
-  "peerDependencies": {
-    "ioredis": ">=5"
+    "@expo/entity": "^0.64.0"
   },
   "devDependencies": {
     "@expo/batcher": "1.0.0",
-    "@expo/entity-testing-utils": "^0.62.0",
+    "@expo/entity-testing-utils": "^0.64.0",
     "@jest/globals": "30.3.0",
-    "ioredis": "5.10.0",
+    "ioredis": "5.10.1",
     "ts-mockito": "2.6.1",
-    "typescript": "5.9.3"
+    "typescript": "6.0.3"
+  },
+  "peerDependencies": {
+    "ioredis": ">=5"
+  },
+  "engines": {
+    "node": ">=18"
   },
-  "gitHead": "4965cc238882982e6315beca48a68679ed45456b"
+  "gitHead": "3f10a9e70eab45ae95acdae133055d8a3ec04ce8"
 }

package/src/GenericRedisCacher.ts

@@ -79,6 +79,27 @@ export type GenericRedisCacheInvalidationConfig =
       cacheKeyVersionsToInvalidateFn: (cacheKeyVersion: number) => readonly number[];
     };
 
+function validateGenericRedisCacheContext(context: GenericRedisCacheContext): void {
+  if (context.cacheKeyDelimiter.length === 0) {
+    throw new Error('GenericRedisCacheContext.cacheKeyDelimiter must be a non-empty string');
+  }
+  if (context.cacheKeyDelimiter.includes('\\')) {
+    throw new Error(
+      `GenericRedisCacheContext.cacheKeyDelimiter must not contain the escape character "\\" (got ${JSON.stringify(context.cacheKeyDelimiter)})`,
+    );
+  }
+  if (!Number.isInteger(context.ttlSecondsPositive) || context.ttlSecondsPositive <= 0) {
+    throw new Error(
+      `GenericRedisCacheContext.ttlSecondsPositive must be a positive integer (got ${context.ttlSecondsPositive})`,
+    );
+  }
+  if (!Number.isInteger(context.ttlSecondsNegative) || context.ttlSecondsNegative <= 0) {
+    throw new Error(
+      `GenericRedisCacheContext.ttlSecondsNegative must be a positive integer (got ${context.ttlSecondsNegative})`,
+    );
+  }
+}
+
 export interface GenericRedisCacheContext {
   /**
    * Instance of ioredis.Redis
@@ -86,10 +107,15 @@ export interface GenericRedisCacheContext {
   redisClient: IRedis;
 
   /**
-   * Create a key string for key parts (cache key prefix, versions, entity name, etc).
-   * Most commonly a simple `parts.join(':')`. See integration test for example.
+   * Delimiter used to join the parts of a Redis cache key (cache key prefix,
+   * versions, entity name, field values, etc). Typically `:`.
+   *
+   * The cacher escapes occurrences of this delimiter (and the escape character `\`)
+   * within each part before joining, so the encoding is injective regardless of
+   * what the parts contain. This prevents a value that happens to contain the
+   * delimiter from colliding with a different (key, value) pair.
    */
-  makeKeyFn: (...parts: string[]) => string;
+  cacheKeyDelimiter: string;
 
   /**
    * Prefix prepended to all entity cache keys. Useful for adding a short, human-readable
@@ -122,7 +148,9 @@ export class GenericRedisCacher<
   constructor(
     private readonly context: GenericRedisCacheContext,
     private readonly entityConfiguration: EntityConfiguration<TFields, TIDField>,
-  ) {}
+  ) {
+    validateGenericRedisCacheContext(context);
+  }
 
   public async loadManyAsync(
     keys: readonly string[],
@@ -212,14 +240,18 @@ export class GenericRedisCacher<
     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(
+    const keyAndValueParts = key.createCacheKeyPartsForLoadValue(this.entityConfiguration, value);
+    const allParts = [
       this.context.cacheKeyPrefix,
       cacheKeyType,
       this.entityConfiguration.tableName,
-      `v3.${cacheKeyVersion}`,
-      ...parts,
-    );
+      `v4.${cacheKeyVersion}`,
+      ...keyAndValueParts,
+    ];
+    const delimiter = this.context.cacheKeyDelimiter;
+    return allParts
+      .map((part) => part.replaceAll('\\', '\\\\').replaceAll(delimiter, `\\${delimiter}`))
+      .join(delimiter);
   }
 
   public makeCacheKeyForStorage<
@@ -250,12 +282,19 @@ export class GenericRedisCacher<
         ).map((cacheKeyVersion) =>
           this.makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion),
         );
-      case RedisCacheInvalidationStrategy.CUSTOM:
-        return this.context.invalidationConfig
-          .cacheKeyVersionsToInvalidateFn(this.entityConfiguration.cacheKeyVersion)
-          .map((cacheKeyVersion) =>
-            this.makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion),
+      case RedisCacheInvalidationStrategy.CUSTOM: {
+        const cacheKeyVersions = this.context.invalidationConfig.cacheKeyVersionsToInvalidateFn(
+          this.entityConfiguration.cacheKeyVersion,
+        );
+        if (cacheKeyVersions.length === 0) {
+          throw new Error(
+            `GenericRedisCacheContext.invalidationConfig.cacheKeyVersionsToInvalidateFn returned an empty list for cacheKeyVersion ${this.entityConfiguration.cacheKeyVersion}; this would silently disable invalidation`,
           );
+        }
+        return cacheKeyVersions.map((cacheKeyVersion) =>
+          this.makeCacheKeyForCacheKeyVersion(key, value, cacheKeyVersion),
+        );
+      }
     }
   }
 }

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

@@ -68,13 +68,7 @@ describe(GenericRedisCacher, () => {
   beforeAll(() => {
     genericRedisCacheContext = {
       redisClient,
-      makeKeyFn(...parts: string[]): string {
-        const delimiter = ':';
-        const escapedParts = parts.map((part) =>
-          part.replaceAll('\\', '\\\\').replaceAll(delimiter, `\\${delimiter}`),
-        );
-        return escapedParts.join(delimiter);
-      },
+      cacheKeyDelimiter: ':',
       cacheKeyPrefix: 'test-',
       ttlSecondsPositive: 86400, // 1 day
       ttlSecondsNegative: 600, // 10 minutes

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

@@ -26,13 +26,7 @@ describe(GenericRedisCacher, () => {
   beforeAll(() => {
     genericRedisCacheContext = {
       redisClient: new Redis(new URL(process.env['REDIS_URL']!).toString()),
-      makeKeyFn(...parts: string[]): string {
-        const delimiter = ':';
-        const escapedParts = parts.map((part) =>
-          part.replaceAll('\\', '\\\\').replaceAll(delimiter, `\\${delimiter}`),
-        );
-        return escapedParts.join(delimiter);
-      },
+      cacheKeyDelimiter: ':',
       cacheKeyPrefix: 'test-',
       ttlSecondsPositive: 86400, // 1 day
       ttlSecondsNegative: 600, // 10 minutes

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

@@ -20,13 +20,7 @@ describe(GenericRedisCacher, () => {
   beforeAll(() => {
     genericRedisCacheContext = {
       redisClient: new Redis(new URL(process.env['REDIS_URL']!).toString()),
-      makeKeyFn(...parts: string[]): string {
-        const delimiter = ':';
-        const escapedParts = parts.map((part) =>
-          part.replaceAll('\\', '\\\\').replaceAll(delimiter, `\\${delimiter}`),
-        );
-        return escapedParts.join(delimiter);
-      },
+      cacheKeyDelimiter: ':',
       cacheKeyPrefix: 'test-',
       ttlSecondsPositive: 86400, // 1 day
       ttlSecondsNegative: 600, // 10 minutes

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

@@ -17,13 +17,7 @@ describe(GenericRedisCacher, () => {
   beforeAll(() => {
     genericRedisCacheContext = {
       redisClient,
-      makeKeyFn(...parts: string[]): string {
-        const delimiter = ':';
-        const escapedParts = parts.map((part) =>
-          part.replaceAll('\\', '\\\\').replaceAll(delimiter, `\\${delimiter}`),
-        );
-        return escapedParts.join(delimiter);
-      },
+      cacheKeyDelimiter: ':',
       cacheKeyPrefix: 'test-',
       ttlSecondsPositive: 86400, // 1 day
       ttlSecondsNegative: 600, // 10 minutes

package/src/__tests__/GenericRedisCacher-test.ts

@@ -1,8 +1,11 @@
 import {
   CacheStatus,
+  CompositeFieldHolder,
+  CompositeFieldValueHolder,
   EntityConfiguration,
   SingleFieldHolder,
   SingleFieldValueHolder,
+  StringField,
   UUIDField,
 } from '@expo/entity';
 import { describe, expect, it } from '@jest/globals';
@@ -13,6 +16,8 @@ import { GenericRedisCacher, RedisCacheInvalidationStrategy } from '../GenericRe
 
 type BlahFields = {
   id: string;
+  fieldA: string;
+  fieldB: string;
 };
 
 const entityConfiguration = new EntityConfiguration<BlahFields, 'id'>({
@@ -21,6 +26,8 @@ const entityConfiguration = new EntityConfiguration<BlahFields, 'id'>({
   cacheKeyVersion: 2,
   schema: {
     id: new UUIDField({ columnName: 'id', cache: true }),
+    fieldA: new StringField({ columnName: 'field_a', cache: true }),
+    fieldB: new StringField({ columnName: 'field_b', cache: true }),
   },
   databaseAdapterFlavor: 'postgres',
   cacheAdapterFlavor: 'redis',
@@ -41,7 +48,7 @@ describe(GenericRedisCacher, () => {
       const genericCacher = new GenericRedisCacher(
         {
           redisClient: instance(mockRedisClient),
-          makeKeyFn: (...parts) => parts.join(':'),
+          cacheKeyDelimiter: ':',
           cacheKeyPrefix: 'hello-',
           ttlSecondsPositive: 1,
           ttlSecondsNegative: 2,
@@ -83,7 +90,7 @@ describe(GenericRedisCacher, () => {
       const genericCacher = new GenericRedisCacher(
         {
           redisClient: instance(mock<Redis>()),
-          makeKeyFn: (...parts) => parts.join(':'),
+          cacheKeyDelimiter: ':',
           cacheKeyPrefix: 'hello-',
           ttlSecondsPositive: 1,
           ttlSecondsNegative: 2,
@@ -118,7 +125,7 @@ describe(GenericRedisCacher, () => {
       const genericCacher = new GenericRedisCacher(
         {
           redisClient: instance(mockRedisClient),
-          makeKeyFn: (...parts) => parts.join(':'),
+          cacheKeyDelimiter: ':',
           cacheKeyPrefix: 'hello-',
           ttlSecondsPositive: 1,
           ttlSecondsNegative: 2,
@@ -134,10 +141,12 @@ describe(GenericRedisCacher, () => {
         new SingleFieldValueHolder('wat'),
       );
 
-      await genericCacher.cacheManyAsync(new Map([[cacheKey, { id: 'wat' }]]));
+      const value = { id: 'wat', fieldA: 'a', fieldB: 'b' };
+
+      await genericCacher.cacheManyAsync(new Map([[cacheKey, value]]));
 
       expect(redisResults.get(cacheKey)).toMatchObject({
-        value: JSON.stringify({ id: 'wat' }),
+        value: JSON.stringify(value),
         code: 'EX',
         ttl: 1,
       });
@@ -163,7 +172,7 @@ describe(GenericRedisCacher, () => {
       const genericCacher = new GenericRedisCacher(
         {
           redisClient: instance(mockRedisClient),
-          makeKeyFn: (...parts) => parts.join(':'),
+          cacheKeyDelimiter: ':',
           cacheKeyPrefix: 'hello-',
           ttlSecondsPositive: 1,
           ttlSecondsNegative: 2,
@@ -197,7 +206,7 @@ describe(GenericRedisCacher, () => {
       const genericCacher = new GenericRedisCacher(
         {
           redisClient: instance(mockRedisClient),
-          makeKeyFn: (...parts) => parts.join(':'),
+          cacheKeyDelimiter: ':',
           cacheKeyPrefix: 'hello-',
           ttlSecondsPositive: 1,
           ttlSecondsNegative: 2,
@@ -212,12 +221,40 @@ describe(GenericRedisCacher, () => {
         new SingleFieldValueHolder('wat'),
       );
       expect(cacheKeys).toHaveLength(1);
-      expect(cacheKeys[0]).toBe('hello-:single:blah:v3.2:id:wat');
+      expect(cacheKeys[0]).toBe('hello-:single:blah:v4.2:id:wat');
 
       await genericCacher.invalidateManyAsync(cacheKeys);
       verify(mockRedisClient.del(...cacheKeys)).once();
     });
 
+    it('does not collapse composite cache keys with delimiter-bearing parts', () => {
+      const genericCacher = new GenericRedisCacher(
+        {
+          redisClient: instance(mock<Redis>()),
+          cacheKeyPrefix: 'hello-',
+          cacheKeyDelimiter: ':',
+          ttlSecondsPositive: 1,
+          ttlSecondsNegative: 2,
+          invalidationConfig: {
+            invalidationStrategy: RedisCacheInvalidationStrategy.CURRENT_CACHE_KEY_VERSION,
+          },
+        },
+        entityConfiguration,
+      );
+
+      const compositeFieldHolder = new CompositeFieldHolder<BlahFields, 'id'>(['fieldA', 'fieldB']);
+      const cacheKey1 = genericCacher['makeCacheKeyForStorage'](
+        compositeFieldHolder,
+        new CompositeFieldValueHolder({ fieldA: 'a:b', fieldB: 'c' }),
+      );
+      const cacheKey2 = genericCacher['makeCacheKeyForStorage'](
+        compositeFieldHolder,
+        new CompositeFieldValueHolder({ fieldA: 'a', fieldB: 'b:c' }),
+      );
+
+      expect(cacheKey1).not.toEqual(cacheKey2);
+    });
+
     it('invalidates correctly with RedisCacheInvalidationStrategy.SURROUNDING_CACHE_KEY_VERSIONS', async () => {
       const mockRedisClient = mock<Redis>();
       when(mockRedisClient.del()).thenResolve(1);
@@ -225,7 +262,7 @@ describe(GenericRedisCacher, () => {
       const genericCacher = new GenericRedisCacher(
         {
           redisClient: instance(mockRedisClient),
-          makeKeyFn: (...parts) => parts.join(':'),
+          cacheKeyDelimiter: ':',
           cacheKeyPrefix: 'hello-',
           ttlSecondsPositive: 1,
           ttlSecondsNegative: 2,
@@ -240,9 +277,9 @@ describe(GenericRedisCacher, () => {
         new SingleFieldValueHolder('wat'),
       );
       expect(cacheKeys).toHaveLength(3);
-      expect(cacheKeys[0]).toBe('hello-:single:blah:v3.1:id:wat');
-      expect(cacheKeys[1]).toBe('hello-:single:blah:v3.2:id:wat');
-      expect(cacheKeys[2]).toBe('hello-:single:blah:v3.3:id:wat');
+      expect(cacheKeys[0]).toBe('hello-:single:blah:v4.1:id:wat');
+      expect(cacheKeys[1]).toBe('hello-:single:blah:v4.2:id:wat');
+      expect(cacheKeys[2]).toBe('hello-:single:blah:v4.3:id:wat');
 
       await genericCacher.invalidateManyAsync(cacheKeys);
       verify(mockRedisClient.del(...cacheKeys)).once();
@@ -255,7 +292,7 @@ describe(GenericRedisCacher, () => {
       const genericCacher = new GenericRedisCacher(
         {
           redisClient: instance(mockRedisClient),
-          makeKeyFn: (...parts) => parts.join(':'),
+          cacheKeyDelimiter: ':',
           cacheKeyPrefix: 'hello-',
           ttlSecondsPositive: 1,
           ttlSecondsNegative: 2,
@@ -278,10 +315,10 @@ describe(GenericRedisCacher, () => {
         new SingleFieldValueHolder('wat'),
       );
       expect(cacheKeys).toHaveLength(4);
-      expect(cacheKeys[0]).toBe('hello-:single:blah:v3.2:id:wat');
-      expect(cacheKeys[1]).toBe('hello-:single:blah:v3.3:id:wat');
-      expect(cacheKeys[2]).toBe('hello-:single:blah:v3.4:id:wat');
-      expect(cacheKeys[3]).toBe('hello-:single:blah:v3.5:id:wat');
+      expect(cacheKeys[0]).toBe('hello-:single:blah:v4.2:id:wat');
+      expect(cacheKeys[1]).toBe('hello-:single:blah:v4.3:id:wat');
+      expect(cacheKeys[2]).toBe('hello-:single:blah:v4.4:id:wat');
+      expect(cacheKeys[3]).toBe('hello-:single:blah:v4.5:id:wat');
 
       await genericCacher.invalidateManyAsync(cacheKeys);
       verify(mockRedisClient.del(...cacheKeys)).once();
@@ -291,7 +328,7 @@ describe(GenericRedisCacher, () => {
       const genericCacher = new GenericRedisCacher(
         {
           redisClient: instance(mock<Redis>()),
-          makeKeyFn: (...parts) => parts.join(':'),
+          cacheKeyDelimiter: ':',
           cacheKeyPrefix: 'hello-',
           ttlSecondsPositive: 1,
           ttlSecondsNegative: 2,
@@ -303,5 +340,89 @@ describe(GenericRedisCacher, () => {
       );
       await genericCacher.invalidateManyAsync([]);
     });
+
+    it('throws when CUSTOM strategy returns an empty cacheKeyVersions list', () => {
+      const genericCacher = new GenericRedisCacher(
+        {
+          redisClient: instance(mock<Redis>()),
+          cacheKeyDelimiter: ':',
+          cacheKeyPrefix: 'hello-',
+          ttlSecondsPositive: 1,
+          ttlSecondsNegative: 2,
+          invalidationConfig: {
+            invalidationStrategy: RedisCacheInvalidationStrategy.CUSTOM,
+            cacheKeyVersionsToInvalidateFn: () => [],
+          },
+        },
+        entityConfiguration,
+      );
+      expect(() =>
+        genericCacher['makeCacheKeysForInvalidation'](
+          new SingleFieldHolder('id'),
+          new SingleFieldValueHolder('wat'),
+        ),
+      ).toThrow(/empty list/);
+    });
+  });
+
+  describe('GenericRedisCacheContext validation', () => {
+    const validContext = {
+      redisClient: instance(mock<Redis>()),
+      cacheKeyDelimiter: ':',
+      cacheKeyPrefix: 'hello-',
+      ttlSecondsPositive: 1,
+      ttlSecondsNegative: 2,
+      invalidationConfig: {
+        invalidationStrategy: RedisCacheInvalidationStrategy.CURRENT_CACHE_KEY_VERSION as const,
+      },
+    };
+
+    it('throws when cacheKeyDelimiter is empty', () => {
+      expect(
+        () =>
+          new GenericRedisCacher({ ...validContext, cacheKeyDelimiter: '' }, entityConfiguration),
+      ).toThrow(/cacheKeyDelimiter must be a non-empty string/);
+    });
+
+    it('throws when cacheKeyDelimiter contains the escape character', () => {
+      expect(
+        () =>
+          new GenericRedisCacher({ ...validContext, cacheKeyDelimiter: '\\' }, entityConfiguration),
+      ).toThrow(/must not contain the escape character/);
+    });
+
+    it('throws when ttlSecondsPositive is not a positive integer', () => {
+      expect(
+        () =>
+          new GenericRedisCacher({ ...validContext, ttlSecondsPositive: 0 }, entityConfiguration),
+      ).toThrow(/ttlSecondsPositive must be a positive integer/);
+      expect(
+        () =>
+          new GenericRedisCacher({ ...validContext, ttlSecondsPositive: -1 }, entityConfiguration),
+      ).toThrow(/ttlSecondsPositive must be a positive integer/);
+      expect(
+        () =>
+          new GenericRedisCacher({ ...validContext, ttlSecondsPositive: 1.5 }, entityConfiguration),
+      ).toThrow(/ttlSecondsPositive must be a positive integer/);
+    });
+
+    it('throws when ttlSecondsNegative is not a positive integer', () => {
+      expect(
+        () =>
+          new GenericRedisCacher({ ...validContext, ttlSecondsNegative: 0 }, entityConfiguration),
+      ).toThrow(/ttlSecondsNegative must be a positive integer/);
+      expect(
+        () =>
+          new GenericRedisCacher({ ...validContext, ttlSecondsNegative: -1 }, entityConfiguration),
+      ).toThrow(/ttlSecondsNegative must be a positive integer/);
+      expect(
+        () =>
+          new GenericRedisCacher({ ...validContext, ttlSecondsNegative: 1.5 }, entityConfiguration),
+      ).toThrow(/ttlSecondsNegative must be a positive integer/);
+    });
+
+    it('accepts a valid context', () => {
+      expect(() => new GenericRedisCacher(validContext, entityConfiguration)).not.toThrow();
+    });
   });
 });