@edgeone/opennextjs-pages 0.0.1

package/dist/build/plugin-context.js

@@ -0,0 +1,367 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_semver
+} from "../esm-chunks/chunk-TLQCAGE2.js";
+import {
+  __toESM
+} from "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/plugin-context.ts
+var import_semver = __toESM(require_semver(), 1);
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join, relative, resolve } from "node:path";
+import { join as posixJoin, relative as posixRelative } from "node:path/posix";
+import { fileURLToPath } from "node:url";
+var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
+var PLUGIN_DIR = join(MODULE_DIR, "../..");
+var DEFAULT_PUBLISH_DIR = ".next";
+var SERVER_HANDLER_NAME = "server-handler";
+var EDGE_HANDLER_NAME = "edgeone-edge-handler";
+var PluginContext = class {
+  edgeoneConfig;
+  pluginName;
+  pluginVersion;
+  utils;
+  constants;
+  packageJSON;
+  /** Absolute path of the next runtime plugin directory */
+  pluginDir = PLUGIN_DIR;
+  serverlessWrapHandler;
+  get relPublishDir() {
+    return this.constants.PUBLISH_DIR ?? join(this.constants.PACKAGE_PATH || "", DEFAULT_PUBLISH_DIR);
+  }
+  /** Temporary directory for stashing the build output */
+  get tempPublishDir() {
+    return this.resolveFromPackagePath(".edgeone/.next");
+  }
+  /** Absolute path of the publish directory */
+  get publishDir() {
+    return resolve(this.relPublishDir);
+  }
+  /**
+   * Relative package path in non monorepo setups this is an empty string
+   * This path is provided by Next.js RequiredServerFiles manifest
+   * @example ''
+   * @example 'apps/my-app'
+   */
+  get relativeAppDir() {
+    return this.requiredServerFiles.relativeAppDir ?? "";
+  }
+  /**
+   * The working directory inside the lambda that is used for monorepos to execute the serverless function
+   */
+  get lambdaWorkingDirectory() {
+    return join("./", this.distDirParent);
+  }
+  /**
+   * Retrieves the root of the `.next/standalone` directory
+   */
+  get standaloneRootDir() {
+    return join(this.publishDir, "standalone");
+  }
+  /**
+   * The resolved relative next dist directory defaults to `.next`,
+   * but can be configured through the next.config.js. For monorepos this will include the packagePath
+   * If we need just the plain dist dir use the `nextDistDir`
+   */
+  get distDir() {
+    const dir = this.buildConfig.distDir ?? DEFAULT_PUBLISH_DIR;
+    return relative(process.cwd(), resolve(this.relativeAppDir, dir));
+  }
+  /** Represents the parent directory of the .next folder or custom distDir */
+  get distDirParent() {
+    return join(this.distDir, "..");
+  }
+  /** The `.next` folder or what the custom dist dir is set to */
+  get nextDistDir() {
+    return relative(this.distDirParent, this.distDir);
+  }
+  /** Retrieves the `.next/standalone/` directory monorepo aware */
+  get standaloneDir() {
+    return join(this.standaloneRootDir, this.distDirParent);
+  }
+  /**
+   * Absolute path of the directory that is published and deployed to the CDN
+   * Will be swapped with the publish directory
+   * `.edgeone/static`
+   */
+  get staticDir() {
+    return this.resolveFromPackagePath(".edgeone/assets");
+  }
+  /**
+   * Absolute path of the directory that will be deployed to the blob store
+   * region aware: `.edgeone/deploy/v1/blobs/deploy`
+   * default: `.edgeone/blobs/deploy`
+   */
+  get blobDir() {
+    if (this.useRegionalBlobs) {
+      return this.resolveFromPackagePath(".edgeone/deploy/v1/blobs/deploy");
+    }
+    return this.resolveFromPackagePath(".edgeone/blobs/deploy");
+  }
+  get buildVersion() {
+    return this.constants.BUILD_VERSION || "v0.0.0";
+  }
+  get useRegionalBlobs() {
+    const REQUIRED_BUILD_VERSION = ">=29.41.5";
+    return (0, import_semver.satisfies)(this.buildVersion, REQUIRED_BUILD_VERSION, { includePrerelease: true });
+  }
+  /**
+   * Absolute path of the directory containing the files for the serverless lambda function
+   * `.edgeone/functions-internal`
+   */
+  get serverFunctionsDir() {
+    return this.resolveFromPackagePath(".edgeone");
+  }
+  /** Absolute path of the server handler */
+  get serverHandlerRootDir() {
+    return join(this.serverFunctionsDir, SERVER_HANDLER_NAME);
+  }
+  get serverHandlerDir() {
+    if (this.relativeAppDir.length === 0) {
+      return this.serverHandlerRootDir;
+    }
+    return join(this.serverHandlerRootDir, this.distDirParent);
+  }
+  get serverHandlerRuntimeModulesDir() {
+    return join(this.serverHandlerDir, ".edgeone");
+  }
+  get nextServerHandler() {
+    if (this.relativeAppDir.length !== 0) {
+      return join(this.lambdaWorkingDirectory, ".edgeone/dist/run/handlers/server.js");
+    }
+    return "./.edgeone/dist/run/handlers/server.js";
+  }
+  /**
+   * Absolute path of the directory containing the files for deno edge functions
+   * `.edgeone/edge-functions`
+   */
+  get edgeFunctionsDir() {
+    return this.resolveFromPackagePath(".edgeone/edge-functions");
+  }
+  /** Absolute path of the edge handler */
+  get edgeHandlerDir() {
+    return join(this.edgeFunctionsDir, EDGE_HANDLER_NAME);
+  }
+  constructor(options) {
+    options = {
+      ...options,
+      functions: {
+        "*": {}
+      },
+      constants: {
+        PUBLISH_DIR: ".next"
+        // BUILD_VERSION: '32.1.4',
+      }
+    };
+    this.constants = options.constants;
+    this.edgeoneConfig = options.edgeoneConfig;
+    this.packageJSON = JSON.parse(readFileSync(join(PLUGIN_DIR, "package.json"), "utf-8"));
+    this.pluginName = this.packageJSON.name;
+    this.pluginVersion = this.packageJSON.version;
+    this.utils = options.utils;
+    this.serverlessWrapHandler = options.serverlessWrapHandler;
+  }
+  /** Resolves a path correctly with mono repository awareness for .edgeone directories mainly  */
+  resolveFromPackagePath(...args) {
+    return resolve(this.constants.PACKAGE_PATH || "", ...args);
+  }
+  /** Resolves a path correctly from site directory */
+  resolveFromSiteDir(...args) {
+    return resolve(this.requiredServerFiles.appDir, ...args);
+  }
+  /** Get the next prerender-manifest.json */
+  async getPrerenderManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "prerender-manifest.json"), "utf-8"));
+  }
+  async getPagesManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "server/pages-manifest.json"), "utf-8"));
+  }
+  // 获取 next api manifest 
+  async getAppPathRoutesManifest() {
+    const manifestPath = join(this.publishDir, "app-path-routes-manifest.json");
+    try {
+      if (!existsSync(manifestPath)) {
+        return {};
+      }
+      return JSON.parse(await readFile(manifestPath, "utf-8"));
+    } catch (error) {
+      return {};
+    }
+  }
+  /**
+   * Uses various heuristics to try to find the .next dir.
+   * Works by looking for BUILD_ID, so requires the site to have been built
+   */
+  findDotNext() {
+    for (const dir of [
+      // The publish directory
+      this.publishDir,
+      // In the root
+      resolve(DEFAULT_PUBLISH_DIR),
+      // The sibling of the publish directory
+      resolve(this.publishDir, "..", DEFAULT_PUBLISH_DIR),
+      // In the package dir
+      resolve(this.constants.PACKAGE_PATH || "", DEFAULT_PUBLISH_DIR)
+    ]) {
+      if (existsSync(join(dir, "BUILD_ID"))) {
+        return dir;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get Next.js middleware config from the build output
+   */
+  async getMiddlewareManifest() {
+    return JSON.parse(
+      await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
+    );
+  }
+  // don't make private as it is handy inside testing to override the config
+  _requiredServerFiles = null;
+  /** Get RequiredServerFiles manifest from build output **/
+  get requiredServerFiles() {
+    if (!this._requiredServerFiles) {
+      let requiredServerFilesJson = join(this.publishDir, "required-server-files.json");
+      if (!existsSync(requiredServerFilesJson)) {
+        const dotNext = this.findDotNext();
+        if (dotNext) {
+          requiredServerFilesJson = join(dotNext, "required-server-files.json");
+        }
+      }
+      this._requiredServerFiles = JSON.parse(
+        readFileSync(requiredServerFilesJson, "utf-8")
+      );
+    }
+    return this._requiredServerFiles;
+  }
+  #exportDetail = null;
+  /** Get metadata when output = export */
+  get exportDetail() {
+    if (this.buildConfig.output !== "export") {
+      return null;
+    }
+    if (!this.#exportDetail) {
+      const detailFile = join(
+        this.requiredServerFiles.appDir,
+        this.buildConfig.distDir,
+        "export-detail.json"
+      );
+      if (!existsSync(detailFile)) {
+        return null;
+      }
+      try {
+        this.#exportDetail = JSON.parse(readFileSync(detailFile, "utf-8"));
+      } catch {
+      }
+    }
+    return this.#exportDetail;
+  }
+  /** Get Next Config from build output **/
+  get buildConfig() {
+    return this.requiredServerFiles.config;
+  }
+  /**
+   * Get Next.js routes manifest from the build output
+   */
+  async getRoutesManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "routes-manifest.json"), "utf-8"));
+  }
+  /**
+   * Get Next.js images manifest from the build output
+   * This handles the image optimization routes for Next.js Image component
+   */
+  async getImagesManifest() {
+    const imagesManifestPath = join(this.publishDir, "images-manifest.json");
+    try {
+      if (!existsSync(imagesManifestPath)) {
+        return {};
+      }
+      return JSON.parse(await readFile(imagesManifestPath, "utf-8"));
+    } catch (error) {
+      return {};
+    }
+  }
+  #nextVersion = void 0;
+  /**
+   * Get Next.js version that was used to build the site
+   */
+  get nextVersion() {
+    if (this.#nextVersion === void 0) {
+      try {
+        const serverHandlerRequire = createRequire(posixJoin(this.standaloneRootDir, ":internal:"));
+        const { version } = serverHandlerRequire("next/package.json");
+        this.#nextVersion = version;
+      } catch {
+        this.#nextVersion = null;
+      }
+    }
+    return this.#nextVersion;
+  }
+  #fallbacks = null;
+  /**
+   * Get an array of localized fallback routes
+   *
+   * Example return value for non-i18n site: `['blog/[slug]']`
+   *
+   * Example return value for i18n site: `['en/blog/[slug]', 'fr/blog/[slug]']`
+   */
+  getFallbacks(prerenderManifest) {
+    if (!this.#fallbacks) {
+      const locales = this.buildConfig.i18n?.locales ?? [""];
+      this.#fallbacks = Object.entries(prerenderManifest.dynamicRoutes).reduce(
+        (fallbacks, [route, meta]) => {
+          if (typeof meta.fallback === "string") {
+            for (const locale of locales) {
+              const localizedRoute = posixJoin(locale, route.replace(/^\/+/g, ""));
+              fallbacks.push(localizedRoute);
+            }
+          }
+          return fallbacks;
+        },
+        []
+      );
+    }
+    return this.#fallbacks;
+  }
+  #fullyStaticHtmlPages = null;
+  /**
+   * Get an array of fully static pages router pages (no `getServerSideProps` or `getStaticProps`).
+   * Those are being served as-is without involving CacheHandler, so we need to keep track of them
+   * to make sure we apply permanent caching headers for responses that use them.
+   */
+  async getFullyStaticHtmlPages() {
+    if (!this.#fullyStaticHtmlPages) {
+      const pagesManifest = JSON.parse(
+        await readFile(join(this.publishDir, "server/pages-manifest.json"), "utf-8")
+      );
+      this.#fullyStaticHtmlPages = Object.values(pagesManifest).filter(
+        (filePath) => (
+          // Limit handling to pages router files (App Router pages should not be included in pages-manifest.json
+          // as they have their own app-paths-manifest.json)
+          filePath.startsWith("pages/") && // Fully static pages will have entries in the pages-manifest.json pointing to .html files.
+          // Pages with data fetching exports will point to .js files.
+          filePath.endsWith(".html")
+        )
+      ).map((filePath) => posixRelative("pages", filePath));
+    }
+    return this.#fullyStaticHtmlPages;
+  }
+  /** Fails a build with a message and an optional error */
+  failBuild(message, error) {
+    return console.error(message);
+  }
+};
+export {
+  EDGE_HANDLER_NAME,
+  PluginContext,
+  SERVER_HANDLER_NAME
+};

package/dist/build/routes.js

@@ -0,0 +1,127 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/build/routes.ts
+import * as fs from "fs";
+import * as path from "path";
+var convertNextRoutePattern = (path2) => {
+  if (!path2.includes("[")) {
+    return path2;
+  }
+  let convertedPath = path2;
+  const optionalCatchAllMatch = path2.match(/\[\[\.\.\.([^\]]+)\]\]/);
+  if (optionalCatchAllMatch) {
+    const paramName = optionalCatchAllMatch[1];
+    convertedPath = convertedPath.replace(/\[\[\.\.\.([^\]]+)\]\]/g, `:${paramName}*?`);
+  }
+  const catchAllMatch = path2.match(/\[\.\.\.([^\]]+)\]/);
+  if (catchAllMatch) {
+    const paramName = catchAllMatch[1];
+    convertedPath = convertedPath.replace(/\[\.\.\.([^\]]+)\]/g, `:${paramName}*`);
+  }
+  const dynamicMatch = path2.match(/\[([^\]]+)\]/);
+  if (dynamicMatch) {
+    const paramName = dynamicMatch[1];
+    convertedPath = convertedPath.replace(/\[([^\]]+)\]/g, `:${paramName}`);
+  }
+  return convertedPath;
+};
+var createRouteMeta = async (ctx) => {
+  const routeMap = {};
+  const manifest = await ctx.getPrerenderManifest();
+  if (manifest?.routes) {
+    for (const [route, routeInfo] of Object.entries(manifest.routes)) {
+      routeMap[route] = {
+        // 提取关键信息到routeMap
+        isStatic: routeInfo.initialRevalidateSeconds === false,
+        initialRevalidateSeconds: routeInfo.initialRevalidateSeconds || void 0,
+        srcRoute: routeInfo.srcRoute || void 0,
+        dataRoute: routeInfo.dataRoute || void 0
+      };
+    }
+  }
+  const pagesManifest = await ctx.getPagesManifest();
+  if (pagesManifest) {
+    for (const [route, filePath] of Object.entries(pagesManifest)) {
+      if (!routeMap[route]) {
+        routeMap[route] = {};
+      }
+      if (filePath.startsWith("pages") && filePath.endsWith(".html")) {
+        routeMap[route].isStatic = true;
+      }
+    }
+  }
+  const appPathRoutesManifest = await ctx.getAppPathRoutesManifest();
+  if (appPathRoutesManifest) {
+    for (const [route, actualRoute] of Object.entries(appPathRoutesManifest)) {
+      if (!routeMap[actualRoute]) {
+        routeMap[actualRoute] = {};
+      }
+    }
+  }
+  const routesManifest = await ctx.getRoutesManifest();
+  if (routesManifest) {
+    const dataRoutes = routesManifest.dataRoutes;
+    for (const { page, dataRouteRegex } of dataRoutes) {
+      routeMap[dataRouteRegex] = {
+        isStatic: routeMap[page]?.isStatic || false
+      };
+    }
+  }
+  const imagesManifest = await ctx.getImagesManifest();
+  if (imagesManifest) {
+    if (imagesManifest.images) {
+      const imageConfig = imagesManifest.images;
+      routeMap[imageConfig.path] = {};
+    }
+  }
+  const convertedRouteMap = {};
+  const pathsToDelete = [];
+  for (const [routePath, routeConfig] of Object.entries(routeMap)) {
+    const convertedPath = convertNextRoutePattern(routePath);
+    if (convertedPath !== routePath) {
+      pathsToDelete.push(routePath);
+      convertedRouteMap[convertedPath] = routeConfig;
+    }
+  }
+  for (const pathToDelete of pathsToDelete) {
+    delete routeMap[pathToDelete];
+  }
+  Object.assign(routeMap, convertedRouteMap);
+  const routesArray = Object.entries(routeMap).map(([path2, config]) => ({
+    path: path2,
+    ...config
+  }));
+  const edgeOneDir = path.join(process.cwd(), ".edgeone");
+  if (!fs.existsSync(edgeOneDir)) {
+    fs.mkdirSync(edgeOneDir, { recursive: true });
+  }
+  const metaFilePath = path.join(edgeOneDir, "meta.json");
+  let existingMetaData = {};
+  if (fs.existsSync(metaFilePath)) {
+    try {
+      const existingContent = fs.readFileSync(metaFilePath, "utf-8");
+      existingMetaData = JSON.parse(existingContent);
+    } catch (error) {
+      console.warn("Failed to parse existing meta.json:", error);
+    }
+  }
+  const mergedMetaData = {
+    ...existingMetaData,
+    nextRoutes: routesArray
+  };
+  fs.writeFileSync(
+    metaFilePath,
+    JSON.stringify(mergedMetaData, null, 2),
+    "utf-8"
+  );
+};
+export {
+  convertNextRoutePattern,
+  createRouteMeta
+};

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

@@ -0,0 +1,210 @@
+import { createServer } from 'http';
+import {
+  createRequestContext,
+  runWithRequestContext,
+} from './{{cwd}}/.edgeone/dist/run/handlers/request-context.cjs'
+import { getTracer } from './{{cwd}}/.edgeone/dist/run/handlers/tracer.cjs'
+import * as serverHandler from './{{cwd}}/.edgeone/dist/run/handlers/server.js'
+
+
+process.chdir('./{{cwd}}')
+
+// Set feature flag for regional blobs
+process.env.USE_REGIONAL_BLOBS = '{{useRegionalBlobs}}'
+
+
+async function handleResponse(res, response, passHeaders = {}) {
+  const startTime = Date.now();
+  
+  if (!response) {
+    res.writeHead(404);
+    res.end(JSON.stringify({
+      error: "Not Found",
+      message: "The requested path does not exist"
+    }));
+    const endTime = Date.now();
+    console.log(`HandleResponse: 404 Not Found - ${endTime - startTime}ms`);
+    return;
+  }
+
+  try {
+    if (response instanceof Response) {
+      const headers = Object.fromEntries(response.headers);
+      Object.assign(headers, passHeaders);
+      if (response.headers.get('eop-client-geo')) {
+        // 删除 eop-client-geo 头部
+        response.headers.delete('eop-client-geo');
+      }
+      
+      // 检查是否是流式响应
+      const isStream = response.body && (
+        response.headers.get('content-type')?.includes('text/event-stream') ||
+        response.headers.get('transfer-encoding')?.includes('chunked') ||
+        response.body instanceof ReadableStream ||
+        typeof response.body.pipe === 'function' ||
+        response.headers.get('x-content-type-stream') === 'true'
+      );
+
+      if (isStream) {
+        // 设置流式响应所需的头部
+        const streamHeaders = {
+          ...headers
+        };
+
+        if (response.headers.get('content-type')?.includes('text/event-stream')) {
+          streamHeaders['Content-Type'] = 'text/event-stream';
+        }
+
+        res.writeHead(response.status, streamHeaders);
+
+        if (typeof response.body.pipe === 'function') {
+          response.body.pipe(res);
+        } else {
+          const reader = response.body.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              
+              if (value instanceof Uint8Array || Buffer.isBuffer(value)) {
+                res.write(value);
+              } else {
+                const chunk = new TextDecoder().decode(value);
+                res.write(chunk);
+              }
+            }
+          } finally {
+            reader.releaseLock();
+            res.end();
+          }
+        }
+      } else {
+        // 普通响应
+        res.writeHead(response.status, headers);
+        const body = await response.text();
+        res.end(body);
+      }
+    } else {
+      // 非 Response 对象，直接返回 JSON
+      res.writeHead(200, {
+        'Content-Type': 'application/json'
+      });
+      res.end(JSON.stringify(response));
+    }
+  } catch (error) {
+    console.error('HandleResponse error', error);
+    // 错误处理
+    res.writeHead(500);
+    res.end(JSON.stringify({
+      error: "Internal Server Error",
+      message: error.message
+    }));
+  } finally {
+    const endTime = Date.now();
+    console.log(`HandleResponse: ${response?.status || 'unknown'} - ${endTime - startTime}ms`);
+  }
+}
+
+
+let cachedHandler
+export default async function eoHandler (req, context) {
+  const requestContext = createRequestContext(req, context)
+  const tracer = getTracer()
+
+  const handlerResponse = await runWithRequestContext(requestContext, () => {
+    return tracer.withActiveSpan('Next.js Server Handler', async (span) => {
+      if (!cachedHandler) {
+        // const { default: handler } = await import('{{nextServerHandler}}')
+        cachedHandler = serverHandler.default
+      }
+      const response = await cachedHandler(req, context, span, requestContext)
+      return response
+    })
+  })
+
+  return handlerResponse
+}
+
+
+export const config = {
+  path: '/*',
+  preferStatic: true,
+};
+
+const port = 9000;
+
+// 实时流转换函数
+function createReadableStreamFromRequest(req) {
+  return new ReadableStream({
+    start(controller) {
+      req.on('data', chunk => {
+        // 将Buffer转换为Uint8Array
+        const uint8Array = new Uint8Array(chunk);
+        controller.enqueue(uint8Array);
+      });
+      
+      req.on('end', () => {
+        controller.close();
+      });
+      
+      req.on('error', error => {
+        controller.error(error);
+      });
+    },
+    
+    cancel() {
+      // 清理资源
+      req.destroy();
+    }
+  });
+}
+
+const server = createServer(async (req, res) => {
+  try {
+    const requestStartTime = Date.now();
+  
+    // 构造 handler 需要的 req 对象（可根据需要扩展）
+    const handlerReq = {
+      ...req,
+      headers: {
+        ...req.headers,
+        'accept-encoding': 'identity',
+      },
+      method: req.method,
+      url: req.url,
+    };
+
+    // 读取 body（如果有）
+    // let body = [];
+    // req.on('data', chunk => body.push(chunk));
+    // await new Promise(resolve => req.on('end', resolve));
+    // if (body.length > 0) {
+    //   handlerReq.body = Buffer.concat(body);
+    // }
+
+    handlerReq.body = createReadableStreamFromRequest(req);
+
+    const response = await eoHandler(handlerReq, {});
+
+    response.headers.set('functions-request-id', req.headers['x-scf-request-id'] || '');
+
+    const requestEndTime = Date.now();
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    console.log(`Request path: ${url.pathname}`);
+    console.log(`Request processing time: ${requestEndTime - requestStartTime}ms`);
+    await handleResponse(res, response, {
+      'functions-request-id': req.headers['x-scf-request-id'] || ''
+    });
+    return;
+  } catch (error) {
+    console.error('SSR Error:', error);
+    res.statusCode = 500;
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.end('<html><body><h1>Error</h1><p>'+error.message+'</p></body></html>');
+  }
+});
+
+server.listen(port, () => {
+  console.log('Server is running on http://localhost:9000');
+});
+