@leejpsd/nextjs-cache-handler 0.3.4 → 0.4.1

package/dist/ops/index.d.cts

@@ -1,4 +1,4 @@
-import { d as MetricEventType } from '../types-Bl-rkLKX.cjs';
+import { e as MetricEventType } from '../types-C1vJ_sED.cjs';
 
 /**
  * Process-local metric counters with an optional emit hook.

package/dist/ops/index.d.ts

@@ -1,4 +1,4 @@
-import { d as MetricEventType } from '../types-Bl-rkLKX.js';
+import { e as MetricEventType } from '../types-C1vJ_sED.js';
 
 /**
  * Process-local metric counters with an optional emit hook.

package/dist/otel/index.d.cts

@@ -1,4 +1,4 @@
-import { M as MetricEmitter } from '../types-Bl-rkLKX.cjs';
+import { M as MetricEmitter } from '../types-C1vJ_sED.cjs';
 
 /**
  * Built-in OpenTelemetry metric emitter.

package/dist/otel/index.d.ts

@@ -1,4 +1,4 @@
-import { M as MetricEmitter } from '../types-Bl-rkLKX.js';
+import { M as MetricEmitter } from '../types-C1vJ_sED.js';
 
 /**
  * Built-in OpenTelemetry metric emitter.

package/dist/seed/index.cjs

@@ -0,0 +1,561 @@
+'use strict';
+
+var module$1 = require('module');
+var path2 = require('path');
+var fs = require('fs');
+var util = require('util');
+var zlib = require('zlib');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in 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(
+      path2__default.default.join(process.cwd(), "__resolve-anchor__.js")
+    );
+  }
+});
+
+// src/shared/client/adapter-redis.ts
+var adapter_redis_exports = {};
+__export(adapter_redis_exports, {
+  adaptRedisV5: () => adaptRedisV5,
+  createRedisV5Client: () => createRedisV5Client
+});
+function adaptRedisV5(client) {
+  const like = client;
+  like.dispose = () => {
+    try {
+      client.destroy();
+    } catch {
+    }
+  };
+  like.subscribe = async (channel, onMessage, onDown) => {
+    const sub = client.duplicate();
+    const teardown = () => {
+      try {
+        sub.destroy();
+      } catch {
+      }
+    };
+    let down = false;
+    const markDown = () => {
+      if (down) return;
+      down = true;
+      teardown();
+      onDown?.();
+    };
+    sub.on("error", markDown);
+    sub.on("end", markDown);
+    try {
+      await sub.connect();
+      await sub.subscribe(channel, (message) => onMessage(message));
+    } catch (err) {
+      teardown();
+      throw err;
+    }
+    return async () => teardown();
+  };
+  return like;
+}
+function createRedisV5Client(config) {
+  const { createClient } = nodeRequire("redis");
+  const useTls = config.tls ?? config.url.startsWith("rediss://");
+  const opts = {
+    url: config.url,
+    socket: {
+      connectTimeout: config.connectTimeout ?? 1500,
+      reconnectStrategy: false,
+      ...useTls ? { tls: true } : {}
+    }
+  };
+  if (config.password !== void 0) opts.password = config.password;
+  return createClient(opts);
+}
+var init_adapter_redis = __esm({
+  "src/shared/client/adapter-redis.ts"() {
+    init_cjs_shims();
+    init_node_require();
+  }
+});
+
+// src/shared/client/adapter-ioredis.ts
+var adapter_ioredis_exports = {};
+__export(adapter_ioredis_exports, {
+  adaptCluster: () => adaptCluster,
+  adaptIoredis: () => adaptIoredis,
+  createIoredisClient: () => createIoredisClient,
+  createIoredisCluster: () => createIoredisCluster,
+  createIoredisSentinel: () => createIoredisSentinel
+});
+function adapt(client, isClusterClient = false) {
+  return {
+    get isOpen() {
+      return client.status === "ready";
+    },
+    connect: async () => {
+      if (client.status !== "ready" && client.status !== "connecting") {
+        await client.connect();
+      }
+    },
+    get: (k) => client.get(k),
+    set: (k, v, opts) => {
+      const args = [];
+      if (opts?.EX !== void 0) args.push("EX", opts.EX);
+      if (opts?.NX) args.push("NX");
+      return client.set(k, v, ...args);
+    },
+    del: async (keys) => {
+      const arr = Array.isArray(keys) ? keys : [keys];
+      if (arr.length === 0) return 0;
+      return client.del(...arr);
+    },
+    sAdd: async (k, m) => {
+      const arr = Array.isArray(m) ? m : [m];
+      if (arr.length === 0) return 0;
+      return client.sadd(k, ...arr);
+    },
+    sMembers: (k) => client.smembers(k),
+    expire: async (k, s) => {
+      const r = await client.expire(k, s);
+      return r;
+    },
+    mGet: async (keys) => {
+      if (keys.length === 0) return [];
+      return client.mget(...keys);
+    },
+    eval: (script, opts) => client.eval(
+      script,
+      opts.keys.length,
+      ...opts.keys,
+      ...opts.arguments
+    ),
+    evalSha: (sha, opts) => client.evalsha(
+      sha,
+      opts.keys.length,
+      ...opts.keys,
+      ...opts.arguments
+    ),
+    scriptLoad: async (script) => await client.script("LOAD", script),
+    scanIterator: async function* ({ MATCH, COUNT }) {
+      if (isClusterClient) {
+        const cluster = client;
+        for (const node of cluster.nodes("master")) {
+          let cursor = "0";
+          do {
+            const [next, batch] = await node.scan(
+              cursor,
+              "MATCH",
+              MATCH,
+              "COUNT",
+              COUNT ?? 100
+            );
+            cursor = next;
+            if (batch.length > 0) yield batch;
+          } while (cursor !== "0");
+        }
+      } else {
+        const redis = client;
+        let cursor = "0";
+        do {
+          const [next, batch] = await redis.scan(
+            cursor,
+            "MATCH",
+            MATCH,
+            "COUNT",
+            COUNT ?? 100
+          );
+          cursor = next;
+          if (batch.length > 0) yield batch;
+        } while (cursor !== "0");
+      }
+    },
+    ping: () => client.ping(),
+    on: (event, listener) => {
+      client.on(event, listener);
+      return client;
+    },
+    publish: (channel, message) => client.publish(channel, message),
+    ...isClusterClient ? {} : {
+      subscribe: async (channel, onMessage, onDown) => {
+        const sub = client.duplicate();
+        let down = false;
+        const markDown = () => {
+          if (down) return;
+          down = true;
+          try {
+            sub.disconnect();
+          } catch {
+          }
+          onDown?.();
+        };
+        sub.on("error", markDown);
+        sub.on("end", markDown);
+        try {
+          if (sub.status !== "ready" && sub.status !== "connecting") {
+            await sub.connect();
+          }
+          await sub.subscribe(channel);
+        } catch (err) {
+          markDown();
+          throw err;
+        }
+        sub.on("message", (ch, message) => {
+          if (ch === channel) onMessage(message);
+        });
+        return async () => {
+          down = true;
+          sub.disconnect();
+        };
+      }
+    },
+    dispose: () => {
+      client.disconnect();
+    }
+  };
+}
+function adaptIoredis(client) {
+  return adapt(client, false);
+}
+function adaptCluster(cluster) {
+  return adapt(cluster, true);
+}
+function createIoredisClient(config) {
+  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,
+    // 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 = nodeRequire("ioredis");
+  const ClusterCtor = IORedis.Cluster ?? IORedis.default.Cluster;
+  return new ClusterCtor(config.nodes, {
+    redisOptions: {
+      password: config.password,
+      tls: config.tls ? {} : void 0
+    },
+    enableReadyCheck: 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/seed/index.ts
+init_cjs_shims();
+
+// src/shared/client/index.ts
+init_cjs_shims();
+async function buildClient(source) {
+  if (typeof source === "function") {
+    return await source();
+  }
+  switch (source.type) {
+    case "redis": {
+      const { adaptRedisV5: adaptRedisV52, createRedisV5Client: createRedisV5Client2 } = await Promise.resolve().then(() => (init_adapter_redis(), adapter_redis_exports));
+      return adaptRedisV52(createRedisV5Client2(source));
+    }
+    case "ioredis": {
+      const { adaptIoredis: adaptIoredis2, createIoredisClient: createIoredisClient2 } = await Promise.resolve().then(() => (init_adapter_ioredis(), adapter_ioredis_exports));
+      return adaptIoredis2(createIoredisClient2(source));
+    }
+    case "cluster": {
+      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(
+        `[next-cache] unknown client config: ${JSON.stringify(exhaustive)}`
+      );
+    }
+  }
+}
+
+// src/shared/compress.ts
+init_cjs_shims();
+var gzipAsync = util.promisify(zlib.gzip);
+util.promisify(zlib.gunzip);
+var brotliCompressAsync = util.promisify(zlib.brotliCompress);
+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");
+}
+
+// src/shared/namespace.ts
+init_cjs_shims();
+var FALLBACK = "unversioned";
+function resolveBuildNamespace(override) {
+  if (override !== void 0) {
+    return typeof override === "function" ? override() : override;
+  }
+  return process.env.DEPLOYMENT_VERSION ?? process.env.GIT_HASH ?? process.env.NEXT_DEPLOYMENT_ID ?? FALLBACK;
+}
+function buildKey(prefix, namespace, rest, hashTag = false) {
+  const ns = hashTag ? `{${namespace}}` : namespace;
+  return `${prefix}${ns}:${rest}`;
+}
+
+// src/incremental/serialize.ts
+init_cjs_shims();
+function replacer(key, value) {
+  const raw = this[key];
+  if (Buffer.isBuffer(raw)) {
+    const env = {
+      __type: "Buffer",
+      data: raw.toString("base64")
+    };
+    return env;
+  }
+  if (value instanceof Map) {
+    const env = {
+      __type: "Map",
+      entries: Array.from(value.entries())
+    };
+    return env;
+  }
+  return value;
+}
+function serializeCacheRecord(record) {
+  return JSON.stringify(record, replacer);
+}
+
+// src/seed/index.ts
+var ONE_YEAR_SEC = 60 * 60 * 24 * 365;
+var MIN_TTL_SEC = 60;
+var DEFAULT_KEY_PREFIX = "next-incremental:";
+function clampTtl(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);
+  }
+  return MIN_TTL_SEC;
+}
+function routeToFileBase(route) {
+  return route === "/" ? "/index" : route;
+}
+function readMeta(file) {
+  try {
+    return JSON.parse(fs__default.default.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function writeRecord(client, key, value, revalidateSec, opts) {
+  const record = {
+    lastModified: Date.now(),
+    value,
+    revalidateSec: clampTtl(revalidateSec)
+  };
+  const redisKey = buildKey(`${opts.keyPrefix}entry:`, opts.ns, key, opts.hashTag);
+  const payload = await compressValue(
+    serializeCacheRecord(record),
+    opts.compression
+  );
+  const result = await client.set(redisKey, payload, {
+    EX: clampTtl(revalidateSec),
+    NX: true
+  });
+  return result === null ? "skipped" : "written";
+}
+async function seedBuildOutput(options) {
+  const dir = path2__default.default.resolve(options.dir ?? ".next");
+  const keyPrefix = options.keyPrefix ?? DEFAULT_KEY_PREFIX;
+  const hashTag = options.hashTag ?? false;
+  const ns = resolveBuildNamespace(options.buildNamespace);
+  const warn = options.logger?.warn ?? (() => {
+  });
+  const summary = {
+    routes: 0,
+    pages: 0,
+    fetch: 0,
+    skippedExisting: 0,
+    skippedIncomplete: 0,
+    skippedRouteHandlers: 0,
+    errors: []
+  };
+  const manifestPath = path2__default.default.join(dir, "prerender-manifest.json");
+  if (!fs__default.default.existsSync(manifestPath)) {
+    throw new Error(
+      `[next-cache] no prerender-manifest.json in ${dir} \u2014 run \`next build\` first`
+    );
+  }
+  const manifest = JSON.parse(fs__default.default.readFileSync(manifestPath, "utf8"));
+  const client = await buildClient(options.client);
+  if (!client.isOpen) await client.connect();
+  const writeOpts = { keyPrefix, hashTag, ns, ...options.compression ? { compression: options.compression } : {} };
+  try {
+    for (const [route, info] of Object.entries(manifest.routes ?? {})) {
+      try {
+        const isPages = typeof info.dataRoute === "string" && info.dataRoute.endsWith(".json");
+        const base = routeToFileBase(route);
+        if (isPages) {
+          const html = path2__default.default.join(dir, "server", "pages", `${base.slice(1)}.html`);
+          const data = path2__default.default.join(dir, "server", "pages", `${base.slice(1)}.json`);
+          if (!fs__default.default.existsSync(html)) {
+            summary.skippedIncomplete += 1;
+            continue;
+          }
+          const value2 = {
+            kind: "PAGES",
+            html: fs__default.default.readFileSync(html, "utf8"),
+            pageData: fs__default.default.existsSync(data) ? JSON.parse(fs__default.default.readFileSync(data, "utf8")) : {},
+            headers: void 0,
+            status: void 0
+          };
+          const r2 = await writeRecord(client, route, value2, info.initialRevalidateSeconds, writeOpts);
+          if (r2 === "written") summary.pages += 1;
+          else summary.skippedExisting += 1;
+          continue;
+        }
+        const htmlPath = path2__default.default.join(dir, "server", "app", `${base.slice(1)}.html`);
+        const rscPath = path2__default.default.join(dir, "server", "app", `${base.slice(1)}.rsc`);
+        const metaPath = path2__default.default.join(dir, "server", "app", `${base.slice(1)}.meta`);
+        if (!fs__default.default.existsSync(htmlPath) || !fs__default.default.existsSync(metaPath)) {
+          if (fs__default.default.existsSync(path2__default.default.join(dir, "server", "app", `${base.slice(1)}.body`))) {
+            summary.skippedRouteHandlers += 1;
+          } else {
+            summary.skippedIncomplete += 1;
+          }
+          continue;
+        }
+        const meta = readMeta(metaPath) ?? {};
+        if (meta.postponed) {
+          summary.skippedIncomplete += 1;
+          continue;
+        }
+        let segmentData;
+        if (Array.isArray(meta.segmentPaths) && meta.segmentPaths.length > 0) {
+          const segDir = path2__default.default.join(dir, "server", "app", `${base.slice(1)}.segments`);
+          segmentData = /* @__PURE__ */ new Map();
+          for (const segPath of meta.segmentPaths) {
+            const segFile = path2__default.default.join(segDir, `${segPath.slice(1)}.segment.rsc`);
+            if (fs__default.default.existsSync(segFile)) {
+              segmentData.set(segPath, fs__default.default.readFileSync(segFile));
+            }
+          }
+          if (segmentData.size !== meta.segmentPaths.length) {
+            summary.skippedIncomplete += 1;
+            continue;
+          }
+        }
+        const value = {
+          kind: "APP_PAGE",
+          html: fs__default.default.readFileSync(htmlPath, "utf8"),
+          rscData: fs__default.default.existsSync(rscPath) ? fs__default.default.readFileSync(rscPath) : void 0,
+          headers: meta.headers,
+          status: meta.status
+        };
+        if (segmentData) value.segmentData = segmentData;
+        const r = await writeRecord(client, route, value, info.initialRevalidateSeconds, writeOpts);
+        if (r === "written") summary.routes += 1;
+        else summary.skippedExisting += 1;
+      } catch (err) {
+        summary.errors.push(`${route}: ${err.message}`);
+        warn("seed: route failed", { route, message: err.message });
+      }
+    }
+    const fetchDir = path2__default.default.join(dir, "cache", "fetch-cache");
+    if (fs__default.default.existsSync(fetchDir)) {
+      for (const file of fs__default.default.readdirSync(fetchDir)) {
+        if (file.startsWith(".")) continue;
+        try {
+          const raw = fs__default.default.readFileSync(path2__default.default.join(fetchDir, file), "utf8");
+          const value = JSON.parse(raw);
+          if (value.kind !== "FETCH") continue;
+          const r = await writeRecord(client, file, value, value.revalidate, writeOpts);
+          if (r === "written") summary.fetch += 1;
+          else summary.skippedExisting += 1;
+        } catch (err) {
+          summary.errors.push(`fetch:${file}: ${err.message}`);
+        }
+      }
+    }
+  } finally {
+    const c = client;
+    try {
+      (c.dispose ?? c.destroy ?? c.disconnect)?.call(c);
+    } catch {
+    }
+  }
+  return summary;
+}
+
+exports.seedBuildOutput = seedBuildOutput;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map