@edgeone/nuxt-pages 1.0.0

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

@@ -0,0 +1,243 @@
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { extname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Static assets directory
+const ASSET_DIR = resolve(__dirname, '../assets');
+
+// MIME type mapping
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.txt': 'text/plain',
+  '.xml': 'application/xml'
+};
+
+/**
+ * Get the MIME type of a file
+ */
+function getMimeType(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || 'application/octet-stream';
+}
+
+/**
+ * Handle static file requests
+ */
+function handleStaticFile(url) {
+  try {
+    // Remove query parameters
+    let cleanUrl = url.split('?')[0];
+    
+    // Handle IPX image processing paths from @nuxt/image
+    // Convert /_ipx/s_800x600/hero.png to /hero.png
+    // Also handles nested paths: /_ipx/s_800x600/images/hero.png -> /images/hero.png
+    if (cleanUrl.startsWith('/_ipx/')) {
+      let newUrl = '';
+
+      // Remove /_ipx/ prefix
+      const ipxPath = cleanUrl.slice(6); // Remove '/_ipx/'
+      
+      // IPX format: /_ipx/[params]/[original_path]
+      // Parameters are typically the first segment(s) and contain underscores/commas
+      // The original file path starts after the params
+      const pathSegments = ipxPath.split('/').filter(s => s); // Remove empty segments
+      
+      if (pathSegments.length === 0) {
+        // Empty path after /_ipx/, skip
+        return null;
+      }
+      
+      // Check each segment for file extension
+      for (let i = 0; i < pathSegments.length; i++) {
+        const segment = pathSegments[i];
+        if(segment.startsWith('s_') || segment.startsWith('w_') || segment.startsWith('h_') || segment.startsWith('q_') || segment.startsWith('f_') || segment.startsWith('c_') || segment.startsWith('bg_') || segment.startsWith('blur_') || segment.startsWith('_')) {
+          continue;
+        }
+        // Check if segment ends with a known image extension
+        newUrl += '/' + segment;
+      }
+      if(cleanUrl.includes('http://') || cleanUrl.includes('https://')) {
+        newUrl = cleanUrl.includes('http://') ? cleanUrl.slice(cleanUrl.indexOf('http://')) : cleanUrl.slice(cleanUrl.indexOf('https://'));
+      }
+
+      return {
+        statusCode: 302,
+        headers: {
+          'from-server': 'true',
+          location: newUrl
+        }
+      }
+    }
+
+    if(cleanUrl.includes('-ssr-functions/_ipx/')) {
+      let newUrl = '';
+      const pathSegments = cleanUrl.split('/') // Remove empty segments
+      if(pathSegments.length === 0) {
+        return null;
+      }
+      // Check each segment for file extension
+      newUrl = pathSegments.slice(4).join('/');
+      if(newUrl.includes('http:/') && !newUrl.includes('http://')) {
+        newUrl = newUrl.replace('http:/', 'http://');
+      } else if(newUrl.includes('https:/') && !newUrl.includes('https://')) {
+        newUrl = newUrl.replace('https:/', 'https://');
+      }
+
+      return {
+        statusCode: 302,
+        headers: {
+          'from-server': 'true',
+          location: newUrl
+        }
+      }
+    }
+    
+    // 本地调试寻找文件路径
+    const possiblePaths = [];
+    
+    // Direct file path
+    const directPath = resolve(ASSET_DIR, cleanUrl.startsWith('/') ? cleanUrl.slice(1) : cleanUrl);
+    possiblePaths.push(directPath);
+    
+    // Try each possible path
+    for (const filePath of possiblePaths) {
+      // Security check: ensure file is within asset directory
+      if (!filePath.startsWith(ASSET_DIR)) {
+        continue;
+      }
+      
+      if (existsSync(filePath) && statSync(filePath).isFile()) {
+        const content = readFileSync(filePath);
+        const mimeType = getMimeType(filePath);
+        
+        return {
+          statusCode: 200,
+          headers: {
+            'Content-Type': mimeType,
+            'Content-Length': content.length.toString(),
+            'Cache-Control': 'public, max-age=31536000' // 1 year cache
+          },
+          body: content
+        };
+      }
+    }
+  } catch (error) {
+    console.error('Static file error:', error);
+  }
+  
+  return null;
+}
+
+/**
+ * Lazy load Nitro application
+ */
+let nitroApp = null;
+async function getNitroApp() {
+  if (!nitroApp) {
+    // Set environment variables to prevent automatic server startup
+    process.env.NITRO_PORT = '';
+    process.env.PORT = '';
+    
+    // Set correct static assets path
+    process.env.NITRO_PUBLIC_DIR = ASSET_DIR;
+    
+    const { {{USE_NITRO_APP_SYMBOL}}: useNitroApp } = await import('./chunks/nitro/nitro.mjs');
+    nitroApp = useNitroApp();
+  }
+  return nitroApp;
+}
+
+async function getBody(req) {
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    const body = Buffer.concat(chunks).toString();
+    return body;
+  }
+  return '';
+}
+
+/**
+ * EdgeOne function handler
+ */
+export default async function handler(req, res, context) {
+  try {
+    const url = req.url || '/';
+    const method = req.method || 'GET';
+    const headers = req.headers || new Headers();
+    const body = await getBody(req);
+
+    // First try to handle static assets
+    if (method === 'GET') {
+      const staticResponse = handleStaticFile(url);
+      if (staticResponse) {
+        return new Response(staticResponse.body, {
+          status: staticResponse.statusCode,
+          headers: staticResponse.headers
+        });
+      }
+    }
+
+    // Handle dynamic requests
+    const app = await getNitroApp();
+    
+    try {
+      const response = await app.localCall({
+        url,
+        method,
+        headers,
+        body
+      });
+
+      return new Response(response.body, {
+        status: response.statusCode,
+        headers: response.headers
+      });
+    } catch (nitroError) {
+      // Handle Nitro static file read errors (prerender files not found)
+      // Check error and its cause property (H3Error may wrap actual error in cause)
+      const actualError = nitroError?.cause || nitroError;
+      const errorPath = actualError?.path || nitroError?.path;
+      const errorCode = actualError?.code || nitroError?.code;
+      
+      // If error is due to prerender static file not found, try dynamic rendering
+      if (errorCode === 'ENOENT' && 
+          errorPath && 
+          (errorPath.includes('/assets/') || errorPath.includes('assets/')) &&
+          (errorPath.includes('/index.html') || errorPath.includes('index.html'))) {
+        console.warn(`Prerender file not found: ${errorPath}, falling back to dynamic rendering for ${url}`);
+        
+        // If static file handling has been tried but file not found, should perform dynamic rendering
+        // Nitro should be able to handle dynamic routes, but if it still tries to read static files,
+        // it may be due to configuration issues. We throw an error directly to let user know to build or check configuration
+        throw new Error(`Prerender route ${url} not found. Make sure to run build first or configure routeRules correctly. Original error: ${actualError?.message || nitroError?.message}`);
+      }
+      
+      // Other errors are thrown directly
+      throw nitroError;
+    }
+  } catch (error) {
+    return new Response(`Server Error: ${error.message}`, {
+      status: 500,
+      headers: {
+        'Content-Type': 'text/plain'
+      }
+    });
+  }
+}
+

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

@@ -0,0 +1,212 @@
+// import { createServer } from 'http';
+// import {
+//   createRequestContext,
+//   runWithRequestContext,
+// } from './.edgeone/dist/run/handlers/request-context.cjs';
+// import { 
+//   createEdgeOneNuxtServerHandler,
+//   defaultEdgeOneNuxtConfig 
+// } from './.edgeone/dist/run/handlers/nuxt-server.cjs';
+// import { 
+//   createEdgeOneNuxtCacheHandler 
+// } from './.edgeone/dist/run/handlers/nuxt-cache.cjs';
+
+// // Initialize Nuxt server handler
+// const nuxtServerHandler = createEdgeOneNuxtServerHandler(defaultEdgeOneNuxtConfig);
+
+// async function handleResponse(res, response, passHeaders = {}) {
+//   const startTime = Date.now();
+  
+//   if (!response) {
+//     res.writeHead(404, { 'Content-Type': 'application/json' });
+//     res.end(JSON.stringify({
+//       error: "Not Found",
+//       message: "The requested path does not exist"
+//     }));
+//     console.log(`HandleResponse: 404 Not Found - ${Date.now() - startTime}ms`);
+//     return;
+//   }
+
+//   try {
+//     if (response instanceof Response) {
+//       const headers = Object.fromEntries(response.headers);
+//       Object.assign(headers, passHeaders);
+      
+//       // Handle set-cookie headers properly
+//       if (response.headers.has('set-cookie')) {
+//         const cookieArr = response.headers.getSetCookie();
+//         headers['set-cookie'] = cookieArr;
+//       }
+      
+//       res.writeHead(response.status, headers);
+      
+//       if (response.body) {
+//         const arrayBuffer = await response.arrayBuffer();
+//         res.end(Buffer.from(arrayBuffer));
+//       } else {
+//         res.end();
+//       }
+//     } else {
+//       // Handle non-Response objects
+//       res.writeHead(200, { 'Content-Type': 'application/json', ...passHeaders });
+//       res.end(JSON.stringify(response));
+//     }
+//   } catch (error) {
+//     console.error('Error in handleResponse:', error);
+//     res.writeHead(500, { 'Content-Type': 'application/json' });
+//     res.end(JSON.stringify({
+//       error: "Internal Server Error",
+//       message: error.message
+//     }));
+//   } finally {
+//     console.log(`HandleResponse: ${response?.status || 'unknown'} - ${Date.now() - startTime}ms`);
+//   }
+// }
+
+// // Enable regional blobs for EdgeOne
+// process.env.USE_REGIONAL_BLOBS = 'true';
+
+// export default async function handler(req, context) {
+//   const requestContext = createRequestContext(req, context);
+  
+//   // Initialize cache handler for this request
+//   const cacheHandler = createEdgeOneNuxtCacheHandler({
+//     maxMemoryCacheSize: 50 * 1024 * 1024, // 50MB
+//     revalidateOnStale: true
+//   });
+  
+//   // Add cache handler to request context
+//   requestContext.cacheHandler = cacheHandler;
+
+//   const handlerResponse = await runWithRequestContext(requestContext, async () => {
+//     try {
+//       // Convert Node.js request to Web API Request
+//       const url = new URL(req.url, `http://${req.headers.host}`);
+//       const method = req.method || 'GET';
+      
+//       let body = null;
+//       if (method !== 'GET' && method !== 'HEAD') {
+//         body = createReadableStreamFromRequest(req);
+//       }
+      
+//       const webRequest = new Request(url.toString(), {
+//         method,
+//         headers: req.headers,
+//         body
+//       });
+      
+//       // Handle request with Nuxt server handler
+//       return await nuxtServerHandler.handleRequest(webRequest, requestContext);
+//     } catch (error) {
+//       console.error('Error in Nuxt handler:', error);
+      
+//       return new Response(JSON.stringify({
+//         error: 'Internal Server Error',
+//         message: error.message,
+//         timestamp: new Date().toISOString()
+//       }), {
+//         status: 500,
+//         headers: {
+//           'Content-Type': 'application/json',
+//           'X-Handled-By': 'EdgeOne-Nuxt-Error'
+//         }
+//       });
+//     }
+//   });
+
+//   return handlerResponse;
+// }
+
+// export const config = {
+//   path: '/*',
+//   preferStatic: true,
+// };
+
+// // Development server configuration
+// const port = 9000;
+
+// // Convert Node.js request stream to Web API ReadableStream
+// function createReadableStreamFromRequest(req) {
+//   return new ReadableStream({
+//     start(controller) {
+//       req.on('data', chunk => {
+//         // Convert Buffer to Uint8Array
+//         const uint8Array = new Uint8Array(chunk);
+//         controller.enqueue(uint8Array);
+//       });
+      
+//       req.on('end', () => {
+//         controller.close();
+//       });
+      
+//       req.on('error', error => {
+//         controller.error(error);
+//       });
+//     },
+    
+//     cancel() {
+//       // Clean up resources
+//       req.destroy();
+//     }
+//   });
+// }
+
+// // Development server for local testing
+// // Start development server directly when running the script
+// const server = createServer(async (req, res) => {
+//   try {
+//     const response = await handler(req, { waitUntil: () => {} });
+//     await handleResponse(res, response);
+//   } catch (error) {
+//     console.error('Development server error:', error);
+//     res.writeHead(500, { 'Content-Type': 'application/json' });
+//     res.end(JSON.stringify({
+//       error: 'Development Server Error',
+//       message: error.message
+//     }));
+//   }
+// });
+
+// server.listen(port, () => {
+//   console.log(`Nuxt development server running on http://localhost:${port}`);
+// });
+
+// Ensure Nitro can read import.meta and env like in built index
+globalThis._importMeta_ = { url: import.meta.url, env: process.env };
+
+// Choose port
+process.env.NITRO_PORT = process.env.NITRO_PORT || '9000';
+process.env.PORT = process.env.PORT || process.env.NITRO_PORT;
+
+// Import and execute Nitro server (top-level code starts the server)
+const nitroModule = await import('./chunks/nitro/nitro.mjs');
+
+// Get useNitroApp (your build exports it as `k`)
+const useNitroApp = nitroModule.k || nitroModule.useNitroApp;
+if (!useNitroApp) {
+  console.error('useNitroApp not found in nitro module exports');
+  process.exit(1);
+}
+
+const nitroApp = useNitroApp();
+
+// Request interceptor
+nitroApp.hooks.hook('request', async (event) => {
+  const { req } = event.node;
+  console.log(`📥 [${new Date().toISOString()}] ${req.method} ${req.url}`);
+  console.log('📋 Request Headers:', req.headers);
+  // Example: mark request source
+  req.headers['x-intercepted-by'] = 'custom-hooks';
+});
+
+// Response interceptor
+nitroApp.hooks.hook('beforeResponse', async (event, response) => {
+  const { res } = event.node;
+  console.log(`📤 [${new Date().toISOString()}] Status: ${res.statusCode}`);
+  console.log('📋 Response Headers:', res.getHeaders());
+  // Example: add a custom header
+  res.setHeader('x-intercepted', 'true');
+  return response;
+});
+
+console.log('🔍 Request/Response interception enabled (run-with-hooks)');

package/dist/esm-chunks/chunk-5YBUNNZ4.js

@@ -0,0 +1,81 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/run/headers.ts
+var getHeaderValueArray = (header) => {
+  return header.split(",").map((value) => value.trim()).filter(Boolean);
+};
+var omitHeaderValues = (header, values) => {
+  const headerValues = getHeaderValueArray(header);
+  const filteredValues = headerValues.filter(
+    (value) => !values.some((val) => value.startsWith(val))
+  );
+  return filteredValues.join(", ");
+};
+function setCacheControlFromRequestContext(headers, revalidate) {
+  const cdnCacheControl = (
+    // if we are serving already stale response, instruct edge to not attempt to cache that response
+    headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate, durable" : `s-maxage=${revalidate || 31536e3}, stale-while-revalidate=31536000, durable`
+  );
+  headers.set("eo-cdn-cache-control", cdnCacheControl);
+}
+var setCacheControlHeaders = ({ headers, status }, request, requestContext) => {
+  if (typeof requestContext.routeHandlerRevalidate !== "undefined" && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("eo-cdn-cache-control")) {
+    setCacheControlFromRequestContext(headers, requestContext.routeHandlerRevalidate);
+    return;
+  }
+  if (status === 404) {
+    if (request.url.endsWith(".php")) {
+      headers.set("cache-control", "public, max-age=0, must-revalidate");
+      headers.set("eo-cdn-cache-control", `max-age=31536000, durable`);
+      return;
+    }
+    if (process.env.CACHE_404_PAGE && request.url.endsWith("/404") && ["GET", "HEAD"].includes(request.method)) {
+      setCacheControlFromRequestContext(headers, requestContext.pageHandlerRevalidate);
+      return;
+    }
+  }
+  const cacheControl = headers.get("cache-control");
+  if (cacheControl !== null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("eo-cdn-cache-control")) {
+    const browserCacheControl = omitHeaderValues(cacheControl, [
+      "s-maxage",
+      "stale-while-revalidate"
+    ]);
+    const cdnCacheControl = (
+      // if we are serving already stale response, instruct edge to not attempt to cache that response
+      headers.get("x-nextjs-cache") === "STALE" ? "public, max-age=0, must-revalidate, durable" : [
+        ...getHeaderValueArray(cacheControl).map(
+          (value) => value === "stale-while-revalidate" ? "stale-while-revalidate=31536000" : value
+        ),
+        "durable"
+      ].join(", ")
+    );
+    headers.set("cache-control", browserCacheControl || "public, max-age=0, must-revalidate");
+    headers.set("eo-cdn-cache-control", cdnCacheControl);
+    return;
+  }
+  if (cacheControl === null && ["GET", "HEAD"].includes(request.method) && !headers.has("cdn-cache-control") && !headers.has("eo-cdn-cache-control") && requestContext.usedFsReadForNonFallback && !requestContext.didPagesRouterOnDemandRevalidate) {
+    headers.set("cache-control", "public, max-age=0, must-revalidate");
+    headers.set("eo-cdn-cache-control", `max-age=31536000, durable`);
+  }
+};
+var setCacheTagsHeaders = (headers, requestContext) => {
+  if (!headers.has("cache-control")) {
+    return;
+  }
+};
+var setCacheStatusHeader = (headers, nextCache) => {
+  if (headers.has("x-nextjs-cache")) {
+    headers.delete("x-nextjs-cache");
+  }
+};
+
+export {
+  setCacheControlHeaders,
+  setCacheTagsHeaders,
+  setCacheStatusHeader
+};

package/dist/esm-chunks/chunk-6BT4RYQJ.js

@@ -0,0 +1,43 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+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 __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 __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};