@trieb.work/nextjs-turbo-redis-cache 1.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,50 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write # Grant write access to pull request comments
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run lint
+        run: npm run lint
+
+      - name: Run tests
+        run: npm run test
+
+      - name: Code Coverage Comments
+        uses: kcjpop/coverage-comments@v2.2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          coverage-file: './coverage/lcov.info'
+
+      - name: Build project
+        run: npm run build
+      
+      - name: Dry run the release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # GitHub token for Semantic Release
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} # NPM token for publishing
+        run: |
+          npx semantic-release --dry-run
+

package/.github/workflows/release.yml

@@ -0,0 +1,30 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+      - beta
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run Semantic Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # GitHub token for Semantic Release
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }} # NPM token for publishing
+        run: npx semantic-release

package/.prettierrc.json

@@ -0,0 +1,6 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "printWidth": 80,
+  "trailingComma": "all"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 trieb.work | cloud consulting
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# nextjs-turbo-redis-cache
+
+The ultimate Redis caching solution for Next.js. Built for production-ready, large-scale projects, it delivers unparalleled performance and efficiency with features tailored for high-traffic applications.
+
+Key Features:
+
+- _Turbocharged Storage_: Avoids base64 encoding to save ~33% of storage space compared to traditional implementations.
+- _Batch Tag Invalidation_: Groups and optimizes delete operations for minimal Redis stress.
+- _Request Deduplication_: Prevents redundant Redis get calls, ensuring faster response times.
+- _In-Memory Caching_: Includes local caching for Redis get operations to reduce latency further.
+- _Efficient Tag Management_: in-memory tags map for lightning-fast revalidate operations with minimal Redis overhead.
+- _Intelligent Key-Space Notifications_: Automatic update of in-memory tags map for expired or evicted keys.
+
+## Describe Options
+
+TODO
+
+## Getting started
+
+TODO add description for how to use it
+
+## Consistency
+
+To understand consistency levels of this caching implementation we first have to understand the consistency of redis itself:
+Redis executes commands in a single-threaded manner. This ensures that all operations are processed sequentially, so clients always see a consistent view of the data.
+But depending on the setup of redis this can change:
+
+- Strong consistency: only for single node setup
+- Eventual consistency: In a master-replica setup (strong consistency only while there is no failover)
+- Eventual consistency: In Redis Cluster mode
+
+Consistency levels of Caching Handler:
+If Redis is used in a single node setup and Request Deduplication is turned off, only then the caching handler will have strong consistency.
+
+If using Request Deduplication, the strong consistency is not guaranteed anymore. The following sequence can happen with request deduplication:
+Instance 1: call set A 1
+Instance 1: served set A 1
+Instance 2: call get A
+Instance 1: call delete A
+Instance 2: call get A
+Instance 2: served get A -> 1
+Instance 2: served get A -> 1 (served 1 but should already be deleted)
+Instance 1: served delete A
+
+The time window for this eventual consistency to occur is typically around the length of a single redis command. Depending on your load ranging from 5ms to max 100ms.
+If using local in-memory caching (Enabled by RedisStringsHandler option inMemoryCachingTime), the window for this eventual consistency to occur can be even higher because additionally also synchronization messages have to get delivered. Depending on your load typically ranging around 50ms to max of 120ms.
+
+Since all caching calls in one api/page/server action request is always served by the same instance this problem will not occur inside a single request but rather in a combination of multiple parallel requests. The probability that this will occur for a single user during a request sequence is very low, since typically a single user will not make the follow up request during this small time window of typically 50ms. To further mitigate the Problem and increase performance (increase local in-memory cache hit ratio) make sure that your load balancer will always serve one user to the same instance (sticky sessions).
+
+## Development
+
+5. Run `npm install` to install the dependencies
+6. Run `npm run build` to build the project
+7. Run `npm run dev` to develop the project
+8. Run `npm run test` to test the project
+9. Checkout into a new branch (main is protected)
+10. Change code and commit it using conventional commit. Staged code will get checked
+11. Push and create a PR (against main or beta) to run CI
+12. Merge to main or beta to create a release or pre-release
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

package/commitlint.config.cjs

@@ -0,0 +1,4 @@
+// commitlint.config.js
+module.exports = {
+  extends: ["@commitlint/config-conventional"],
+};

package/dist/CachedHandler.d.ts

@@ -0,0 +1,9 @@
+import { CacheHandler } from "next/dist/server/lib/incremental-cache";
+import RedisStringsHandler, { CreateRedisStringsHandlerOptions } from "./RedisStringsHandler";
+export default class CachedHandler implements CacheHandler {
+    constructor(options: CreateRedisStringsHandlerOptions);
+    get(...args: Parameters<RedisStringsHandler["get"]>): ReturnType<RedisStringsHandler["get"]>;
+    set(...args: Parameters<RedisStringsHandler["set"]>): ReturnType<RedisStringsHandler["set"]>;
+    revalidateTag(...args: Parameters<RedisStringsHandler["revalidateTag"]>): ReturnType<RedisStringsHandler["revalidateTag"]>;
+    resetRequestCache(...args: Parameters<RedisStringsHandler["resetRequestCache"]>): ReturnType<RedisStringsHandler["resetRequestCache"]>;
+}

package/dist/CachedHandler.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RedisStringsHandler_1 = __importDefault(require("./RedisStringsHandler"));
+let cachedHandler;
+class CachedHandler {
+    constructor(options) {
+        if (!cachedHandler) {
+            console.log("created cached handler");
+            cachedHandler = new RedisStringsHandler_1.default(options);
+        }
+    }
+    get(...args) {
+        return cachedHandler.get(...args);
+    }
+    set(...args) {
+        return cachedHandler.set(...args);
+    }
+    revalidateTag(...args) {
+        return cachedHandler.revalidateTag(...args);
+    }
+    resetRequestCache(...args) {
+        return cachedHandler.resetRequestCache(...args);
+    }
+}
+exports.default = CachedHandler;

package/dist/DeduplicatedRequestHandler.d.ts

@@ -0,0 +1,9 @@
+import { SyncedMap } from './SyncedMap';
+export declare class DeduplicatedRequestHandler<T extends (...args: [never, never]) => Promise<K>, K> {
+    private inMemoryDeduplicationCache;
+    private cachingTimeMs;
+    private fn;
+    constructor(fn: T, cachingTimeMs: number, inMemoryDeduplicationCache: SyncedMap<Promise<K>>);
+    seedRequestReturn(key: string, value: K): void;
+    deduplicatedFunction: (key: string) => T;
+}

package/dist/DeduplicatedRequestHandler.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeduplicatedRequestHandler = void 0;
+class DeduplicatedRequestHandler {
+    constructor(fn, cachingTimeMs, inMemoryDeduplicationCache) {
+        // Method to handle deduplicated requests
+        this.deduplicatedFunction = (key) => {
+            //eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this;
+            const dedupedFn = async (...args) => {
+                // If there's already a pending request with the same key, return it
+                if (self.inMemoryDeduplicationCache &&
+                    self.inMemoryDeduplicationCache.has(key)) {
+                    const res = await self.inMemoryDeduplicationCache
+                        .get(key)
+                        .then((v) => structuredClone(v));
+                    return res;
+                }
+                // If no pending request, call the original function and store the promise
+                const promise = self.fn(...args);
+                self.inMemoryDeduplicationCache.set(key, promise);
+                try {
+                    const result = await promise;
+                    return structuredClone(result);
+                }
+                finally {
+                    // Once the promise is resolved/rejected, remove it from the map
+                    setTimeout(() => {
+                        self.inMemoryDeduplicationCache.delete(key);
+                    }, self.cachingTimeMs);
+                }
+            };
+            return dedupedFn;
+        };
+        this.fn = fn;
+        this.cachingTimeMs = cachingTimeMs;
+        this.inMemoryDeduplicationCache = inMemoryDeduplicationCache;
+    }
+    // Method to manually seed a result into the cache
+    seedRequestReturn(key, value) {
+        const resultPromise = new Promise((res) => res(value));
+        this.inMemoryDeduplicationCache.set(key, resultPromise);
+        setTimeout(() => {
+            this.inMemoryDeduplicationCache.delete(key);
+        }, this.cachingTimeMs);
+    }
+}
+exports.DeduplicatedRequestHandler = DeduplicatedRequestHandler;

package/dist/RedisStringsHandler.d.ts

@@ -0,0 +1,48 @@
+import { commandOptions, createClient } from 'redis';
+import { CacheHandler, CacheHandlerValue, IncrementalCache } from 'next/dist/server/lib/incremental-cache';
+export type CommandOptions = ReturnType<typeof commandOptions>;
+type GetParams = Parameters<IncrementalCache['get']>;
+type SetParams = Parameters<IncrementalCache['set']>;
+type RevalidateParams = Parameters<IncrementalCache['revalidateTag']>;
+export type Client = ReturnType<typeof createClient>;
+export type CreateRedisStringsHandlerOptions = {
+    database?: number;
+    keyPrefix?: string;
+    timeoutMs?: number;
+    revalidateTagQuerySize?: number;
+    sharedTagsKey?: string;
+    avgResyncIntervalMs?: number;
+    redisGetDeduplication?: boolean;
+    inMemoryCachingTime?: number;
+    defaultStaleAge?: number;
+    estimateExpireAge?: (staleAge: number) => number;
+    maxMemoryCacheSize?: number;
+};
+export declare function getTimeoutRedisCommandOptions(timeoutMs: number): CommandOptions;
+export default class RedisStringsHandler implements CacheHandler {
+    private maxMemoryCacheSize;
+    private client;
+    private sharedTagsMap;
+    private revalidatedTagsMap;
+    private inMemoryDeduplicationCache;
+    private redisGet;
+    private redisDeduplicationHandler;
+    private deduplicatedRedisGet;
+    private timeoutMs;
+    private keyPrefix;
+    private redisGetDeduplication;
+    private inMemoryCachingTime;
+    private defaultStaleAge;
+    private estimateExpireAge;
+    constructor({ maxMemoryCacheSize, database, keyPrefix, sharedTagsKey, timeoutMs, revalidateTagQuerySize, avgResyncIntervalMs, redisGetDeduplication, inMemoryCachingTime, defaultStaleAge, estimateExpireAge, }: CreateRedisStringsHandlerOptions);
+    resetRequestCache(...args: never[]): void;
+    private assertClientIsReady;
+    get(key: GetParams[0], ctx: GetParams[1]): Promise<(CacheHandlerValue & {
+        lastModified: number;
+    }) | null>;
+    set(key: SetParams[0], data: SetParams[1] & {
+        lastModified: number;
+    }, ctx: SetParams[2]): Promise<void>;
+    revalidateTag(tagOrTags: RevalidateParams[0]): Promise<void>;
+}
+export {};

package/dist/RedisStringsHandler.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeoutRedisCommandOptions = getTimeoutRedisCommandOptions;
+const redis_1 = require("redis");
+const SyncedMap_1 = require("./SyncedMap");
+const DeduplicatedRequestHandler_1 = require("./DeduplicatedRequestHandler");
+const NEXT_CACHE_IMPLICIT_TAG_ID = '_N_T_';
+const REVALIDATED_TAGS_KEY = '__revalidated_tags__';
+function isImplicitTag(tag) {
+    return tag.startsWith(NEXT_CACHE_IMPLICIT_TAG_ID);
+}
+function getTimeoutRedisCommandOptions(timeoutMs) {
+    return (0, redis_1.commandOptions)({ signal: AbortSignal.timeout(timeoutMs) });
+}
+class RedisStringsHandler {
+    constructor({ maxMemoryCacheSize, database = process.env.VERCEL_ENV === 'production' ? 0 : 1, keyPrefix = process.env.VERCEL_URL || 'UNDEFINED_URL_', sharedTagsKey = '__sharedTags__', timeoutMs = 5000, revalidateTagQuerySize = 250, avgResyncIntervalMs = 60 * 60 * 1000, redisGetDeduplication = true, inMemoryCachingTime = 10000, defaultStaleAge = 60 * 60 * 24 * 14, estimateExpireAge = (staleAge) => process.env.VERCEL_ENV === 'preview' ? staleAge * 1.2 : staleAge * 2, }) {
+        this.maxMemoryCacheSize = maxMemoryCacheSize;
+        this.keyPrefix = keyPrefix;
+        this.timeoutMs = timeoutMs;
+        this.redisGetDeduplication = redisGetDeduplication;
+        this.inMemoryCachingTime = inMemoryCachingTime;
+        this.defaultStaleAge = defaultStaleAge;
+        this.estimateExpireAge = estimateExpireAge;
+        try {
+            this.client = (0, redis_1.createClient)({
+                ...(database !== 0 ? { database } : {}),
+                url: process.env.REDISHOST
+                    ? `redis://${process.env.REDISHOST}:${process.env.REDISPORT}`
+                    : 'redis://localhost:6379',
+            });
+            this.client.on('error', (error) => {
+                console.error('Redis client error', error);
+            });
+            this.client
+                .connect()
+                .then(() => {
+                console.info('Redis client connected.');
+            })
+                .catch((error) => {
+                console.error('Failed to connect Redis client:', error);
+                this.client.disconnect();
+            });
+        }
+        catch (error) {
+            console.error('Failed to initialize Redis client');
+            throw error;
+        }
+        const filterKeys = (key) => key !== REVALIDATED_TAGS_KEY && key !== sharedTagsKey;
+        this.sharedTagsMap = new SyncedMap_1.SyncedMap({
+            client: this.client,
+            keyPrefix,
+            redisKey: sharedTagsKey,
+            database,
+            timeoutMs,
+            querySize: revalidateTagQuerySize,
+            filterKeys,
+            resyncIntervalMs: avgResyncIntervalMs -
+                avgResyncIntervalMs / 10 +
+                Math.random() * (avgResyncIntervalMs / 10),
+        });
+        this.revalidatedTagsMap = new SyncedMap_1.SyncedMap({
+            client: this.client,
+            keyPrefix,
+            redisKey: REVALIDATED_TAGS_KEY,
+            database,
+            timeoutMs,
+            querySize: revalidateTagQuerySize,
+            filterKeys,
+            resyncIntervalMs: avgResyncIntervalMs +
+                avgResyncIntervalMs / 10 +
+                Math.random() * (avgResyncIntervalMs / 10),
+        });
+        this.inMemoryDeduplicationCache = new SyncedMap_1.SyncedMap({
+            client: this.client,
+            keyPrefix,
+            redisKey: 'inMemoryDeduplicationCache',
+            database,
+            timeoutMs,
+            querySize: revalidateTagQuerySize,
+            filterKeys,
+            customizedSync: {
+                withoutRedisHashmap: true,
+                withoutSetSync: true,
+            },
+        });
+        const redisGet = this.client.get.bind(this.client);
+        this.redisDeduplicationHandler = new DeduplicatedRequestHandler_1.DeduplicatedRequestHandler(redisGet, inMemoryCachingTime, this.inMemoryDeduplicationCache);
+        this.redisGet = redisGet;
+        this.deduplicatedRedisGet =
+            this.redisDeduplicationHandler.deduplicatedFunction;
+    }
+    resetRequestCache(...args) {
+        console.warn('WARNING resetRequestCache() was called', args);
+    }
+    async assertClientIsReady() {
+        await Promise.all([
+            this.sharedTagsMap.waitUntilReady(),
+            this.revalidatedTagsMap.waitUntilReady(),
+        ]);
+        if (!this.client.isReady) {
+            throw new Error('Redis client is not ready yet or connection is lost.');
+        }
+    }
+    async get(key, ctx) {
+        await this.assertClientIsReady();
+        const clientGet = this.redisGetDeduplication
+            ? this.deduplicatedRedisGet(key)
+            : this.redisGet;
+        const result = await clientGet(getTimeoutRedisCommandOptions(this.timeoutMs), this.keyPrefix + key);
+        if (!result) {
+            return null;
+        }
+        const cacheValue = JSON.parse(result);
+        if (!cacheValue) {
+            return null;
+        }
+        if (cacheValue.value?.kind === 'FETCH') {
+            cacheValue.value.data.body = Buffer.from(cacheValue.value.data.body).toString('base64');
+        }
+        const combinedTags = new Set([
+            ...(ctx?.softTags || []),
+            ...(ctx?.tags || []),
+        ]);
+        if (combinedTags.size === 0) {
+            return cacheValue;
+        }
+        for (const tag of combinedTags) {
+            // TODO: check how this revalidatedTagsMap is used or if it can be deleted
+            const revalidationTime = this.revalidatedTagsMap.get(tag);
+            if (revalidationTime && revalidationTime > cacheValue.lastModified) {
+                const redisKey = this.keyPrefix + key;
+                // Do not await here as this can happen in the background while we can already serve the cacheValue
+                this.client
+                    .unlink(getTimeoutRedisCommandOptions(this.timeoutMs), redisKey)
+                    .catch((err) => {
+                    console.error('Error occurred while unlinking stale data. Retrying now. Error was:', err);
+                    this.client.unlink(getTimeoutRedisCommandOptions(this.timeoutMs), redisKey);
+                })
+                    .finally(async () => {
+                    await this.sharedTagsMap.delete(key);
+                    await this.revalidatedTagsMap.delete(tag);
+                });
+                return null;
+            }
+        }
+        return cacheValue;
+    }
+    async set(key, data, ctx) {
+        if (data.kind === 'FETCH') {
+            console.time('encoding' + key);
+            data.data.body = Buffer.from(data.data.body, 'base64').toString();
+            console.timeEnd('encoding' + key);
+        }
+        await this.assertClientIsReady();
+        data.lastModified = Date.now();
+        const value = JSON.stringify(data);
+        // pre seed data into deduplicated get client. This will reduce redis load by not requesting
+        // the same value from redis which was just set.
+        if (this.redisGetDeduplication) {
+            this.redisDeduplicationHandler.seedRequestReturn(key, value);
+        }
+        const expireAt = ctx.revalidate &&
+            Number.isSafeInteger(ctx.revalidate) &&
+            ctx.revalidate > 0
+            ? this.estimateExpireAge(ctx.revalidate)
+            : this.estimateExpireAge(this.defaultStaleAge);
+        const options = getTimeoutRedisCommandOptions(this.timeoutMs);
+        const setOperation = this.client.set(options, this.keyPrefix + key, value, {
+            EX: expireAt,
+        });
+        let setTagsOperation;
+        if (ctx.tags && ctx.tags.length > 0) {
+            const currentTags = this.sharedTagsMap.get(key);
+            const currentIsSameAsNew = currentTags?.length === ctx.tags.length &&
+                currentTags.every((v) => ctx.tags.includes(v)) &&
+                ctx.tags.every((v) => currentTags.includes(v));
+            if (!currentIsSameAsNew) {
+                setTagsOperation = this.sharedTagsMap.set(key, structuredClone(ctx.tags));
+            }
+        }
+        await Promise.all([setOperation, setTagsOperation]);
+    }
+    async revalidateTag(tagOrTags) {
+        const tags = new Set([tagOrTags || []].flat());
+        await this.assertClientIsReady();
+        // TODO: check how this revalidatedTagsMap is used or if it can be deleted
+        for (const tag of tags) {
+            if (isImplicitTag(tag)) {
+                const now = Date.now();
+                await this.revalidatedTagsMap.set(tag, now);
+            }
+        }
+        const keysToDelete = [];
+        for (const [key, sharedTags] of this.sharedTagsMap.entries()) {
+            if (sharedTags.some((tag) => tags.has(tag))) {
+                keysToDelete.push(key);
+            }
+        }
+        if (keysToDelete.length === 0) {
+            return;
+        }
+        const fullRedisKeys = keysToDelete.map((key) => this.keyPrefix + key);
+        const options = getTimeoutRedisCommandOptions(this.timeoutMs);
+        const deleteKeysOperation = this.client.unlink(options, fullRedisKeys);
+        // delete entries from in-memory deduplication cache
+        if (this.redisGetDeduplication && this.inMemoryCachingTime > 0) {
+            for (const key of keysToDelete) {
+                this.inMemoryDeduplicationCache.delete(key);
+            }
+        }
+        const deleteTagsOperation = this.sharedTagsMap.delete(keysToDelete);
+        await Promise.all([deleteKeysOperation, deleteTagsOperation]);
+    }
+}
+exports.default = RedisStringsHandler;

package/dist/SyncedMap.d.ts

@@ -0,0 +1,51 @@
+import { Client } from './RedisStringsHandler';
+type CustomizedSync = {
+    withoutRedisHashmap?: boolean;
+    withoutSetSync?: boolean;
+};
+type SyncedMapOptions = {
+    client: Client;
+    keyPrefix: string;
+    redisKey: string;
+    database: number;
+    timeoutMs: number;
+    querySize: number;
+    filterKeys: (key: string) => boolean;
+    resyncIntervalMs?: number;
+    customizedSync?: CustomizedSync;
+};
+export type SyncMessage<V> = {
+    type: 'insert' | 'delete';
+    key?: string;
+    value?: V;
+    keys?: string[];
+};
+export declare class SyncedMap<V> {
+    private client;
+    private subscriberClient;
+    private map;
+    private keyPrefix;
+    private syncChannel;
+    private redisKey;
+    private database;
+    private timeoutMs;
+    private querySize;
+    private filterKeys;
+    private resyncIntervalMs?;
+    private customizedSync?;
+    private setupLock;
+    private setupLockResolve;
+    constructor(options: SyncedMapOptions);
+    private setup;
+    private initialSync;
+    private cleanupKeysNotInRedis;
+    private setupPeriodicResync;
+    private setupPubSub;
+    waitUntilReady(): Promise<void>;
+    get(key: string): V | undefined;
+    set(key: string, value: V): Promise<void>;
+    delete(keys: string[] | string, withoutSyncMessage?: boolean): Promise<void>;
+    has(key: string): boolean;
+    entries(): IterableIterator<[string, V]>;
+}
+export {};