@leejpsd/nextjs-cache-handler 0.2.0 → 0.3.0

package/dist/incremental/index.js

@@ -1,11 +1,11 @@
+import path2 from 'path';
+import 'url';
+import { createRequire } from 'module';
+import { promisify } from 'util';
+import { gzip, gunzip, brotliCompress, brotliDecompress, constants } from 'zlib';
+
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -13,6 +13,27 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+  }
+});
+function nodeRequire(id) {
+  try {
+    return packageRequire(id);
+  } catch {
+    return cwdRequire(id);
+  }
+}
+var packageRequire, cwdRequire;
+var init_node_require = __esm({
+  "src/shared/node-require.ts"() {
+    init_esm_shims();
+    packageRequire = createRequire(import.meta.url);
+    cwdRequire = createRequire(
+      path2.join(process.cwd(), "__resolve-anchor__.js")
+    );
+  }
+});
 
 // src/shared/client/adapter-redis.ts
 var adapter_redis_exports = {};
@@ -24,7 +45,7 @@ function adaptRedisV5(client) {
   return client;
 }
 function createRedisV5Client(config) {
-  const { createClient } = __require("redis");
+  const { createClient } = nodeRequire("redis");
   const useTls = config.tls ?? config.url.startsWith("rediss://");
   const opts = {
     url: config.url,
@@ -39,6 +60,8 @@ function createRedisV5Client(config) {
 }
 var init_adapter_redis = __esm({
   "src/shared/client/adapter-redis.ts"() {
+    init_esm_shims();
+    init_node_require();
   }
 });
 
@@ -48,7 +71,8 @@ __export(adapter_ioredis_exports, {
   adaptCluster: () => adaptCluster,
   adaptIoredis: () => adaptIoredis,
   createIoredisClient: () => createIoredisClient,
-  createIoredisCluster: () => createIoredisCluster
+  createIoredisCluster: () => createIoredisCluster,
+  createIoredisSentinel: () => createIoredisSentinel
 });
 function adapt(client, isClusterClient = false) {
   return {
@@ -131,6 +155,9 @@ function adapt(client, isClusterClient = false) {
     on: (event, listener) => {
       client.on(event, listener);
       return client;
+    },
+    dispose: () => {
+      client.disconnect();
     }
   };
 }
@@ -141,18 +168,36 @@ function adaptCluster(cluster) {
   return adapt(cluster, true);
 }
 function createIoredisClient(config) {
-  const IORedis = __require("ioredis");
+  const IORedis = nodeRequire("ioredis");
   const Ctor = IORedis.default ?? IORedis;
   return new Ctor(config.url, {
     password: config.password,
     connectTimeout: config.connectTimeout ?? 1500,
     tls: config.tls ? {} : void 0,
     lazyConnect: true,
-    maxRetriesPerRequest: 1
+    maxRetriesPerRequest: 1,
+    // Batch same-tick commands into one RTT (matches redis@5's default
+    // behavior) — makes Promise.all fan-outs a single pipeline.
+    enableAutoPipelining: true
+  });
+}
+function createIoredisSentinel(config) {
+  const IORedis = nodeRequire("ioredis");
+  const Ctor = IORedis.default ?? IORedis;
+  return new Ctor({
+    sentinels: config.sentinels,
+    name: config.name,
+    password: config.password,
+    sentinelPassword: config.sentinelPassword,
+    connectTimeout: config.connectTimeout ?? 1500,
+    tls: config.tls ? {} : void 0,
+    lazyConnect: true,
+    maxRetriesPerRequest: 1,
+    enableAutoPipelining: true
   });
 }
 function createIoredisCluster(config) {
-  const IORedis = __require("ioredis");
+  const IORedis = nodeRequire("ioredis");
   const ClusterCtor = IORedis.Cluster ?? IORedis.default.Cluster;
   return new ClusterCtor(config.nodes, {
     redisOptions: {
@@ -160,15 +205,26 @@ function createIoredisCluster(config) {
       tls: config.tls ? {} : void 0
     },
     enableReadyCheck: true,
-    lazyConnect: true
+    lazyConnect: true,
+    // Same-slot commands issued in the same tick share one pipeline.
+    enableAutoPipelining: true
   });
 }
 var init_adapter_ioredis = __esm({
   "src/shared/client/adapter-ioredis.ts"() {
+    init_esm_shims();
+    init_node_require();
   }
 });
 
+// src/incremental/index.ts
+init_esm_shims();
+
+// src/incremental/handler.ts
+init_esm_shims();
+
 // src/shared/abort.ts
+init_esm_shims();
 var CacheTimeoutError = class extends Error {
   constructor(opName, ms) {
     super(`[@leejpsd/nextjs-cache-handler] ${opName} timed out after ${ms}ms`);
@@ -200,7 +256,41 @@ async function withAbortSignal(opName, ms, fn) {
   }
 }
 
+// src/shared/compress.ts
+init_esm_shims();
+var gzipAsync = promisify(gzip);
+var gunzipAsync = promisify(gunzip);
+var brotliCompressAsync = promisify(brotliCompress);
+var brotliDecompressAsync = promisify(brotliDecompress);
+var GZIP_MARKER = "__ncgz__:";
+var BROTLI_MARKER = "__ncbr__:";
+var MIN_COMPRESS_BYTES = 1024;
+var BROTLI_OPTS = {
+  params: { [constants.BROTLI_PARAM_QUALITY]: 5 }
+};
+async function compressValue(value, algo) {
+  if (!algo || Buffer.byteLength(value) < MIN_COMPRESS_BYTES) return value;
+  const input = Buffer.from(value);
+  if (algo === "gzip") {
+    return GZIP_MARKER + (await gzipAsync(input)).toString("base64");
+  }
+  return BROTLI_MARKER + (await brotliCompressAsync(input, BROTLI_OPTS)).toString("base64");
+}
+async function decompressValue(value) {
+  if (value === null) return null;
+  if (value.startsWith(GZIP_MARKER)) {
+    const buf = Buffer.from(value.slice(GZIP_MARKER.length), "base64");
+    return (await gunzipAsync(buf)).toString("utf8");
+  }
+  if (value.startsWith(BROTLI_MARKER)) {
+    const buf = Buffer.from(value.slice(BROTLI_MARKER.length), "base64");
+    return (await brotliDecompressAsync(buf)).toString("utf8");
+  }
+  return value;
+}
+
 // src/shared/client/index.ts
+init_esm_shims();
 async function buildClient(source) {
   if (typeof source === "function") {
     return await source();
@@ -218,6 +308,10 @@ async function buildClient(source) {
       const { adaptCluster: adaptCluster2, createIoredisCluster: createIoredisCluster2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
       return adaptCluster2(createIoredisCluster2(source));
     }
+    case "sentinel": {
+      const { adaptIoredis: adaptIoredis2, createIoredisSentinel: createIoredisSentinel2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
+      return adaptIoredis2(createIoredisSentinel2(source));
+    }
     default: {
       const exhaustive = source;
       throw new Error(
@@ -227,28 +321,45 @@ async function buildClient(source) {
   }
 }
 var ConnectionManager = class {
-  constructor(source, onError) {
+  constructor(source, onError, retry = {}) {
     this.source = source;
     this.onError = onError;
+    this.baseCooldownMs = retry.baseCooldownMs ?? 1e3;
+    this.maxCooldownMs = retry.maxCooldownMs ?? 3e4;
   }
   source;
   onError;
   client = null;
   connecting = null;
-  failed = false;
+  consecutiveFailures = 0;
+  lastFailureAt = 0;
+  baseCooldownMs;
+  maxCooldownMs;
+  cooldownMs() {
+    if (this.consecutiveFailures === 0) return 0;
+    return Math.min(
+      this.maxCooldownMs,
+      this.baseCooldownMs * 2 ** (this.consecutiveFailures - 1)
+    );
+  }
   async getOrConnect() {
     if (this.client?.isOpen) return this.client;
-    if (this.failed) return null;
     if (this.connecting) return this.connecting;
+    if (Date.now() - this.lastFailureAt < this.cooldownMs()) return null;
+    const stale = this.client;
+    this.client = null;
     this.connecting = (async () => {
+      disposeQuietly(stale);
       try {
         const c = await buildClient(this.source);
         c.on("error", (err) => this.onError(err));
         if (!c.isOpen) await c.connect();
         this.client = c;
+        this.consecutiveFailures = 0;
         return c;
       } catch (err) {
-        this.failed = true;
+        this.consecutiveFailures += 1;
+        this.lastFailureAt = Date.now();
         this.onError(err);
         return null;
       } finally {
@@ -258,13 +369,24 @@ var ConnectionManager = class {
     return this.connecting;
   }
   reset() {
+    disposeQuietly(this.client);
     this.client = null;
     this.connecting = null;
-    this.failed = false;
+    this.consecutiveFailures = 0;
+    this.lastFailureAt = 0;
   }
 };
+function disposeQuietly(client) {
+  if (!client) return;
+  const c = client;
+  try {
+    (c.dispose ?? c.destroy ?? c.disconnect)?.call(c);
+  } catch {
+  }
+}
 
 // src/shared/logger.ts
+init_esm_shims();
 var defaultLogger = {
   debug: () => {
   },
@@ -281,13 +403,19 @@ var defaultLogger = {
 };
 
 // src/shared/memory-fallback.ts
+init_esm_shims();
 var MAX_TIMER_MS = 2147483647;
 function clampTimerMs(ms) {
   return Math.min(Math.max(0, ms), MAX_TIMER_MS);
 }
+var DEFAULT_MAX_ENTRIES = 1e3;
 var MemoryStore = class {
   kv = /* @__PURE__ */ new Map();
   timers = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+    this.maxEntries = Math.max(1, maxEntries);
+  }
   set(key, value, ttlSeconds) {
     this.delete(key);
     const expiresAt = Date.now() + ttlSeconds * 1e3;
@@ -297,6 +425,10 @@ var MemoryStore = class {
       timer.unref();
     }
     this.timers.set(key, timer);
+    while (this.kv.size > this.maxEntries) {
+      const oldest = this.kv.keys().next().value;
+      this.delete(oldest);
+    }
   }
   get(key) {
     const entry = this.kv.get(key);
@@ -305,6 +437,8 @@ var MemoryStore = class {
       this.delete(key);
       return null;
     }
+    this.kv.delete(key);
+    this.kv.set(key, entry);
     return entry.value;
   }
   delete(key) {
@@ -337,6 +471,7 @@ var MemoryStore = class {
 };
 
 // src/shared/metrics.ts
+init_esm_shims();
 var counters = /* @__PURE__ */ new Map();
 function bump(event) {
   const existing = counters.get(event.type);
@@ -365,6 +500,7 @@ function createEmitter(onMetric) {
 }
 
 // src/shared/namespace.ts
+init_esm_shims();
 var FALLBACK = "unversioned";
 function resolveBuildNamespace(override) {
   if (override !== void 0) {
@@ -378,6 +514,7 @@ function buildKey(prefix, namespace, rest, hashTag = false) {
 }
 
 // src/shared/build-phase.ts
+init_esm_shims();
 var PHASE_PRODUCTION_BUILD = "phase-production-build";
 function isBuildPhase() {
   return process.env.NEXT_PHASE === PHASE_PRODUCTION_BUILD;
@@ -390,6 +527,7 @@ function shouldUseRedis(opts) {
 }
 
 // src/incremental/serialize.ts
+init_esm_shims();
 function isEnvelope(value) {
   return typeof value === "object" && value !== null && "__type" in value && typeof value.__type === "string";
 }
@@ -471,7 +609,7 @@ function init(opts) {
     logger,
     emit,
     conn,
-    memEntries: new MemoryStore(),
+    memEntries: new MemoryStore(opts.memoryMaxEntries),
     memTagStates: /* @__PURE__ */ new Map(),
     resolveNs: () => resolveBuildNamespace(opts.buildNamespace)
   };
@@ -530,7 +668,7 @@ function normalizeTtlSeconds(data, ctx) {
       return ONE_YEAR_SEC;
     }
   }
-  const revalidate = ctx?.cacheControl?.revalidate;
+  const revalidate = ctx?.cacheControl?.revalidate ?? ctx?.revalidate;
   if (revalidate === false || revalidate === void 0) return ONE_YEAR_SEC;
   if (typeof revalidate === "number" && revalidate > 0) {
     return Math.min(Math.max(Math.ceil(revalidate), MIN_TTL_SEC), ONE_YEAR_SEC);
@@ -568,10 +706,49 @@ async function readTagStates(state, tags) {
 var IncrementalRedisCacheHandler = class {
   state;
   revalidatedTags;
+  /**
+   * Request-scoped memo of Redis entry reads. Next.js instantiates this class
+   * per request (and calls resetRequestCache() at request boundaries when it
+   * reuses an instance), so entries live at most one request. Bounded by the
+   * number of distinct cache keys a single request touches.
+   */
+  requestMemo = /* @__PURE__ */ new Map();
   constructor(state, ctx) {
     this.state = state;
     this.revalidatedTags = normalizeTags(ctx?.revalidatedTags);
   }
+  /**
+   * Redis entry read, deduplicated per request: parallel RSC renders or
+   * repeated fetch() calls hitting the same cache key share one GET. The
+   * memoized promise never rejects — errors are converted to a miss (with
+   * the same timeout metric the inline path emitted before).
+   */
+  readEntryDeduped(eKey) {
+    const memoized = this.requestMemo.get(eKey);
+    if (memoized) {
+      this.state.emit({ type: "cache.get.deduped" });
+      return memoized;
+    }
+    const read = withAbortSignal(
+      "incremental.get",
+      this.state.opts.abortTimeoutMs,
+      async () => {
+        const client = await this.state.conn.getOrConnect();
+        if (!client) return null;
+        return await decompressValue(await client.get(eKey));
+      }
+    ).catch((err) => {
+      if (err instanceof CacheTimeoutError) {
+        this.state.emit({
+          type: "redis.timeout",
+          meta: { op: "incremental.get" }
+        });
+      }
+      return null;
+    });
+    this.requestMemo.set(eKey, read);
+    return read;
+  }
   async get(cacheKey, ctx) {
     try {
       const requestedTags = normalizeTags([
@@ -583,24 +760,11 @@ var IncrementalRedisCacheHandler = class {
       const useRedis = !useLocal && gateRedis(this.state);
       let raw = null;
       if (useRedis) {
-        try {
-          raw = await withAbortSignal(
-            "incremental.get",
-            this.state.opts.abortTimeoutMs,
-            async () => {
-              const client = await this.state.conn.getOrConnect();
-              if (!client) return null;
-              return await client.get(eKey);
-            }
-          );
-        } catch (err) {
-          if (err instanceof CacheTimeoutError) {
-            this.state.emit({ type: "redis.timeout", meta: { op: "incremental.get" } });
-          }
-          raw = null;
-        }
+        raw = await this.readEntryDeduped(eKey);
+      }
+      if (raw === null && (useLocal || this.state.opts.fallback !== "never")) {
+        raw = this.state.memEntries.get(eKey);
       }
-      if (raw === null) raw = this.state.memEntries.get(eKey);
       if (raw === null) {
         this.state.emit({ type: "cache.miss" });
         return null;
@@ -613,7 +777,7 @@ var IncrementalRedisCacheHandler = class {
         return null;
       }
       const tagStates = await readTagStates(this.state, tags);
-      const isFetch = ctx?.kind === "FETCH";
+      const isFetch = ctx?.kind === "FETCH" || ctx?.kindHint?.toLowerCase() === "fetch" || typeof parsed.value === "object" && parsed.value !== null && parsed.value.kind === "FETCH";
       if (tagStates.some((s) => isTagStateExpired(s, parsed.lastModified, isFetch))) {
         this.state.emit({ type: "cache.miss", meta: { reason: "tag-state-expired" } });
         return null;
@@ -636,6 +800,7 @@ var IncrementalRedisCacheHandler = class {
       const record = { lastModified: Date.now(), value: data };
       const serialized = serializeCacheRecord(record);
       const eKey = entryKey(this.state, cacheKey);
+      this.requestMemo.delete(eKey);
       const useRedis = !useLocal && gateRedis(this.state);
       if (useRedis) {
         try {
@@ -645,10 +810,19 @@ var IncrementalRedisCacheHandler = class {
             async () => {
               const client = await this.state.conn.getOrConnect();
               if (!client) {
-                this.state.memEntries.set(eKey, serialized, ttl);
+                if (this.state.opts.fallback !== "never") {
+                  this.state.memEntries.set(eKey, serialized, ttl);
+                }
                 return;
               }
-              await client.set(eKey, serialized, { EX: ttl });
+              await client.set(
+                eKey,
+                await compressValue(
+                  serialized,
+                  this.state.opts.rest.compression
+                ),
+                { EX: ttl }
+              );
             }
           );
           this.state.emit({ type: "cache.set", meta: { backend: "redis" } });
@@ -659,8 +833,15 @@ var IncrementalRedisCacheHandler = class {
           }
         }
       }
-      this.state.memEntries.set(eKey, serialized, ttl);
-      this.state.emit({ type: "cache.set", meta: { backend: "memory" } });
+      if (useLocal || this.state.opts.fallback !== "never") {
+        this.state.memEntries.set(eKey, serialized, ttl);
+        this.state.emit({ type: "cache.set", meta: { backend: "memory" } });
+      } else {
+        this.state.emit({
+          type: "cache.set.failed",
+          meta: { reason: "no-fallback" }
+        });
+      }
     } catch (err) {
       this.state.logger.error("set() error", {
         message: err.message
@@ -714,6 +895,7 @@ var IncrementalRedisCacheHandler = class {
     }
   }
   resetRequestCache() {
+    this.requestMemo.clear();
   }
 };
 function createIncrementalCacheHandler(opts) {