@edgeone/opennextjs-pages 0.0.9 → 0.1.0

package/dist/build/functions/middleware/compiler.js

@@ -2356,10 +2356,17 @@ function transformForEdgeOneRuntime(code) {
     const patchedConstructor = `class ${className} extends ${parentClass}{constructor(${paramName}){super(${paramName}.input,${paramName}.init),this.sourcePage=${paramName}.page;var __k="__edgeone_nextInternal",__self=this;if(this[__k]){Object.defineProperty(this,"nextUrl",{get:function(){return __self[__k]?__self[__k].nextUrl:undefined},enumerable:true,configurable:true});Object.defineProperty(this,"cookies",{get:function(){return __self[__k]?__self[__k].cookies:undefined},enumerable:true,configurable:true})}}`;
     return patchedConstructor;
   });
-  const baseClassInternalAssignPattern = /this\[(\w+)\]\s*=\s*\{\s*cookies\s*:\s*new\s+\w+\.RequestCookies\s*\(\s*this\.headers\s*\)\s*,\s*nextUrl\s*:\s*(\w+)\s*,\s*url\s*:\s*\2\.toString\s*\(\s*\)\s*\}/g;
-  transformed = transformed.replace(baseClassInternalAssignPattern, (match, internalVar, _nextUrlVar) => {
+  const baseClassInternalAssignPattern = /this\[(\w+)\]\s*=\s*\{\s*cookies\s*:\s*new\s+([\w.]+)\.RequestCookies\s*\(\s*this\.headers\s*\)\s*,\s*nextUrl\s*:\s*(\w+)\s*,\s*url\s*:\s*\3\.toString\s*\(\s*\)\s*\}/g;
+  transformed = transformed.replace(baseClassInternalAssignPattern, (match, internalVar, cookiesModule, nextUrlVar) => {
     transformCount++;
-    const patchedAssignment = match + `;var __self=this;Object.defineProperty(this,"nextUrl",{get:function(){return __self[${internalVar}]?__self[${internalVar}].nextUrl:undefined},enumerable:true,configurable:true});Object.defineProperty(this,"cookies",{get:function(){return __self[${internalVar}]?__self[${internalVar}].cookies:undefined},enumerable:true,configurable:true})`;
+    const patchedAssignment = `Object.defineProperty(this,${internalVar},{value:{cookies:new ${cookiesModule}.RequestCookies(this.headers),nextUrl:${nextUrlVar},url:${nextUrlVar}.toString()},writable:true,enumerable:true,configurable:true});var __self=this;Object.defineProperty(this,"nextUrl",{get:function(){return __self[${internalVar}]?__self[${internalVar}].nextUrl:undefined},enumerable:true,configurable:true});Object.defineProperty(this,"cookies",{get:function(){return __self[${internalVar}]?__self[${internalVar}].cookies:undefined},enumerable:true,configurable:true})`;
+    return patchedAssignment;
+  });
+  const baseClassInternalAssignPatternMultiline = /this\[(\w+)\]\s*=\s*\{\s*cookies\s*:\s*new\s+[\w.]+\.RequestCookies\s*\(\s*this\.headers\s*\)\s*,\s*geo\s*:\s*[^,]+,\s*ip\s*:\s*[^,]+,\s*nextUrl\s*,\s*url\s*:\s*[^}]+\}/g;
+  transformed = transformed.replace(baseClassInternalAssignPatternMultiline, (match, internalVar) => {
+    transformCount++;
+    const objContent = match.replace(/^this\[\w+\]\s*=\s*/, "");
+    const patchedAssignment = `Object.defineProperty(this,${internalVar},{value:${objContent},writable:true,enumerable:true,configurable:true});var __self=this;Object.defineProperty(this,"nextUrl",{get:function(){return __self[${internalVar}]?__self[${internalVar}].nextUrl:undefined},enumerable:true,configurable:true});Object.defineProperty(this,"cookies",{get:function(){return __self[${internalVar}]?__self[${internalVar}].cookies:undefined},enumerable:true,configurable:true});Object.defineProperty(this,"geo",{get:function(){return __self[${internalVar}]?__self[${internalVar}].geo:undefined},enumerable:true,configurable:true});Object.defineProperty(this,"ip",{get:function(){return __self[${internalVar}]?__self[${internalVar}].ip:undefined},enumerable:true,configurable:true})`;
     return patchedAssignment;
   });
   const responseInternalAssignPattern = /this\[(\w+)\]\s*=\s*\{\s*cookies\s*:\s*(\w+)\s*,\s*url\s*:\s*([^}]+)\}/g;
@@ -2961,6 +2968,230 @@ function getExternalMock(id) {
     };
   }
   
+  // OpenTelemetry API mock - Next.js 16+ \u4F7F\u7528 OpenTelemetry \u8FDB\u884C\u8FFD\u8E2A
+  if (id.includes('opentelemetry') || id.includes('@opentelemetry/api')) {
+    // createContextKey - \u521B\u5EFA\u4E0A\u4E0B\u6587\u952E
+    const createContextKey = (name) => Symbol.for(name);
+    
+    // ROOT_CONTEXT - \u6839\u4E0A\u4E0B\u6587
+    class Context {
+      constructor(parentContext) {
+        this._currentContext = parentContext ? new Map(parentContext._currentContext) : new Map();
+      }
+      getValue(key) { return this._currentContext.get(key); }
+      setValue(key, value) {
+        const ctx = new Context(this);
+        ctx._currentContext.set(key, value);
+        return ctx;
+      }
+      deleteValue(key) {
+        const ctx = new Context(this);
+        ctx._currentContext.delete(key);
+        return ctx;
+      }
+    }
+    const ROOT_CONTEXT = new Context();
+    
+    // NoopContextManager - \u7A7A\u64CD\u4F5C\u4E0A\u4E0B\u6587\u7BA1\u7406\u5668
+    class NoopContextManager {
+      active() { return ROOT_CONTEXT; }
+      with(context, fn, thisArg, ...args) { return fn.call(thisArg, ...args); }
+      bind(context, target) { return target; }
+      enable() { return this; }
+      disable() { return this; }
+    }
+    
+    // NoopSpan - \u7A7A\u64CD\u4F5C Span
+    class NoopSpan {
+      constructor() {}
+      spanContext() { return { traceId: '', spanId: '', traceFlags: 0 }; }
+      setAttribute() { return this; }
+      setAttributes() { return this; }
+      addEvent() { return this; }
+      setStatus() { return this; }
+      updateName() { return this; }
+      end() {}
+      isRecording() { return false; }
+      recordException() {}
+    }
+    
+    // NoopTracer - \u7A7A\u64CD\u4F5C\u8FFD\u8E2A\u5668
+    class NoopTracer {
+      startSpan() { return new NoopSpan(); }
+      startActiveSpan(name, ...args) {
+        const span = new NoopSpan();
+        const fn = args[args.length - 1];
+        if (typeof fn === 'function') {
+          return fn(span);
+        }
+        return span;
+      }
+    }
+    
+    // NoopTracerProvider - \u7A7A\u64CD\u4F5C\u8FFD\u8E2A\u5668\u63D0\u4F9B\u8005
+    class NoopTracerProvider {
+      getTracer() { return new NoopTracer(); }
+    }
+    
+    // NoopMeter - \u7A7A\u64CD\u4F5C\u8BA1\u91CF\u5668
+    class NoopMeter {
+      createCounter() { return { add: () => {} }; }
+      createHistogram() { return { record: () => {} }; }
+      createUpDownCounter() { return { add: () => {} }; }
+      createObservableGauge() { return { addCallback: () => {} }; }
+      createObservableCounter() { return { addCallback: () => {} }; }
+      createObservableUpDownCounter() { return { addCallback: () => {} }; }
+    }
+    
+    // NoopMeterProvider - \u7A7A\u64CD\u4F5C\u8BA1\u91CF\u5668\u63D0\u4F9B\u8005
+    class NoopMeterProvider {
+      getMeter() { return new NoopMeter(); }
+    }
+    
+    // DiagLogLevel \u679A\u4E3E
+    const DiagLogLevel = {
+      NONE: 0,
+      ERROR: 30,
+      WARN: 50,
+      INFO: 60,
+      DEBUG: 70,
+      VERBOSE: 80,
+      ALL: 9999
+    };
+    
+    // DiagConsoleLogger - \u63A7\u5236\u53F0\u8BCA\u65AD\u65E5\u5FD7\u8BB0\u5F55\u5668
+    class DiagConsoleLogger {
+      error(...args) { console.error('[OTel]', ...args); }
+      warn(...args) { console.warn('[OTel]', ...args); }
+      info(...args) { console.info('[OTel]', ...args); }
+      debug(...args) { console.debug('[OTel]', ...args); }
+      verbose(...args) { console.log('[OTel]', ...args); }
+    }
+    
+    // API \u5355\u4F8B
+    const contextAPI = {
+      active: () => ROOT_CONTEXT,
+      with: (ctx, fn, thisArg, ...args) => fn.call(thisArg, ...args),
+      bind: (ctx, target) => target,
+      setGlobalContextManager: () => true,
+      disable: () => {}
+    };
+    
+    const traceAPI = {
+      getTracer: () => new NoopTracer(),
+      getTracerProvider: () => new NoopTracerProvider(),
+      setGlobalTracerProvider: () => new NoopTracerProvider(),
+      getSpan: () => undefined,
+      getActiveSpan: () => undefined,
+      getSpanContext: () => undefined,  // \u83B7\u53D6 span \u4E0A\u4E0B\u6587
+      setSpan: (ctx) => ctx,
+      setSpanContext: (ctx) => ctx,  // \u8BBE\u7F6E span \u4E0A\u4E0B\u6587
+      deleteSpan: (ctx) => ctx,
+      isSpanContextValid: () => false,
+      wrapSpanContext: (spanContext) => new NoopSpan()
+    };
+    
+    const metricsAPI = {
+      getMeter: () => new NoopMeter(),
+      getMeterProvider: () => new NoopMeterProvider(),
+      setGlobalMeterProvider: () => new NoopMeterProvider()
+    };
+    
+    const propagationAPI = {
+      inject: () => {},
+      extract: (ctx) => ctx,
+      fields: () => [],
+      setGlobalPropagator: () => true,
+      createBaggage: () => ({
+        getEntry: () => undefined,
+        getAllEntries: () => [],
+        setEntry: () => ({}),
+        removeEntry: () => ({}),
+        clear: () => ({})
+      }),
+      getBaggage: () => undefined,
+      setBaggage: (ctx) => ctx,
+      deleteBaggage: (ctx) => ctx,
+      getActiveBaggage: () => undefined
+    };
+    
+    const diagAPI = {
+      setLogger: () => {},
+      disable: () => {},
+      createComponentLogger: () => new DiagConsoleLogger(),
+      verbose: () => {},
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {}
+    };
+    
+    // \u5B8C\u6574\u7684 OpenTelemetry API mock
+    const result = {
+      // \u4E0A\u4E0B\u6587
+      createContextKey,
+      ROOT_CONTEXT,
+      Context,
+      context: contextAPI,
+      ContextAPI: { getInstance: () => contextAPI },
+      NoopContextManager,
+      
+      // \u8FFD\u8E2A
+      trace: traceAPI,
+      TraceAPI: { getInstance: () => traceAPI },
+      SpanKind: { INTERNAL: 0, SERVER: 1, CLIENT: 2, PRODUCER: 3, CONSUMER: 4 },
+      SpanStatusCode: { UNSET: 0, OK: 1, ERROR: 2 },
+      TraceFlags: { NONE: 0, SAMPLED: 1 },
+      isSpanContextValid: () => false,
+      isValidTraceId: () => false,
+      isValidSpanId: () => false,
+      INVALID_SPANID: '',
+      INVALID_TRACEID: '',
+      INVALID_SPAN_CONTEXT: { traceId: '', spanId: '', traceFlags: 0 },
+      NoopTracer,
+      NoopTracerProvider,
+      NoopSpan,
+      
+      // \u8BA1\u91CF
+      metrics: metricsAPI,
+      MetricsAPI: { getInstance: () => metricsAPI },
+      ValueType: { INT: 0, DOUBLE: 1 },
+      NoopMeter,
+      NoopMeterProvider,
+      
+      // \u4F20\u64AD
+      propagation: propagationAPI,
+      PropagationAPI: { getInstance: () => propagationAPI },
+      
+      // \u8BCA\u65AD
+      diag: diagAPI,
+      DiagAPI: { getInstance: () => diagAPI },
+      DiagLogLevel,
+      DiagConsoleLogger,
+      
+      // Baggage
+      baggageEntryMetadataFromString: () => ({ toString: () => '' }),
+      createBaggage: () => ({
+        getEntry: () => undefined,
+        getAllEntries: () => [],
+        setEntry: () => ({}),
+        removeEntry: () => ({}),
+        clear: () => ({})
+      }),
+      
+      // \u9ED8\u8BA4\u5BFC\u51FA
+      default: {
+        context: contextAPI,
+        trace: traceAPI,
+        metrics: metricsAPI,
+        propagation: propagationAPI,
+        diag: diagAPI
+      }
+    };
+    Object.defineProperty(result, '__esModule', { value: true });
+    return result;
+  }
+  
   // \u901A\u7528 mock
   const result = {};
   Object.defineProperty(result, '__esModule', { value: true });

package/dist/build/functions/middleware/middleware.js

@@ -32,9 +32,8 @@ var compileMiddleware = async (ctx) => {
     }
   }
   if (!middlewareFilePath) {
-    console.error("[Middleware Compiler] Could not find middleware.js in any of the expected locations:");
-    possiblePaths.forEach((p) => console.error("  -", p));
-    throw new Error("middleware.js not found");
+    console.log("[Middleware Compiler] No middleware.js found, skipping middleware compilation.");
+    return null;
   }
   const result = await compile(middlewareFilePath, {
     env: { DEBUG: "true" }

package/dist/build/functions/middleware/wrapper.js

@@ -292,48 +292,36 @@ async function executeMiddleware({request}) {
   // \u83B7\u53D6 middleware \u51FD\u6570
   const middlewareFn = await getMiddleware();
   
-  // \u6784\u9020 Next.js middleware \u671F\u671B\u7684\u8BF7\u6C42\u683C\u5F0F
-  // \u6CE8\u610F\uFF1Aheaders \u5FC5\u987B\u662F Headers \u5B9E\u4F8B\uFF0C\u56E0\u4E3A\u7F16\u8BD1\u540E\u7684\u4EE3\u7801\u4F1A\u8C03\u7528 headers.forEach()
-  const headersInstance = new Headers(request.headers);
+  // \u5C06\u539F\u59CB Headers \u8F6C\u6362\u4E3A\u666E\u901A\u5BF9\u8C61\u683C\u5F0F
+  // Next.js adapter \u5185\u90E8\u7684 fromNodeOutgoingHttpHeaders \u671F\u671B\u5BF9\u8C61\u683C\u5F0F
+  const headersObject = {};
+  request.headers.forEach((value, key) => {
+    headersObject[key] = value;
+  });
   
-  const middlewareRequest = {
+  // \u6784\u9020 Next.js middleware adapter \u671F\u671B\u7684\u53C2\u6570\u683C\u5F0F
+  // \u53C2\u8003 Next.js \u6E90\u7801\u4E2D\u7684 adapter \u51FD\u6570
+  const middlewareParams = {
     request: {
       url: request.url,
       method: request.method,
-      headers: headersInstance,  // \u5FC5\u987B\u662F Headers \u5B9E\u4F8B\uFF0C\u652F\u6301 forEach
+      headers: headersObject,
       body: request.body,
       nextConfig: {
         basePath: '',
         i18n: null,
         trailingSlash: false
       },
-      signal: request.signal || null,
-      waitUntil: (promise) => {}
+      geo: {},
+      ip: request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip') || '',
+      signal: request.signal || null
     },
     page: '/',
-    waitUntil: (promise) => {},
-    bypassNextUrl: false,
-    // \u6DFB\u52A0 rewrite \u65B9\u6CD5 - \u7F16\u8BD1\u540E\u7684 middleware \u9700\u8981\u8C03\u7528\u6B64\u65B9\u6CD5
-    rewrite: (url) => {
-      const headers = new Headers();
-      headers.set("x-middleware-rewrite", typeof url === 'string' ? url : url.toString());
-      return new Response(null, { headers });
-    },
-    // \u6DFB\u52A0 redirect \u65B9\u6CD5
-    redirect: (url, status = 307) => {
-      return new Response(null, {
-        status,
-        headers: { Location: typeof url === 'string' ? url : url.toString() }
-      });
-    },
-    // \u6DFB\u52A0 next \u65B9\u6CD5
-    next: () => {
-      return new Response(null, { headers: { 'x-middleware-next': '1' } });
-    },
-    IncrementalCache: null
+    // \u6DFB\u52A0 waitUntil \u65B9\u6CD5
+    waitUntil: (promise) => {}
   };
 
-  const result = await middlewareFn(middlewareRequest);
+  const result = await middlewareFn(middlewareParams);
 
   // Webpack \u6A21\u5F0F\u8FD4\u56DE\u7684\u662F { response: Response, waitUntil: {} } \u683C\u5F0F
   // \u9700\u8981\u63D0\u53D6\u5B9E\u9645\u7684 Response \u5BF9\u8C61

package/dist/build/functions/server.js

@@ -100,6 +100,8 @@ var getHandlerFile = async (ctx) => {
   };
   if (ctx.relativeAppDir.length !== 0) {
     const template2 = await readFile(join(templatesDir, "handler-monorepo.tmpl.js"), "utf-8");
+    console.log("ctx.lambdaWorkingDirectory", ctx.lambdaWorkingDirectory);
+    console.log("ctx.nextServerHandler", ctx.nextServerHandler);
     templateVariables["{{cwd}}"] = posixJoin(ctx.lambdaWorkingDirectory);
     templateVariables["{{nextServerHandler}}"] = posixJoin(ctx.nextServerHandler);
     return applyTemplateVariables(template2, templateVariables);

package/dist/build/routes.js

@@ -9,6 +9,105 @@ import "../esm-chunks/chunk-6BT4RYQJ.js";
 // src/build/routes.ts
 import * as fs from "fs";
 import * as path from "path";
+function isRE2Compatible(regexSource) {
+  const unsupported = [
+    /\(\?[=!<]/,
+    // 断言（前瞻、后顾）
+    /\(\?>/,
+    // 原子组
+    /\\(\d+)/,
+    // 反向引用 \1 \2
+    /\(\?\(/
+    // 条件表达式
+  ];
+  return !unsupported.some((r) => r.test(regexSource));
+}
+async function getMiddlewareConfig(ctx) {
+  try {
+    const manifest = await ctx.getMiddlewareManifest();
+    if (manifest && manifest.middleware && manifest.middleware["/"]) {
+      const middlewareInfo = manifest.middleware["/"];
+      const matchers = middlewareInfo.matchers || [];
+      const normalizedMatchers = matchers.map((m) => ({
+        source: m.originalSource || "/:path*",
+        regex: m.regexp
+      }));
+      const hasIncompatibleRegex = normalizedMatchers.some(
+        (item) => item.regex && !isRE2Compatible(item.regex)
+      );
+      if (hasIncompatibleRegex) {
+        return {
+          runtime: "edge",
+          matcher: [{ source: "/:path*" }]
+        };
+      }
+      return {
+        runtime: "edge",
+        matcher: normalizedMatchers.map((item) => ({ source: item.source }))
+      };
+    }
+    const possibleFunctionsConfigPaths = [
+      path.join(process.cwd(), ".next/server/functions-config-manifest.json"),
+      path.join(ctx.distDir, "server/functions-config-manifest.json")
+    ];
+    let functionsConfigPath = "";
+    for (const p of possibleFunctionsConfigPaths) {
+      if (fs.existsSync(p)) {
+        functionsConfigPath = p;
+        break;
+      }
+    }
+    if (functionsConfigPath) {
+      const functionsConfig = JSON.parse(fs.readFileSync(functionsConfigPath, "utf-8"));
+      const middlewareConfig = functionsConfig?.functions?.["/_middleware"];
+      if (middlewareConfig && middlewareConfig.matchers) {
+        const matchers = middlewareConfig.matchers;
+        const normalizedMatchers = matchers.map((m) => ({
+          source: m.originalSource || "/:path*",
+          regex: m.regexp
+        }));
+        const hasIncompatibleRegex = normalizedMatchers.some(
+          (item) => item.regex && !isRE2Compatible(item.regex)
+        );
+        if (hasIncompatibleRegex) {
+          return {
+            runtime: middlewareConfig.runtime || "edge",
+            matcher: [{ source: "/:path*" }]
+          };
+        }
+        return {
+          runtime: middlewareConfig.runtime || "edge",
+          matcher: normalizedMatchers.map((item) => ({ source: item.source }))
+        };
+      }
+    }
+    return null;
+  } catch (error) {
+    console.log("[Middleware] Failed to read middleware config:", error);
+    return null;
+  }
+}
+function updateEdgeFunctionsMetaJson(middlewareConfig) {
+  const metaJsonPath = path.join(process.cwd(), ".edgeone/edge-functions/meta.json");
+  let meta = { routes: [] };
+  if (fs.existsSync(metaJsonPath)) {
+    try {
+      const content = fs.readFileSync(metaJsonPath, "utf-8");
+      meta = JSON.parse(content);
+    } catch (error) {
+      console.log("[Middleware] Failed to parse existing meta.json, creating new one");
+    }
+  }
+  if (middlewareConfig) {
+    meta.middleware = middlewareConfig;
+    console.log("[Middleware] Updated meta.json with middleware config:", JSON.stringify(middlewareConfig.matcher));
+  }
+  const edgeFunctionsDir = path.dirname(metaJsonPath);
+  if (!fs.existsSync(edgeFunctionsDir)) {
+    fs.mkdirSync(edgeFunctionsDir, { recursive: true });
+  }
+  fs.writeFileSync(metaJsonPath, JSON.stringify(meta, null, 2), "utf-8");
+}
 var convertNextRoutePattern = (path2) => {
   if (!path2.includes("[")) {
     return path2;
@@ -97,7 +196,7 @@ var createRouteMeta = async (ctx) => {
     path: path2,
     ...config
   }));
-  const serverHandlerDir = ctx.serverHandlerDir;
+  const serverHandlerDir = ctx.serverHandlerRootDir;
   if (!fs.existsSync(serverHandlerDir)) {
     fs.mkdirSync(serverHandlerDir, { recursive: true });
   }
@@ -110,6 +209,8 @@ var createRouteMeta = async (ctx) => {
     JSON.stringify(metaData, null, 2),
     "utf-8"
   );
+  const middlewareConfig = await getMiddlewareConfig(ctx);
+  updateEdgeFunctionsMetaJson(middlewareConfig);
 };
 export {
   convertNextRoutePattern,

package/dist/index.js

@@ -36,13 +36,14 @@ var onBuild = async (options) => {
     // copyStaticAssets(ctx),
     copyStaticContent(ctx),
     copyPrerenderedContent(ctx),
-    createServerHandler(ctx),
-    createRouteMeta(ctx)
+    createServerHandler(ctx)
   ]);
+  await createRouteMeta(ctx);
 };
 var onPostBuild = async (options) => {
+  console.log("onPostBuild");
   const ctx = new PluginContext(options);
-  compileMiddleware(ctx);
+  await compileMiddleware(ctx);
 };
 export {
   onBuild,

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

@@ -28,7 +28,7 @@ module.exports = __toCommonJS(tags_handler_exports);
 
 // package.json
 var name = "@edgeone/opennextjs-pages";
-var version = "0.0.9";
+var version = "0.1.0";
 
 // src/run/handlers/tags-handler.cts
 var import_request_context = require("./request-context.cjs");

package/package.json

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