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

package/.github/workflows/ci.yml

@@ -7,6 +7,15 @@ on:
   pull_request:
     branches:
       - main
+      
+permissions:
+  contents: write
+  pull-requests: write
+  deployments: write
+  packages: write
+  statuses: write
+  issues: write
+  actions: write
 
 jobs:
   build:

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# [1.1.0](https://github.com/trieb-work/nextjs-turbo-redis-cache/compare/v1.0.0...v1.1.0) (2025-03-28)
+
+
+### Features
+
+* Update README.md ([10b474b](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/10b474b456803be924bf4170b6cda662827202c4))
+
+# 1.0.0 (2025-03-28)
+
+
+### Bug Fixes
+
+* double sync on key expiration ([14afef6](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/14afef6b08e3399a2aa7d6cf42a4b9b7b5ea5d33))
+* lint errors ([2b9b138](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/2b9b138759f5754577205b58a998cc034b3b0db5))
+* rEADME ([9e4fab1](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/9e4fab163002c34e8077285064c24ee05ba92bac))
+
+
+### Features
+
+* add handler code ([72251f5](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/72251f58446ec6fb3819ea0bdd67fc012e8a5c38))
+* add handler code ([f674f26](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/f674f262f292e47fd228a827590e8dc10391e5cb))
+* add handler code ([24c497f](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/24c497f1d67898e64528105c61a90b00f55ba02a))
+* improve readme and remove logs ([79408fb](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/79408fbd488db11fcc7472b690f1fff237816da8))
+* improve readme and remove logs ([de7a6aa](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/de7a6aa735d6295299d3a5d41d0fd00d64ac6f89))
+* rename package and extend readme ([e16bcdc](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/e16bcdc6329ee913e1794f2bce05e1e88a08d91b))
+* update to next 15 types + feat: add delete sync to deduplication cache ([832c28f](https://github.com/trieb-work/nextjs-turbo-redis-cache/commit/832c28f1fe0831b87790c2d60e33b314be0adf58))

package/README.md

@@ -17,7 +17,32 @@ TODO
 
 ## Getting started
 
-TODO add description for how to use it
+```bash
+pnpm install @trieb.work/nextjs-turbo-redis-cache
+```
+
+extend `next.config.js` with:
+```
+const nextConfig = {
+  cacheHandler:
+    process.env.NODE_ENV === "production" || process.env.DEV_REDIS_CACHE
+      ? new CachedHandler({
+        // Default Options:
+        // maxMemoryCacheSize, // deprecated
+        // 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 = 10_000,
+        // defaultStaleAge = 60 * 60 * 24 * 14,
+        // estimateExpireAge = (staleAge) =>
+        //   process.env.VERCEL_ENV === 'preview' ? staleAge * 1.2 : staleAge * 2,
+      })
+      : undefined,
+```
 
 ## Consistency
 
@@ -61,3 +86,8 @@ Since all caching calls in one api/page/server action request is always served b
 ## License
 
 This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+
+## Sponsor
+
+This project is created and maintained by the Next.js & Payload CMS agency [trieb.work](https://trieb.work)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trieb.work/nextjs-turbo-redis-cache",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "scripts": {
     "dev": "pnpm test",
     "build": "tsc",
@@ -13,8 +13,29 @@
   "main": "dist/index.js",
   "type": "module",
   "types": "dist/index.d.ts",
-  "keywords": [],
-  "author": "",
+  "keywords": [
+    "nextjs",
+    "redis",
+    "cache",
+    "nextjs-cache",
+    "redis-cache",
+    "turbo-cache",
+    "production",
+    "performance",
+    "optimized",
+    "fast",
+    "large-scale",
+    "scalable",
+    "caching",
+    "nextjs-redis",
+    "nodejs",
+    "in-memory-cache",
+    "revalidate",
+    "deduplication",
+    "batch-invalidation",
+    "tags-cache"
+  ],
+  "author": "Designed for speed, scalability, and optimized performance, nextjs-turbo-redis-cache is your go-to solution for Next.js caching in demanding production environments.",
   "license": "ISC",
   "description": "",
   "publishConfig": {

package/src/RedisStringsHandler.ts

@@ -24,7 +24,6 @@ export type CreateRedisStringsHandlerOptions = {
   inMemoryCachingTime?: number;
   defaultStaleAge?: number;
   estimateExpireAge?: (staleAge: number) => number;
-  maxMemoryCacheSize?: number;
 };
 
 const NEXT_CACHE_IMPLICIT_TAG_ID = '_N_T_';
@@ -41,7 +40,6 @@ export function getTimeoutRedisCommandOptions(
 }
 
 export default class RedisStringsHandler implements CacheHandler {
-  private maxMemoryCacheSize: undefined | number;
   private client: Client;
   private sharedTagsMap: SyncedMap<string[]>;
   private revalidatedTagsMap: SyncedMap<number>;
@@ -62,7 +60,6 @@ export default class RedisStringsHandler implements CacheHandler {
   private estimateExpireAge: (staleAge: number) => number;
 
   constructor({
-    maxMemoryCacheSize,
     database = process.env.VERCEL_ENV === 'production' ? 0 : 1,
     keyPrefix = process.env.VERCEL_URL || 'UNDEFINED_URL_',
     sharedTagsKey = '__sharedTags__',
@@ -75,7 +72,6 @@ export default class RedisStringsHandler implements CacheHandler {
     estimateExpireAge = (staleAge) =>
       process.env.VERCEL_ENV === 'preview' ? staleAge * 1.2 : staleAge * 2,
   }: CreateRedisStringsHandlerOptions) {
-    this.maxMemoryCacheSize = maxMemoryCacheSize;
     this.keyPrefix = keyPrefix;
     this.timeoutMs = timeoutMs;
     this.redisGetDeduplication = redisGetDeduplication;

package/dist/CachedHandler.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1,28 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-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

@@ -1,48 +0,0 @@
-"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

@@ -1,48 +0,0 @@
-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

@@ -1,215 +0,0 @@
-"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

@@ -1,51 +0,0 @@
-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 {};

package/dist/SyncedMap.js

@@ -1,203 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncedMap = void 0;
-// SyncedMap.ts
-const RedisStringsHandler_1 = require("./RedisStringsHandler");
-const SYNC_CHANNEL_SUFFIX = ':sync-channel:';
-class SyncedMap {
-    constructor(options) {
-        this.client = options.client;
-        this.keyPrefix = options.keyPrefix;
-        this.redisKey = options.redisKey;
-        this.syncChannel = `${options.keyPrefix}${SYNC_CHANNEL_SUFFIX}${options.redisKey}`;
-        this.database = options.database;
-        this.timeoutMs = options.timeoutMs;
-        this.querySize = options.querySize;
-        this.filterKeys = options.filterKeys;
-        this.resyncIntervalMs = options.resyncIntervalMs;
-        this.customizedSync = options.customizedSync;
-        this.map = new Map();
-        this.subscriberClient = this.client.duplicate();
-        this.setupLock = new Promise((resolve) => {
-            this.setupLockResolve = resolve;
-        });
-        this.setup().catch((error) => {
-            console.error('Failed to setup SyncedMap:', error);
-            throw error;
-        });
-    }
-    async setup() {
-        let setupPromises = [];
-        if (!this.customizedSync?.withoutRedisHashmap) {
-            setupPromises.push(this.initialSync());
-            this.setupPeriodicResync();
-        }
-        setupPromises.push(this.setupPubSub());
-        await Promise.all(setupPromises);
-        this.setupLockResolve();
-    }
-    async initialSync() {
-        let cursor = 0;
-        const hScanOptions = { COUNT: this.querySize };
-        try {
-            do {
-                const remoteItems = await this.client.hScan((0, RedisStringsHandler_1.getTimeoutRedisCommandOptions)(this.timeoutMs), this.keyPrefix + this.redisKey, cursor, hScanOptions);
-                for (const { field, value } of remoteItems.tuples) {
-                    if (this.filterKeys(field)) {
-                        const parsedValue = JSON.parse(value);
-                        this.map.set(field, parsedValue);
-                    }
-                }
-                cursor = remoteItems.cursor;
-            } while (cursor !== 0);
-            // Clean up keys not in Redis
-            await this.cleanupKeysNotInRedis();
-        }
-        catch (error) {
-            console.error('Error during initial sync:', error);
-            throw error;
-        }
-    }
-    async cleanupKeysNotInRedis() {
-        let cursor = 0;
-        const scanOptions = { COUNT: this.querySize, MATCH: `${this.keyPrefix}*` };
-        let remoteKeys = [];
-        try {
-            do {
-                const remoteKeysPortion = await this.client.scan((0, RedisStringsHandler_1.getTimeoutRedisCommandOptions)(this.timeoutMs), cursor, scanOptions);
-                remoteKeys = remoteKeys.concat(remoteKeysPortion.keys);
-                cursor = remoteKeysPortion.cursor;
-            } while (cursor !== 0);
-            const remoteKeysSet = new Set(remoteKeys.map((key) => key.substring(this.keyPrefix.length)));
-            const keysToDelete = [];
-            for (const key of this.map.keys()) {
-                const keyStr = key;
-                if (!remoteKeysSet.has(keyStr) && this.filterKeys(keyStr)) {
-                    keysToDelete.push(keyStr);
-                }
-            }
-            if (keysToDelete.length > 0) {
-                await this.delete(keysToDelete);
-            }
-        }
-        catch (error) {
-            console.error('Error during cleanup of keys not in Redis:', error);
-            throw error;
-        }
-    }
-    setupPeriodicResync() {
-        if (this.resyncIntervalMs && this.resyncIntervalMs > 0) {
-            setInterval(() => {
-                this.initialSync().catch((error) => {
-                    console.error('Error during periodic resync:', error);
-                });
-            }, this.resyncIntervalMs);
-        }
-    }
-    async setupPubSub() {
-        const syncHandler = async (message) => {
-            const syncMessage = JSON.parse(message);
-            if (syncMessage.type === 'insert') {
-                if (syncMessage.key !== undefined && syncMessage.value !== undefined) {
-                    this.map.set(syncMessage.key, syncMessage.value);
-                }
-            }
-            else if (syncMessage.type === 'delete') {
-                if (syncMessage.keys) {
-                    for (const key of syncMessage.keys) {
-                        this.map.delete(key);
-                    }
-                }
-            }
-        };
-        const keyEventHandler = async (_channel, message) => {
-            const key = message;
-            if (key.startsWith(this.keyPrefix)) {
-                const keyInMap = key.substring(this.keyPrefix.length);
-                if (this.filterKeys(keyInMap)) {
-                    await this.delete(keyInMap, true);
-                }
-            }
-        };
-        try {
-            await this.subscriberClient.connect();
-            await Promise.all([
-                // We use a custom channel for insert/delete For the following reason:
-                // With custom channel we can delete multiple entries in one message. If we would listen to unlink / del we
-                // could get thousands of messages for one revalidateTag (For example revalidateTag("algolia") would send an enormous amount of network packages)
-                // Also we can send the value in the message for insert
-                this.subscriberClient.subscribe(this.syncChannel, syncHandler),
-                // Subscribe to Redis keyspace notifications for evicted and expired keys
-                this.subscriberClient.subscribe(`__keyevent@${this.database}__:evicted`, keyEventHandler),
-                this.subscriberClient.subscribe(`__keyevent@${this.database}__:expired`, keyEventHandler),
-            ]);
-            // Error handling for reconnection
-            this.subscriberClient.on('error', async (err) => {
-                console.error('Subscriber client error:', err);
-                try {
-                    await this.subscriberClient.quit();
-                    this.subscriberClient = this.client.duplicate();
-                    await this.setupPubSub();
-                }
-                catch (reconnectError) {
-                    console.error('Failed to reconnect subscriber client:', reconnectError);
-                }
-            });
-        }
-        catch (error) {
-            console.error('Error setting up pub/sub client:', error);
-            throw error;
-        }
-    }
-    async waitUntilReady() {
-        await this.setupLock;
-    }
-    get(key) {
-        return this.map.get(key);
-    }
-    async set(key, value) {
-        this.map.set(key, value);
-        const operations = [];
-        // This is needed if we only want to sync delete commands. This is especially useful for non serializable data like a promise map
-        if (this.customizedSync?.withoutSetSync) {
-            return;
-        }
-        if (!this.customizedSync?.withoutRedisHashmap) {
-            const options = (0, RedisStringsHandler_1.getTimeoutRedisCommandOptions)(this.timeoutMs);
-            operations.push(this.client.hSet(options, this.keyPrefix + this.redisKey, key, JSON.stringify(value)));
-        }
-        const insertMessage = {
-            type: 'insert',
-            key: key,
-            value,
-        };
-        operations.push(this.client.publish(this.syncChannel, JSON.stringify(insertMessage)));
-        await Promise.all(operations);
-    }
-    async delete(keys, withoutSyncMessage = false) {
-        const keysArray = Array.isArray(keys) ? keys : [keys];
-        const operations = [];
-        for (const key of keysArray) {
-            this.map.delete(key);
-        }
-        if (!this.customizedSync?.withoutRedisHashmap) {
-            const options = (0, RedisStringsHandler_1.getTimeoutRedisCommandOptions)(this.timeoutMs);
-            operations.push(this.client.hDel(options, this.keyPrefix + this.redisKey, keysArray));
-        }
-        if (!withoutSyncMessage) {
-            const deletionMessage = {
-                type: 'delete',
-                keys: keysArray,
-            };
-            operations.push(this.client.publish(this.syncChannel, JSON.stringify(deletionMessage)));
-        }
-        await Promise.all(operations);
-    }
-    has(key) {
-        return this.map.has(key);
-    }
-    entries() {
-        return this.map.entries();
-    }
-}
-exports.SyncedMap = SyncedMap;

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import CachedHandler from "./CachedHandler";
-export default CachedHandler;

package/dist/index.js

@@ -1,7 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const CachedHandler_1 = __importDefault(require("./CachedHandler"));
-exports.default = CachedHandler_1.default;

package/dist/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/index.test.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-(0, vitest_1.describe)('Example Test', () => {
-    (0, vitest_1.it)('should work correctly', () => {
-        console.log("TODO tests");
-    });
-});