@edgeone/nuxt-pages 1.1.0-beta.4 → 1.1.1

package/dist/build/content/module-inject.js

@@ -8,8 +8,8 @@ import {
   cleanupEdgeoneModule,
   injectEdgeoneModule,
   removeTempModule
-} from "../../esm-chunks/chunk-ZR3DYEBK.js";
-import "../../esm-chunks/chunk-VCJ5U4PV.js";
+} from "../../esm-chunks/chunk-PHIWUHZJ.js";
+import "../../esm-chunks/chunk-VPL326TW.js";
 import "../../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   cleanupEdgeoneModule,

package/dist/build/functions/server.js

@@ -7,7 +7,7 @@
 import {
   createServerHandler,
   patchNitroHandler
-} from "../../esm-chunks/chunk-PJWA566S.js";
+} from "../../esm-chunks/chunk-4B7OVONM.js";
 import "../../esm-chunks/chunk-K5VT7O2H.js";
 import "../../esm-chunks/chunk-6BT4RYQJ.js";
 export {

package/dist/build/plugin-context.js

@@ -7,9 +7,9 @@
 import {
   PluginContext,
   SERVER_HANDLER_NAME
-} from "../esm-chunks/chunk-VDBASNGL.js";
-import "../esm-chunks/chunk-AZLY3JO2.js";
-import "../esm-chunks/chunk-VCJ5U4PV.js";
+} from "../esm-chunks/chunk-VLRIK4OQ.js";
+import "../esm-chunks/chunk-ODJXW6KT.js";
+import "../esm-chunks/chunk-VPL326TW.js";
 import "../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   PluginContext,

package/dist/build/routes.js

@@ -8,9 +8,10 @@ import {
   createNuxtApiRoutesMeta,
   createNuxtPagesRouteMeta,
   createNuxtRoutesMeta
-} from "../esm-chunks/chunk-3HA3DZ3G.js";
-import "../esm-chunks/chunk-AZLY3JO2.js";
-import "../esm-chunks/chunk-VCJ5U4PV.js";
+} from "../esm-chunks/chunk-D5KM3RWE.js";
+import "../esm-chunks/chunk-ODJXW6KT.js";
+import "../esm-chunks/chunk-QUFJCWGJ.js";
+import "../esm-chunks/chunk-VPL326TW.js";
 import "../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   createNuxtApiRoutesMeta,

package/dist/build/tag-manifest.js

@@ -0,0 +1,15 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  buildTagManifest,
+  extractCacheTags
+} from "../esm-chunks/chunk-QUFJCWGJ.js";
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+export {
+  buildTagManifest,
+  extractCacheTags
+};

package/dist/build/templates/isr-runtime.js

@@ -0,0 +1,215 @@
+/**
+ * ISR (Incremental Static Regeneration) runtime for the EdgeOne Nuxt adapter.
+ *
+ * Extracted from the handler template so the handler stays thin. This module is
+ * copied next to handler.js in the server-handler directory at build time and
+ * imported from there; it reads the build-time manifests (isr-manifest.json /
+ * tag-manifest.json) that sit in the same directory.
+ *
+ * ISR on EdgeOne is a "CDN cache + purge" model:
+ *   - applyIsr()        tags cacheable responses with `eo-cdn-cache-control` /
+ *                       `cache-tag` so the edge caches + revalidates them.
+ *   - handleRevalidate() purges the edge cache on demand (POST endpoint).
+ */
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, existsSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const ISR_SWR_WINDOW = 31536000; // 1 year stale-while-revalidate window
+export const REVALIDATE_ENDPOINT = '/__edgeone_revalidate';
+
+let _isrRoutes = null; // [{ re: RegExp, revalidate, tags }]
+function getIsrRoutes() {
+  if (_isrRoutes) return _isrRoutes;
+  _isrRoutes = [];
+  try {
+    const p = resolve(__dirname, 'isr-manifest.json');
+    if (existsSync(p)) {
+      const manifest = JSON.parse(readFileSync(p, 'utf-8'));
+      for (const r of manifest?.routes || []) {
+        if (!r?.src) continue;
+        try {
+          _isrRoutes.push({ re: new RegExp(r.src), revalidate: r.revalidate, tags: r.tags || [] });
+        } catch { /* skip invalid pattern */ }
+      }
+    }
+  } catch (err) {
+    console.warn('[nuxt-pages] Failed to load isr-manifest.json:', err?.message || err);
+  }
+  return _isrRoutes;
+}
+
+let _tagManifest = null; // { tag: [paths] }
+function getTagManifest() {
+  if (_tagManifest) return _tagManifest;
+  _tagManifest = { version: 1, tags: {} };
+  try {
+    const p = resolve(__dirname, 'tag-manifest.json');
+    if (existsSync(p)) {
+      _tagManifest = JSON.parse(readFileSync(p, 'utf-8'));
+    }
+  } catch (err) {
+    console.warn('[nuxt-pages] Failed to load tag-manifest.json:', err?.message || err);
+  }
+  return _tagManifest;
+}
+
+/** Find the first ISR route whose pattern matches the given pathname. */
+function matchIsrRoute(pathname) {
+  for (const route of getIsrRoutes()) {
+    if (route.re.test(pathname)) return route;
+  }
+  return null;
+}
+
+/** Set EdgeOne CDN cache-control for an ISR response (time-based revalidation). */
+function setIsrCacheHeaders(headers, route) {
+  const revalidate = typeof route.revalidate === 'number' ? route.revalidate : ISR_SWR_WINDOW;
+  headers.set(
+    'eo-cdn-cache-control',
+    `s-maxage=${revalidate}, stale-while-revalidate=${ISR_SWR_WINDOW}, durable`,
+  );
+  // Keep the browser from caching a stale copy; the edge holds the shared cache.
+  if (!headers.has('cache-control')) {
+    headers.set('cache-control', 'public, max-age=0, must-revalidate');
+  }
+  if (Array.isArray(route.tags) && route.tags.length > 0) {
+    headers.set('cache-tag', route.tags.join(','));
+  }
+}
+
+/** Real user-facing host. EdgeOne rewrites Host to the origin, real host is in `eo-pages-host`. */
+function getRealHost(headers) {
+  const get = (k) => {
+    if (headers && typeof headers.get === 'function') return headers.get(k) || '';
+    return (headers && (headers[k] || headers[k.toLowerCase()])) || '';
+  };
+  return get('eo-pages-host') || get('host') || process.env.SITE_HOST || '';
+}
+
+/** Expand cache tags to concrete paths using the tag manifest (unknown tag -> treated as a path). */
+function expandTagsToPaths(tags) {
+  const manifest = getTagManifest();
+  const paths = new Set();
+  for (const tag of tags) {
+    const mapped = manifest?.tags?.[tag];
+    if (Array.isArray(mapped) && mapped.length) {
+      for (const p of mapped) paths.add(p);
+    } else {
+      paths.add(tag); // revalidatePath scenario
+    }
+  }
+  return Array.from(paths);
+}
+
+/** Purge the EdgeOne CDN cache for a set of paths on the given host. */
+async function purgeEdgeCache(paths, host) {
+  if (!paths || paths.length === 0) return { purged: 0 };
+  if (!host) {
+    console.error('[nuxt-pages] Cannot purge: no host (eo-pages-host header or SITE_HOST env)');
+    return { purged: 0, error: 'no-host' };
+  }
+
+  // Only concrete paths can be purged as URLs. Route patterns (containing
+  // dynamic segments like `**`, `:id`, `[id]`) can't be expanded to a single
+  // URL here — skip them and warn.
+  const isConcrete = (p) => typeof p === 'string' && !/[*:\[\]]/.test(p);
+  const skipped = paths.filter((p) => !isConcrete(p));
+  if (skipped.length) {
+    console.warn(
+      '[nuxt-pages] Skipped non-concrete purge target(s) — pass explicit paths to revalidate dynamic routes:',
+      skipped,
+    );
+  }
+
+  const fullUrls = paths
+    .filter(isConcrete)
+    .map((p) => `https://${host}${p.startsWith('/') ? p : `/${p}`}`);
+
+  if (fullUrls.length === 0) return { purged: 0, skipped };
+
+  const endpoint = process.env.IS_MAINLAND === 'true'
+    ? 'https://pages-api.cloud.tencent.com/eo/pages/hook/eo_purge'
+    : 'https://pages-api.edgeone.ai/eo/pages/hook/eo_purge?site=intl';
+
+  try {
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        RequestId: `purge-${Date.now()}`,
+        Token: process.env.PURGE_TOKEN,
+        paths: fullUrls,
+      }),
+    });
+    const text = await res.text();
+    let data;
+    try { data = JSON.parse(text); } catch {
+      console.error(`[nuxt-pages] Purge API non-JSON (${res.status}): ${text.slice(0, 200)}`);
+      return { purged: 0, error: 'bad-response' };
+    }
+    if (data?.error) {
+      console.error('[nuxt-pages] Purge API error:', JSON.stringify(data.error));
+      return { purged: 0, error: data.error };
+    }
+    return { purged: fullUrls.length, urls: fullUrls };
+  } catch (error) {
+    console.error('[nuxt-pages] Purge request failed:', error?.message || error);
+    return { purged: 0, error: String(error?.message || error) };
+  }
+}
+
+/**
+ * Tag a cacheable response with the ISR CDN cache directives, if its path
+ * matches an ISR route. Mutates `headers` in place. Skips personalized
+ * (Set-Cookie) or explicitly non-shared (no-store/private) responses.
+ */
+export function applyIsr(headers, { method, status, pathname }) {
+  if (method !== 'GET' && method !== 'HEAD') return;
+  if (status !== 200) return;
+  if (headers.has('set-cookie')) return;
+  if (/no-store|private/i.test(headers.get('cache-control') || '')) return;
+
+  // Nuxt client navigation fetches `<route>/_payload.json`; match it to the
+  // page route so the payload is cached with the same window.
+  const matchPath = pathname.replace(/\/_payload\.json$/, '') || '/';
+  const route = matchIsrRoute(matchPath);
+  if (route) setIsrCacheHeaders(headers, route);
+}
+
+/**
+ * On-demand revalidation endpoint handler. POST /__edgeone_revalidate
+ * Body: { token, tags?: string[], paths?: string[] }
+ * Purges the CDN cache for the resolved paths so the next request regenerates.
+ */
+export async function handleRevalidate(req, headers, body) {
+  const token = process.env.PURGE_TOKEN;
+  // Secure by default: without a configured token the endpoint is disabled.
+  if (!token) {
+    return new Response(JSON.stringify({ revalidated: false, error: 'purge-not-configured' }), {
+      status: 403, headers: { 'Content-Type': 'application/json' },
+    });
+  }
+  let payload = {};
+  try { payload = body ? JSON.parse(body) : {}; } catch { /* ignore */ }
+
+  const provided = payload.token
+    || (headers && typeof headers.get === 'function' ? headers.get('x-revalidate-token') : headers?.['x-revalidate-token']);
+  if (provided !== token) {
+    return new Response(JSON.stringify({ revalidated: false, error: 'invalid-token' }), {
+      status: 401, headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  const tags = Array.isArray(payload.tags) ? payload.tags : [];
+  const explicitPaths = Array.isArray(payload.paths) ? payload.paths : [];
+  const paths = Array.from(new Set([...expandTagsToPaths(tags), ...explicitPaths]));
+
+  const result = await purgeEdgeCache(paths, getRealHost(headers));
+  return new Response(JSON.stringify({ revalidated: !result.error, ...result }), {
+    status: result.error ? 500 : 200,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}

package/dist/build/templates/nuxt-handler-monorepo.tmpl.js

@@ -2,6 +2,7 @@ import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { readFileSync, existsSync, statSync } from 'fs';
 import { extname } from 'path';
+import { REVALIDATE_ENDPOINT, applyIsr, handleRevalidate } from './isr-runtime.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -172,6 +173,13 @@ export default async function handler(req, res, context) {
     const headers = req.headers || new Headers();
     const body = await getBody(req);
 
+    const pathname = url.split('?')[0];
+
+    // On-demand ISR revalidation endpoint (purges CDN cache).
+    if (pathname === REVALIDATE_ENDPOINT && method === 'POST') {
+      return await handleRevalidate(req, headers, body);
+    }
+
     // First try to handle static assets
     if (method === 'GET') {
       const staticResponse = handleStaticFile(url);
@@ -221,8 +229,13 @@ export default async function handler(req, res, context) {
       }
     
       // console.log('responseHeaders.getSetCookie() --->', responseHeaders.getSetCookie());
+      const status = response.status || response.statusCode;
+
+      // ISR: tag cacheable responses with EdgeOne CDN cache directives.
+      applyIsr(responseHeaders, { method, status, pathname });
+
       return new Response(response.body, {
-        status: response.status || response.statusCode,
+        status,
         headers: responseHeaders
       });
     } catch (nitroError) {

package/dist/esm-chunks/{chunk-PJWA566S.js → chunk-4B7OVONM.js}

@@ -92,6 +92,12 @@ var getHandlerFile = async (ctx) => {
 var writeHandlerFile = async (ctx) => {
   const handler = await getHandlerFile(ctx);
   await writeFile(join(ctx.serverHandlerRootDir, `handler.js`), handler);
+  const templatesDir = join(ctx.pluginDir, "dist/build/templates");
+  await cp(
+    join(templatesDir, "isr-runtime.js"),
+    join(ctx.serverHandlerRootDir, "isr-runtime.js"),
+    { force: true }
+  );
 };
 var createServerHandler = async (ctx) => {
   await mkdir(join(ctx.serverHandlerRuntimeModulesDir), { recursive: true });

package/dist/esm-chunks/{chunk-3HA3DZ3G.js → chunk-D5KM3RWE.js}

@@ -7,13 +7,19 @@
 import {
   getHandlersArrayWithAST,
   getRouteRulesWithAST
-} from "./chunk-AZLY3JO2.js";
+} from "./chunk-ODJXW6KT.js";
+import {
+  buildTagManifest,
+  extractCacheTags
+} from "./chunk-QUFJCWGJ.js";
 
 // src/build/routes.ts
 import * as fs from "fs";
 import * as path from "path";
 var CONFIG_VERSION = 3;
 var CONFIG_FILE_NAME = "config.json";
+var ISR_MANIFEST_FILE_NAME = "isr-manifest.json";
+var TAG_MANIFEST_FILE_NAME = "tag-manifest.json";
 function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -37,6 +43,14 @@ function writeConfig(config) {
   const configPath = getConfigPath();
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
 }
+function writeIsrManifest(manifest) {
+  const p = path.join(ensureServerHandlerDir(), ISR_MANIFEST_FILE_NAME);
+  fs.writeFileSync(p, JSON.stringify(manifest, null, 2), "utf-8");
+}
+function writeTagManifest(manifest) {
+  const p = path.join(ensureServerHandlerDir(), TAG_MANIFEST_FILE_NAME);
+  fs.writeFileSync(p, JSON.stringify(manifest, null, 2), "utf-8");
+}
 function normalizeHeaders(headers) {
   if (!headers || typeof headers !== "object") return null;
   const out = {};
@@ -240,12 +254,51 @@ async function buildExplicitSsrAndSwrRoutes(ctx) {
   tmp.sort((a, b) => b.score - a.score);
   return tmp.map((x) => x.rule);
 }
+async function buildIsrEntries(ctx) {
+  const routesManifest = await ctx.getRoutesManifest();
+  const manifestRoutes = Array.isArray(routesManifest?.routes) ? routesManifest.routes : [];
+  const routeRules = await getRouteRulesFromBuildOutput(ctx) || {};
+  const seen = /* @__PURE__ */ new Set();
+  const scored = [];
+  for (const r of manifestRoutes) {
+    const p = typeof r?.path === "string" ? r.path : "";
+    if (!p) continue;
+    const swr = r?.swr;
+    const isIsr = swr === true || typeof swr === "number" && swr > 0;
+    if (!isIsr || r?.prerender === true) continue;
+    const normalized = normalizeRoutePath(p);
+    if (normalized.startsWith("/api")) continue;
+    const rule = nuxtRoutePathToRouteRule(normalized);
+    const src = rule?.src;
+    if (!src || seen.has(src)) continue;
+    seen.add(src);
+    const tags = extractCacheTags(routeRules?.[p]?.headers ?? routeRules?.[normalized]?.headers);
+    const score = (isCatchAllLikeRoutePath(normalized) ? -1e4 : 0) + normalized.split("/").length;
+    scored.push({
+      score,
+      entry: {
+        src,
+        path: normalized,
+        revalidate: typeof swr === "number" ? swr : false,
+        tags
+      }
+    });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.map((x) => x.entry);
+}
 var createNuxtRoutesMeta = async (ctx) => {
   const routes = await buildStage1Routes(ctx);
   routes.push(...await buildExplicitApiRoutes(ctx));
   routes.push(...await buildExplicitSsrAndSwrRoutes(ctx));
   routes.push({ src: "^/(.*)$" });
   writeConfig({ version: CONFIG_VERSION, routes });
+  const isrEntries = await buildIsrEntries(ctx);
+  writeIsrManifest({ version: 1, routes: isrEntries });
+  writeTagManifest(buildTagManifest(isrEntries));
+  console.log(
+    `[nuxt-pages] Generated ISR manifest with ${isrEntries.length} route(s) and ${Object.keys(buildTagManifest(isrEntries).tags).length} cache tag(s)`
+  );
 };
 var createNuxtPagesRouteMeta = async (ctx) => {
   await createNuxtRoutesMeta(ctx);

package/dist/esm-chunks/{chunk-AZLY3JO2.js → chunk-ODJXW6KT.js}

@@ -6,7 +6,7 @@
     
 import {
   require_lib
-} from "./chunk-VCJ5U4PV.js";
+} from "./chunk-VPL326TW.js";
 import {
   __toESM
 } from "./chunk-6BT4RYQJ.js";

package/dist/esm-chunks/{chunk-ZR3DYEBK.js → chunk-PHIWUHZJ.js}

@@ -6,7 +6,7 @@
     
 import {
   require_lib
-} from "./chunk-VCJ5U4PV.js";
+} from "./chunk-VPL326TW.js";
 import {
   __toESM
 } from "./chunk-6BT4RYQJ.js";

package/dist/esm-chunks/chunk-QUFJCWGJ.js

@@ -0,0 +1,38 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/build/tag-manifest.ts
+function extractCacheTags(headers) {
+  if (!headers || typeof headers !== "object") return [];
+  let raw;
+  for (const [k, v] of Object.entries(headers)) {
+    if (typeof k === "string" && k.toLowerCase() === "cache-tag") {
+      raw = v;
+      break;
+    }
+  }
+  if (raw == null) return [];
+  const parts = Array.isArray(raw) ? raw : String(raw).split(",");
+  return parts.map((t) => String(t).trim()).filter((t) => t.length > 0);
+}
+function buildTagManifest(entries) {
+  const tags = {};
+  for (const entry of entries) {
+    for (const tag of entry.tags) {
+      if (!tags[tag]) tags[tag] = [];
+      if (!tags[tag].includes(entry.path)) {
+        tags[tag].push(entry.path);
+      }
+    }
+  }
+  return { version: 1, tags };
+}
+
+export {
+  extractCacheTags,
+  buildTagManifest
+};

package/dist/esm-chunks/{chunk-VDBASNGL.js → chunk-VLRIK4OQ.js}

@@ -9,7 +9,7 @@ import {
   getPrerenderRoutesWithAST,
   getRouteRulesWithAST,
   getRoutesArrayWithAST
-} from "./chunk-AZLY3JO2.js";
+} from "./chunk-ODJXW6KT.js";
 
 // src/build/plugin-context.ts
 import { existsSync, readFileSync } from "node:fs";