@edgeone/opennextjs-pages 0.2.6 → 0.2.8-beta.1

package/dist/build/routes.js

@@ -15,6 +15,7 @@ import {
   convertHeaders,
   convertTrailingSlash
 } from "./route-utils.js";
+import { generateTagManifest } from "./tag-manifest.js";
 function hasAppRouter(appPathRoutesManifest) {
   return appPathRoutesManifest && Object.keys(appPathRoutesManifest).length > 0;
 }
@@ -372,6 +373,10 @@ var createRouteMeta = async (ctx) => {
     "utf-8"
   );
   console.log(`[opennext] Generated ${configFilePath} with ${routes.length} routes`);
+  const tagManifest = generateTagManifest(prerenderManifest, ctx.publishDir);
+  const tagManifestPath = path.join(serverHandlerDir, "tag-manifest.json");
+  fs.writeFileSync(tagManifestPath, JSON.stringify(tagManifest, null, 2), "utf-8");
+  console.log(`[opennext] Generated ${tagManifestPath} with ${Object.keys(tagManifest.tags).length} tags`);
   const middlewareConfig = await getMiddlewareConfig(ctx);
   updateEdgeFunctionsConfigJson(middlewareConfig);
 };

package/dist/build/tag-manifest.js

@@ -0,0 +1,57 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/tag-manifest.ts
+import * as fs from "fs";
+import * as path from "path";
+function generateTagManifest(prerenderManifest, publishDir) {
+  const tags = {};
+  if (!prerenderManifest?.routes) {
+    return { version: 1, tags };
+  }
+  const routes = prerenderManifest.routes;
+  for (const [routePath, routeConfig] of Object.entries(routes)) {
+    if (typeof routeConfig.initialRevalidateSeconds !== "number") {
+      continue;
+    }
+    const cacheTags = getCacheTagsForRoute(routePath, routeConfig, publishDir);
+    if (!cacheTags) {
+      continue;
+    }
+    const tagList = cacheTags.split(",").map((tag) => tag.trim().replace(/^_N_T_/, "")).filter((tag) => tag.length > 0);
+    for (const tag of tagList) {
+      if (!tags[tag]) {
+        tags[tag] = [];
+      }
+      if (!tags[tag].includes(routePath)) {
+        tags[tag].push(routePath);
+      }
+    }
+  }
+  return { version: 1, tags };
+}
+function getCacheTagsForRoute(routePath, routeConfig, publishDir) {
+  const metaFileName = routePath === "/" ? "index.meta" : `${routePath.slice(1)}.meta`;
+  const metaFilePath = path.join(publishDir, "server", "app", metaFileName);
+  if (fs.existsSync(metaFilePath)) {
+    try {
+      const metaContent = fs.readFileSync(metaFilePath, "utf-8");
+      const meta = JSON.parse(metaContent);
+      const tags = meta?.headers?.["x-next-cache-tags"];
+      if (tags) {
+        return tags;
+      }
+    } catch (err) {
+      console.warn(`[opennext] Warning: Failed to parse ${metaFilePath}: ${err}`);
+    }
+  }
+  return routeConfig.initialHeaders?.["x-next-cache-tags"] ?? null;
+}
+export {
+  generateTagManifest
+};

package/dist/run/handlers/request-context.cjs

@@ -99,12 +99,21 @@ var systemLogger = new SystemLogger();
 var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
 var REQUEST_COUNTER_KEY = Symbol.for("nf-request-counter");
 var extendedGlobalThis = globalThis;
+function getHostFromRequest(request) {
+  if (!request?.headers) return void 0;
+  const headers = request.headers;
+  if (typeof headers.get === "function") {
+    return headers.get("eo-pages-host") || headers.get("host") || void 0;
+  }
+  return headers["eo-pages-host"] || headers["host"] || void 0;
+}
 function createRequestContext(request, context) {
   const backgroundWorkPromises = [];
   const logger = systemLogger.withLogLevel(LogLevel.Log);
   return {
     isBackgroundRevalidation: false,
     captureServerTiming: false,
+    host: getHostFromRequest(request),
     trackBackgroundWork: (promise) => {
       if (context?.waitUntil) {
         context.waitUntil(promise);

package/dist/run/handlers/server.js

@@ -3094,7 +3094,8 @@ function toComputeResponse(res) {
 import { getRunConfig, setRunConfig } from "../config.js";
 import {
   setCacheControlHeaders,
-  setCacheStatusHeader
+  setCacheStatusHeader,
+  setCacheTagsHeaders
 } from "../headers.js";
 import { nextResponseProxy } from "../revalidate.js";
 import { setFetchBeforeNextPatchedIt } from "../storage/storage.cjs";
@@ -3235,6 +3236,7 @@ var server_default = async (request, _context, topLevelSpan, requestContext) =>
       topLevelSpan.setAttribute("responseCacheKey", requestContext.responseCacheKey);
     }
     setCacheControlHeaders(response, request, requestContext);
+    setCacheTagsHeaders(response.headers, requestContext);
     setCacheStatusHeader(response.headers, null);
     if (requestContext.isCacheableAppPage && response.status !== 304) {
       const isRSCRequest = request.headers.get("rsc") === "1";

package/dist/run/handlers/tag-manifest.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/tag-manifest.cts
+var tag_manifest_exports = {};
+__export(tag_manifest_exports, {
+  expandTagsToPaths: () => expandTagsToPaths
+});
+module.exports = __toCommonJS(tag_manifest_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var cachedManifest = null;
+function loadManifest() {
+  if (cachedManifest) {
+    return cachedManifest;
+  }
+  const emptyManifest = { version: 1, tags: {} };
+  const candidates = [
+    path.resolve(process.cwd(), "tag-manifest.json"),
+    path.resolve(__dirname, "..", "..", "tag-manifest.json"),
+    // Walk up from __dirname to find tag-manifest.json in SCF bundle root
+    ...findAncestorPaths(__dirname, "tag-manifest.json")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      try {
+        const content = fs.readFileSync(candidate, "utf-8");
+        cachedManifest = JSON.parse(content);
+        return cachedManifest;
+      } catch {
+      }
+    }
+  }
+  cachedManifest = emptyManifest;
+  return cachedManifest;
+}
+function findAncestorPaths(startDir, filename) {
+  const paths = [];
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+    paths.push(path.join(dir, filename));
+  }
+  return paths;
+}
+function expandTagsToPaths(tags) {
+  const manifest = loadManifest();
+  const paths = /* @__PURE__ */ new Set();
+  for (const tag of tags) {
+    if (manifest.tags[tag]) {
+      for (const p of manifest.tags[tag]) {
+        paths.add(p);
+      }
+    } else {
+      paths.add(tag);
+    }
+  }
+  return Array.from(paths);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expandTagsToPaths
+});

package/dist/run/handlers/tags-handler.cjs

@@ -28,10 +28,11 @@ module.exports = __toCommonJS(tags_handler_exports);
 
 // package.json
 var name = "@edgeone/opennextjs-pages";
-var version = "0.2.6";
+var version = "0.2.8-beta.1";
 
 // src/run/handlers/tags-handler.cts
 var import_request_context = require("./request-context.cjs");
+var import_tag_manifest = require("./tag-manifest.cjs");
 var purgeCacheUserAgent = `${name}@${version}`;
 function isAnyTagStale(tags, timestamp) {
   return Promise.resolve(false);
@@ -44,24 +45,52 @@ async function purgeEdgeCache(tagOrTags) {
     return tag.replace(/^_N_T_/, "").replace(/\/page|\/layout$/, "");
   });
   if (tags.length === 0) {
-    return Promise.resolve();
+    return;
   }
-  (0, import_request_context.getLogger)().debug(`[NextRuntime] Purging CDN cache for: [${tags}.join(', ')]`);
-  const baseUrl = process.env.IS_MAINLAND === "true" ? "https://pages-api.cloud.tencent.com" : "https://pages-api.edgeone.ai";
-  const token = process.env.PURGE_TOKEN;
-  const requestBody = {
-    path: [...tags]
-  };
-  const res = await fetch(`${baseUrl}/eo/purge`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify(requestBody)
+  const paths = (0, import_tag_manifest.expandTagsToPaths)(tags);
+  if (paths.length === 0) {
+    return;
+  }
+  const requestContext = (0, import_request_context.getRequestContext)();
+  const host = requestContext?.host || process.env.SITE_HOST;
+  if (!host) {
+    (0, import_request_context.getLogger)().error(`[NextRuntime] Cannot purge: no host available (request context or SITE_HOST env)`);
+    return;
+  }
+  const fullUrls = paths.map((p) => {
+    const normalizedPath = p.startsWith("/") ? p : `/${p}`;
+    return `https://${host}${normalizedPath}`;
   });
-  const data = await res.json();
-  if (data?.error) {
+  (0, import_request_context.getLogger)().debug(`[NextRuntime] Purging CDN cache for tags [${tags.join(", ")}] \u2192 urls [${fullUrls.join(", ")}]`);
+  const baseUrl = process.env.PURGE_API_URL || (process.env.IS_MAINLAND === "true" ? "https://pages-api.cloud.tencent.com" : "https://pages-api.edgeone.ai");
+  const token = process.env.PURGE_TOKEN;
+  const purgeEndpoint = `${baseUrl}/eo/pages/hook/eo_purge`;
+  try {
+    const requestBody = {
+      RequestId: `purge-${Date.now()}`,
+      Token: token,
+      paths: fullUrls
+    };
+    const res = await fetch(purgeEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    const text = await res.text();
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      (0, import_request_context.getLogger)().error(`[NextRuntime] Purge API returned non-JSON (${res.status}): ${text.slice(0, 200)}`);
+      return;
+    }
+    if (data?.error) {
+      (0, import_request_context.getLogger)().error(`[NextRuntime] Purge API error: ${JSON.stringify(data.error)}`);
+    }
+  } catch (error) {
+    (0, import_request_context.getLogger)().withError(error).error(`[NextRuntime] Purging CDN cache for [${fullUrls.join(",")}] failed`);
   }
 }
 async function doRevalidateTagAndPurgeEdgeCache(tags) {

package/dist/run/headers.js

@@ -65,9 +65,14 @@ var setCacheControlHeaders = ({ headers, status }, request, requestContext) => {
   }
 };
 var setCacheTagsHeaders = (headers, requestContext) => {
-  if (!headers.has("cache-control")) {
+  const nextCacheTags = headers.get("x-next-cache-tags");
+  if (!nextCacheTags) {
     return;
   }
+  const tags = nextCacheTags.split(",").map((tag) => tag.trim().replace(/^_N_T_/, "")).filter(Boolean).join(",");
+  if (tags) {
+    headers.set("cache-tag", tags);
+  }
 };
 var setCacheStatusHeader = (headers, nextCache) => {
   if (headers.has("x-nextjs-cache")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgeone/opennextjs-pages",
-  "version": "0.2.6",
+  "version": "0.2.8-beta.1",
   "description": "",
   "main": "./dist/index.js",
   "type": "module",