@trieb.work/nextjs-turbo-redis-cache 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -1,21 +1,51 @@
-import { CacheHandler, IncrementalCache, CacheHandlerValue } from 'next/dist/server/lib/incremental-cache';
-
-type GetParams = Parameters<IncrementalCache['get']>;
-type SetParams = Parameters<IncrementalCache['set']>;
-type RevalidateParams = Parameters<IncrementalCache['revalidateTag']>;
+type CacheEntry = {
+    value: unknown;
+    lastModified: number;
+    tags: string[];
+};
 type CreateRedisStringsHandlerOptions = {
+    /** Redis database number to use. Uses DB 0 for production, DB 1 otherwise
+     * @default process.env.VERCEL_ENV === 'production' ? 0 : 1
+     */
     database?: number;
+    /** Prefix added to all Redis keys
+     * @default process.env.VERCEL_URL || 'UNDEFINED_URL_'
+     */
     keyPrefix?: string;
+    /** Timeout in milliseconds for Redis operations
+     * @default 5000
+     */
     timeoutMs?: number;
+    /** Number of entries to query in one batch during full sync of shared tags hash map
+     * @default 250
+     */
     revalidateTagQuerySize?: number;
+    /** Key used to store shared tags hash map in Redis
+     * @default '__sharedTags__'
+     */
     sharedTagsKey?: string;
+    /** Average interval in milliseconds between tag map full re-syncs
+     * @default 3600000 (1 hour)
+     */
     avgResyncIntervalMs?: number;
+    /** Enable deduplication of Redis get requests via internal in-memory cache
+     * @default true
+     */
     redisGetDeduplication?: boolean;
+    /** Time in milliseconds to cache Redis get results in memory. Set this to 0 to disable in-memory caching completely
+     * @default 10000
+     */
     inMemoryCachingTime?: number;
+    /** Default stale age in seconds for cached items
+     * @default 1209600 (14 days)
+     */
     defaultStaleAge?: number;
+    /** Function to calculate expire age (redis TTL value) from stale age
+     * @default Production: staleAge * 2, Other: staleAge * 1.2
+     */
     estimateExpireAge?: (staleAge: number) => number;
 };
-declare class RedisStringsHandler implements CacheHandler {
+declare class RedisStringsHandler {
     private client;
     private sharedTagsMap;
     private revalidatedTagsMap;
@@ -30,23 +60,65 @@ declare class RedisStringsHandler implements CacheHandler {
     private defaultStaleAge;
     private estimateExpireAge;
     constructor({ database, keyPrefix, sharedTagsKey, timeoutMs, revalidateTagQuerySize, avgResyncIntervalMs, redisGetDeduplication, inMemoryCachingTime, defaultStaleAge, estimateExpireAge, }: CreateRedisStringsHandlerOptions);
-    resetRequestCache(...args: never[]): void;
+    resetRequestCache(): 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>;
+    get(key: string, ctx: {
+        kind: 'APP_ROUTE' | 'APP_PAGE';
+        isRoutePPREnabled: boolean;
+        isFallback: boolean;
+    } | {
+        kind: 'FETCH';
+        revalidate: number;
+        fetchUrl: string;
+        fetchIdx: number;
+        tags: string[];
+        softTags: string[];
+        isFallback: boolean;
+    }): Promise<CacheEntry | null>;
+    set(key: string, data: {
+        kind: 'APP_PAGE';
+        status: number;
+        headers: {
+            'x-nextjs-stale-time': string;
+            'x-next-cache-tags': string;
+        };
+        html: string;
+        rscData: Buffer;
+        segmentData: unknown;
+        postboned: unknown;
+    } | {
+        kind: 'APP_ROUTE';
+        status: number;
+        headers: {
+            'cache-control'?: string;
+            'x-nextjs-stale-time': string;
+            'x-next-cache-tags': string;
+        };
+        body: Buffer;
+    } | {
+        kind: 'FETCH';
+        data: {
+            headers: Record<string, string>;
+            body: string;
+            status: number;
+            url: string;
+        };
+        revalidate: number | false;
+    }, ctx: {
+        revalidate: number | false;
+        isRoutePPREnabled: boolean;
+        isFallback: boolean;
+        tags?: string[];
+    }): Promise<void>;
+    revalidateTag(tagOrTags: string | string[], ...rest: any[]): Promise<void>;
 }
 
-declare class CachedHandler implements CacheHandler {
+declare class CachedHandler {
     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"]>;
+    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']>;
 }
 
-export { CachedHandler as default };
+export { RedisStringsHandler, CachedHandler as default };