@leejpsd/nextjs-cache-handler 0.1.1 → 0.3.0

package/dist/cache-components/index.cjs

@@ -1,15 +1,17 @@
 'use strict';
 
+var module$1 = require('module');
+var path = require('path');
+var util = require('util');
+var zlib = require('zlib');
 var crypto = require('crypto');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+
 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;
 };
@@ -18,6 +20,32 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+  }
+});
+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_cjs_shims();
+    packageRequire = module$1.createRequire(importMetaUrl);
+    cwdRequire = module$1.createRequire(
+      path__default.default.join(process.cwd(), "__resolve-anchor__.js")
+    );
+  }
+});
+
 // src/shared/client/adapter-redis.ts
 var adapter_redis_exports = {};
 __export(adapter_redis_exports, {
@@ -28,7 +56,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,
@@ -43,6 +71,8 @@ function createRedisV5Client(config) {
 }
 var init_adapter_redis = __esm({
   "src/shared/client/adapter-redis.ts"() {
+    init_cjs_shims();
+    init_node_require();
   }
 });
 
@@ -52,7 +82,8 @@ __export(adapter_ioredis_exports, {
   adaptCluster: () => adaptCluster,
   adaptIoredis: () => adaptIoredis,
   createIoredisClient: () => createIoredisClient,
-  createIoredisCluster: () => createIoredisCluster
+  createIoredisCluster: () => createIoredisCluster,
+  createIoredisSentinel: () => createIoredisSentinel
 });
 function adapt(client, isClusterClient = false) {
   return {
@@ -135,6 +166,9 @@ function adapt(client, isClusterClient = false) {
     on: (event, listener) => {
       client.on(event, listener);
       return client;
+    },
+    dispose: () => {
+      client.disconnect();
     }
   };
 }
@@ -145,18 +179,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: {
@@ -164,15 +216,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_cjs_shims();
+    init_node_require();
   }
 });
 
+// src/cache-components/index.ts
+init_cjs_shims();
+
+// src/cache-components/handler.ts
+init_cjs_shims();
+
 // src/shared/abort.ts
+init_cjs_shims();
 var CacheTimeoutError = class extends Error {
   constructor(opName, ms) {
     super(`[@leejpsd/nextjs-cache-handler] ${opName} timed out after ${ms}ms`);
@@ -204,7 +267,41 @@ async function withAbortSignal(opName, ms, fn) {
   }
 }
 
+// src/shared/compress.ts
+init_cjs_shims();
+var gzipAsync = util.promisify(zlib.gzip);
+var gunzipAsync = util.promisify(zlib.gunzip);
+var brotliCompressAsync = util.promisify(zlib.brotliCompress);
+var brotliDecompressAsync = util.promisify(zlib.brotliDecompress);
+var GZIP_MARKER = "__ncgz__:";
+var BROTLI_MARKER = "__ncbr__:";
+var MIN_COMPRESS_BYTES = 1024;
+var BROTLI_OPTS = {
+  params: { [zlib.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_cjs_shims();
 async function buildClient(source) {
   if (typeof source === "function") {
     return await source();
@@ -222,6 +319,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(
@@ -231,28 +332,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 {
@@ -262,13 +380,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_cjs_shims();
 var defaultLogger = {
   debug: () => {
   },
@@ -284,6 +413,9 @@ var defaultLogger = {
   }
 };
 
+// src/shared/lua/index.ts
+init_cjs_shims();
+
 // src/shared/lua/set-with-tags.lua
 var set_with_tags_default = `-- set-with-tags.lua
 --
@@ -387,13 +519,19 @@ async function execLuaScript(client, name, keys, args) {
 }
 
 // src/shared/memory-fallback.ts
+init_cjs_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;
@@ -403,6 +541,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);
@@ -411,6 +553,8 @@ var MemoryStore = class {
       this.delete(key);
       return null;
     }
+    this.kv.delete(key);
+    this.kv.set(key, entry);
     return entry.value;
   }
   delete(key) {
@@ -445,13 +589,19 @@ var MemorySetStore = class {
   sets = /* @__PURE__ */ new Map();
   expiresAt = /* @__PURE__ */ new Map();
   timers = /* @__PURE__ */ new Map();
+  maxSets;
+  constructor(maxSets = DEFAULT_MAX_ENTRIES) {
+    this.maxSets = Math.max(1, maxSets);
+  }
   sAdd(key, member) {
     const members = Array.isArray(member) ? member : [member];
     let set = this.sets.get(key);
     if (!set) {
       set = /* @__PURE__ */ new Set();
-      this.sets.set(key, set);
+    } else {
+      this.sets.delete(key);
     }
+    this.sets.set(key, set);
     let added = 0;
     for (const m of members) {
       if (!set.has(m)) {
@@ -459,6 +609,10 @@ var MemorySetStore = class {
         added += 1;
       }
     }
+    while (this.sets.size > this.maxSets) {
+      const oldest = this.sets.keys().next().value;
+      this.delete(oldest);
+    }
     return added;
   }
   sMembers(key) {
@@ -511,6 +665,7 @@ var MemorySetStore = class {
 };
 
 // src/shared/metrics.ts
+init_cjs_shims();
 var counters = /* @__PURE__ */ new Map();
 function bump(event) {
   const existing = counters.get(event.type);
@@ -539,6 +694,7 @@ function createEmitter(onMetric) {
 }
 
 // src/shared/namespace.ts
+init_cjs_shims();
 var FALLBACK = "unversioned";
 function resolveBuildNamespace(override) {
   if (override !== void 0) {
@@ -552,6 +708,7 @@ function buildKey(prefix, namespace, rest, hashTag = false) {
 }
 
 // src/shared/build-phase.ts
+init_cjs_shims();
 var PHASE_PRODUCTION_BUILD = "phase-production-build";
 function isBuildPhase() {
   return process.env.NEXT_PHASE === PHASE_PRODUCTION_BUILD;
@@ -564,6 +721,7 @@ function shouldUseRedis(opts) {
 }
 
 // src/cache-components/serialize.ts
+init_cjs_shims();
 async function readStreamFully(stream) {
   const reader = stream.getReader();
   const chunks = [];
@@ -606,6 +764,7 @@ function decodeEnvelope(raw) {
 }
 
 // src/cache-components/swr.ts
+init_cjs_shims();
 var SECOND_MS = 1e3;
 function partitionEntry(entry, now = Date.now()) {
   const ageMs = now - entry.timestamp;
@@ -632,7 +791,9 @@ var DEFAULT_KEY_PREFIX = "next-cache:";
 var ENTRY_SUFFIX = "entry:";
 var TAG_SUFFIX = "tag:";
 var TAG_EXP_SUFFIX = "tag-expiration:";
+var LOCK_SUFFIX = "lock:";
 var DEFAULT_ABORT_MS = 1500;
+var DEFAULT_LOCK_TTL_SEC = 10;
 var ONE_YEAR_SEC = 60 * 60 * 24 * 365;
 var FALLBACK_TTL_SEC = 3600;
 var TAG_EXP_MARKER_TTL_SEC = 60 * 60 * 24 * 7;
@@ -655,16 +816,19 @@ function init(opts) {
       staleWhileRevalidate: opts.staleWhileRevalidate ?? true,
       hashTag: opts.hashTag ?? false,
       keyPrefix: opts.keyPrefix ?? DEFAULT_KEY_PREFIX,
+      singleFlight: opts.singleFlight ?? false,
+      singleFlightLockTtlSec: opts.singleFlightLockTtlSec ?? DEFAULT_LOCK_TTL_SEC,
       rest: opts
     },
     logger,
     emit,
     conn,
-    memEntries: new MemoryStore(),
-    memTags: new MemorySetStore(),
+    memEntries: new MemoryStore(opts.memoryMaxEntries),
+    memTags: new MemorySetStore(opts.memoryMaxEntries),
     memTagExp: /* @__PURE__ */ new Map(),
     localTagTimestamps: /* @__PURE__ */ new Map(),
-    resolveNs: () => resolveBuildNamespace(opts.buildNamespace)
+    resolveNs: () => resolveBuildNamespace(opts.buildNamespace),
+    instanceId: process.env.HOSTNAME || process.env.ECS_TASK_ID || `pid-${process.pid}`
   };
 }
 function entryKey(state, cacheKey) {
@@ -691,6 +855,40 @@ function tagExpKey(state, tag) {
     state.opts.hashTag
   );
 }
+function lockKey(state, cacheKey) {
+  return buildKey(
+    `${state.opts.keyPrefix}${LOCK_SUFFIX}`,
+    state.resolveNs(),
+    cacheKey,
+    state.opts.hashTag
+  );
+}
+async function tryAcquireRefreshLock(state, cacheKey) {
+  if (!state.opts.singleFlight) return false;
+  if (!gateRedis(state)) return false;
+  try {
+    return await withAbortSignal(
+      "cacheHandlers.singleFlight.lock",
+      state.opts.abortTimeoutMs,
+      async () => {
+        const client = await state.conn.getOrConnect();
+        if (!client) return false;
+        const result = await execLuaScript(
+          client,
+          "refreshTagLock",
+          [lockKey(state, cacheKey)],
+          [
+            state.instanceId,
+            String(state.opts.singleFlightLockTtlSec)
+          ]
+        );
+        return result === 1;
+      }
+    );
+  } catch {
+    return false;
+  }
+}
 function resolveTtlSeconds(entry) {
   if (Number.isFinite(entry.expire) && entry.expire > 0) {
     return Math.max(60, Math.ceil(entry.expire));
@@ -743,6 +941,12 @@ async function getImpl(state, cacheKey, softTags) {
     state.emit({ type: "cache.miss", ms: Date.now() - start });
     return void 0;
   }
+  try {
+    raw = await decompressValue(raw);
+  } catch {
+    state.emit({ type: "cache.miss", meta: { reason: "decode-error" } });
+    return void 0;
+  }
   envelope = decodeEnvelope(raw);
   if (!envelope) {
     state.emit({ type: "cache.miss", meta: { reason: "decode-error" } });
@@ -785,11 +989,28 @@ async function getImpl(state, cacheKey, softTags) {
       return void 0;
     }
   }
-  state.emit({
-    type: partition.freshness === "stale" ? "cache.stale" : "cache.hit",
-    ms: Date.now() - start,
-    meta: { freshness: partition.freshness }
-  });
+  if (partition.freshness === "stale") {
+    if (state.opts.singleFlight) {
+      const isLeader = await tryAcquireRefreshLock(state, cacheKey);
+      state.emit({
+        type: isLeader ? "cache.stale.refresh.leader" : "cache.stale.refresh.follower",
+        ms: Date.now() - start,
+        meta: { freshness: partition.freshness }
+      });
+    } else {
+      state.emit({
+        type: "cache.stale",
+        ms: Date.now() - start,
+        meta: { freshness: partition.freshness }
+      });
+    }
+  } else {
+    state.emit({
+      type: "cache.hit",
+      ms: Date.now() - start,
+      meta: { freshness: partition.freshness }
+    });
+  }
   return {
     value: bufferToStream(Buffer.from(envelope.value, "base64")),
     tags: envelope.tags,
@@ -854,10 +1075,14 @@ async function setImpl(state, cacheKey, pendingEntry) {
           }
           return;
         }
+        const wirePayload = await compressValue(
+          payload,
+          state.opts.rest.compression
+        );
         if (entry.tags.length === 0) {
-          await client.set(eKey, payload, { EX: ttl });
+          await client.set(eKey, wirePayload, { EX: ttl });
         } else {
-          await luaSetWithTags(client, state, eKey, payload, ttl, entry.tags);
+          await luaSetWithTags(client, state, eKey, wirePayload, ttl, entry.tags);
         }
       }
     );
@@ -893,28 +1118,36 @@ async function refreshTagsImpl(state) {
       async () => {
         const client = await state.conn.getOrConnect();
         if (!client) return;
-        const pattern = `${state.opts.keyPrefix}${TAG_EXP_SUFFIX}*`;
-        const seen = [];
+        const ns = state.opts.hashTag ? `{${state.resolveNs()}}` : state.resolveNs();
+        const pattern = `${escapeMatch(
+          `${state.opts.keyPrefix}${TAG_EXP_SUFFIX}${ns}:`
+        )}*`;
+        const scanStartMs = Date.now();
+        const fresh = /* @__PURE__ */ new Map();
         for await (const chunk of client.scanIterator({
           MATCH: pattern,
           COUNT: 100
         })) {
           const keys = Array.isArray(chunk) ? chunk.map(String) : [String(chunk)];
-          seen.push(...keys);
-          if (seen.length >= 500) break;
+          if (keys.length === 0) continue;
+          const values = await client.mGet(keys);
+          for (let i = 0; i < keys.length; i += 1) {
+            const v = values[i];
+            if (!v) continue;
+            const ts = Number.parseInt(v, 10);
+            if (!Number.isFinite(ts)) continue;
+            const key = keys[i];
+            if (key === void 0) continue;
+            const tag = stripExpPrefix(state, key);
+            if (tag) fresh.set(tag, ts);
+          }
         }
-        if (seen.length === 0) return;
-        const values = await client.mGet(seen);
-        for (let i = 0; i < seen.length; i += 1) {
-          const v = values[i];
-          if (!v) continue;
-          const ts = Number.parseInt(v, 10);
-          if (!Number.isFinite(ts)) continue;
-          const key = seen[i];
-          if (key === void 0) continue;
-          const tag = stripExpPrefix(state, key);
-          if (tag) state.localTagTimestamps.set(tag, ts);
+        for (const [tag, ts] of state.localTagTimestamps) {
+          if (ts >= scanStartMs && (fresh.get(tag) ?? 0) < ts) {
+            fresh.set(tag, ts);
+          }
         }
+        state.localTagTimestamps = fresh;
       }
     );
   } catch (err) {
@@ -923,6 +1156,19 @@ async function refreshTagsImpl(state) {
     });
   }
 }
+function escapeMatch(s) {
+  return s.replace(/[\\*?[\]]/g, "\\$&");
+}
+var MAX_LOCAL_TAG_ENTRIES = 1e4;
+function pruneOldestByTimestamp(map, maxEntries) {
+  if (map.size <= maxEntries) return;
+  const byAge = [...map.entries()].sort((a, b) => a[1] - b[1]);
+  const drop = map.size - maxEntries;
+  for (let i = 0; i < drop; i += 1) {
+    const entry = byAge[i];
+    if (entry) map.delete(entry[0]);
+  }
+}
 function stripExpPrefix(state, fullKey) {
   const ns = state.resolveNs();
   const prefix = state.opts.hashTag ? `${state.opts.keyPrefix}${TAG_EXP_SUFFIX}{${ns}}:` : `${state.opts.keyPrefix}${TAG_EXP_SUFFIX}${ns}:`;
@@ -974,6 +1220,7 @@ async function updateTagsImpl(state, tags, durations) {
     state.localTagTimestamps.set(t, now);
     state.memTagExp.set(t, now);
   }
+  pruneOldestByTimestamp(state.memTagExp, MAX_LOCAL_TAG_ENTRIES);
   if (!gateRedis(state)) {
     if (isHardExpire) {
       for (const t of tags) {
@@ -1003,20 +1250,18 @@ async function updateTagsImpl(state, tags, durations) {
           }
           return;
         }
-        for (const t of tags) {
-          if (isHardExpire) {
-            await execLuaScript(
+        await Promise.all(
+          tags.map(
+            (t) => isHardExpire ? execLuaScript(
               client,
               "revalidateHard",
               [tagKey(state, t), tagExpKey(state, t)],
               [String(now), String(TAG_EXP_MARKER_TTL_SEC)]
-            );
-          } else {
-            await client.set(tagExpKey(state, t), String(now), {
+            ) : client.set(tagExpKey(state, t), String(now), {
               EX: TAG_EXP_MARKER_TTL_SEC
-            });
-          }
-        }
+            })
+          )
+        );
       }
     );
     state.emit({