@edgeone/nuxt-pages 1.0.0

package/dist/run/handlers/nuxt-cache.cjs

@@ -0,0 +1,200 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/nuxt-cache.cts
+var nuxt_cache_exports = {};
+__export(nuxt_cache_exports, {
+  EdgeOneNuxtCacheHandler: () => EdgeOneNuxtCacheHandler,
+  createEdgeOneNuxtCacheHandler: () => createEdgeOneNuxtCacheHandler
+});
+module.exports = __toCommonJS(nuxt_cache_exports);
+
+// src/run/handlers/request-context.cts
+var import_node_async_hooks = require("node:async_hooks");
+
+// node_modules/@netlify/functions/dist/internal.js
+var import_process = require("process");
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (import_process.env.NETLIFY_DEV && !import_process.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+      return;
+    }
+    logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    if (this.logLevel > 2) {
+      return;
+    }
+    this.doLog(console.log, message);
+  }
+  debug(message) {
+    if (this.logLevel > 1) {
+      return;
+    }
+    this.doLog(console.debug, message);
+  }
+  error(message) {
+    if (this.logLevel > 3) {
+      return;
+    }
+    this.doLog(console.error, message);
+  }
+  withLogLevel(level) {
+    return new _SystemLogger(this.fields, level);
+  }
+  withFields(fields) {
+    return new _SystemLogger(
+      {
+        ...this.fields,
+        ...fields
+      },
+      this.logLevel
+    );
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+};
+var systemLogger = new SystemLogger();
+
+// src/run/handlers/request-context.cts
+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;
+var requestContextAsyncLocalStorage;
+function getRequestContextAsyncLocalStorage() {
+  if (requestContextAsyncLocalStorage) {
+    return requestContextAsyncLocalStorage;
+  }
+  if (extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY]) {
+    return extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY];
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  requestContextAsyncLocalStorage = storage;
+  extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY] = storage;
+  return storage;
+}
+var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
+function getLogger() {
+  return getRequestContext()?.logger ?? systemLogger;
+}
+
+// src/run/handlers/nuxt-cache.cts
+var EdgeOneNuxtCacheHandler = class {
+  constructor(context) {
+    this.context = context;
+  }
+  memoryCache = /* @__PURE__ */ new Map();
+  /**
+   * Get cached value by key
+   */
+  async get(key, ctx) {
+    const logger = getLogger();
+    try {
+      const memoryEntry = this.memoryCache.get(key);
+      if (memoryEntry && memoryEntry.expires > Date.now()) {
+        return memoryEntry.value;
+      }
+      return null;
+    } catch (error) {
+      logger.withError(error).error("Error getting cache value");
+      return null;
+    }
+  }
+  /**
+   * Set cached value by key
+   */
+  async set(key, data, ctx) {
+    const logger = getLogger();
+    try {
+      let ttl = 3600;
+      if (ctx?.revalidate && typeof ctx.revalidate === "number") {
+        ttl = ctx.revalidate;
+      } else if ("revalidate" in data && typeof data.revalidate === "number") {
+        ttl = data.revalidate;
+      }
+      this.memoryCache.set(key, {
+        value: data,
+        expires: Date.now() + ttl * 1e3
+      });
+    } catch (error) {
+      logger.withError(error).error("Error setting cache value");
+      throw error;
+    }
+  }
+  /**
+   * Revalidate cache entries by tag
+   */
+  async revalidateTag(tag) {
+    const logger = getLogger();
+    try {
+      for (const [key, entry] of this.memoryCache.entries()) {
+        if (this.hasTag(entry.value, tag)) {
+          this.memoryCache.delete(key);
+        }
+      }
+      logger.log(`Revalidated cache tag: ${tag}`);
+    } catch (error) {
+      logger.withError(error).error("Error revalidating cache tag");
+      throw error;
+    }
+  }
+  /**
+   * Get TTL from cache value
+   */
+  getTTL(value) {
+    if ("revalidate" in value && typeof value.revalidate === "number") {
+      return value.revalidate;
+    }
+    return 3600;
+  }
+  /**
+   * Check if cache value has specific tag
+   */
+  hasTag(value, tag) {
+    if ("tags" in value && Array.isArray(value.tags)) {
+      return value.tags.includes(tag);
+    }
+    return false;
+  }
+};
+function createEdgeOneNuxtCacheHandler(context) {
+  return new EdgeOneNuxtCacheHandler(context);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EdgeOneNuxtCacheHandler,
+  createEdgeOneNuxtCacheHandler
+});

package/dist/run/handlers/nuxt-server.js

@@ -0,0 +1,156 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import "../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/run/handlers/nuxt-server.ts
+var defaultEdgeOneNuxtConfig = {
+  // Nuxt specific configuration
+  ssr: true,
+  nitro: {
+    preset: "node-server",
+    storage: {}
+  },
+  experimental: {
+    payloadExtraction: false
+  },
+  // EdgeOne specific settings
+  useRegionalBlobs: true,
+  cacheControl: {
+    maxAge: 3600,
+    staleWhileRevalidate: 86400
+  }
+};
+function createH3EventFromRequest(request) {
+  const url = new URL(request.url);
+  const mockReq = {
+    method: request.method,
+    url: url.pathname + url.search,
+    headers: Object.fromEntries(request.headers.entries()),
+    body: request.body
+  };
+  const mockRes = {
+    writeHead: () => {
+    },
+    write: () => {
+    },
+    end: () => {
+    },
+    writableEnded: false,
+    headersSent: false,
+    statusCode: 200,
+    statusMessage: "OK",
+    _headers: {},
+    setHeader: function(name, value) {
+      this._headers[name.toLowerCase()] = value;
+    },
+    getHeader: function(name) {
+      return this._headers[name.toLowerCase()];
+    },
+    removeHeader: function(name) {
+      delete this._headers[name.toLowerCase()];
+    }
+  };
+  const event = {
+    __is_event__: true,
+    node: { req: mockReq, res: mockRes },
+    context: {},
+    _method: void 0,
+    _path: void 0,
+    _headers: void 0,
+    _requestBody: void 0,
+    _handled: false,
+    _onBeforeResponseCalled: void 0,
+    _onAfterResponseCalled: void 0,
+    get method() {
+      if (!this._method) {
+        this._method = (this.node.req.method || "GET").toUpperCase();
+      }
+      return this._method;
+    },
+    get path() {
+      return this._path || this.node.req.url || "/";
+    },
+    get headers() {
+      if (!this._headers) {
+        this._headers = this._normalizeNodeHeaders(this.node.req.headers);
+      }
+      return this._headers;
+    },
+    get handled() {
+      return this._handled || this.node.res.writableEnded || this.node.res.headersSent;
+    },
+    _normalizeNodeHeaders(nodeHeaders) {
+      const headers = new Headers();
+      for (const [name, value] of Object.entries(nodeHeaders)) {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            headers.append(name, item);
+          }
+        } else if (value) {
+          headers.set(name, value);
+        }
+      }
+      return headers;
+    },
+    toString() {
+      return `[${this.method}] ${this.path}`;
+    },
+    toJSON() {
+      return this.toString();
+    }
+  };
+  return event;
+}
+var EdgeOneNuxtServerHandler = class {
+  nuxtHandler = null;
+  config;
+  nuxtImportPromise;
+  constructor(config = defaultEdgeOneNuxtConfig) {
+    this.config = { ...defaultEdgeOneNuxtConfig, ...config };
+    this.nuxtImportPromise = import(process.cwd() + "/app/.output/server/index.mjs");
+  }
+  async initializeNuxtServer() {
+    if (!this.nuxtHandler) {
+      try {
+        const nuxtApp = await this.nuxtImportPromise;
+        this.nuxtHandler = nuxtApp.default;
+      } catch (error) {
+        console.error("Failed to initialize Nuxt server:", error);
+        throw error;
+      }
+    }
+  }
+  async handleRequest(request) {
+    try {
+      await this.initializeNuxtServer();
+      const event = createH3EventFromRequest(request);
+      const response = await this.nuxtHandler(event);
+      return response;
+    } catch (error) {
+      console.error("Nuxt handler error:", error);
+      return new Response("Internal Server Error", {
+        status: 500,
+        headers: {
+          "Content-Type": "text/plain"
+        }
+      });
+    }
+  }
+};
+function createEdgeOneNuxtServerHandler(config = defaultEdgeOneNuxtConfig) {
+  return new EdgeOneNuxtServerHandler(config);
+}
+var nuxt_server_default = async (request) => {
+  const handler = createEdgeOneNuxtServerHandler();
+  return handler.handleRequest(request);
+};
+export {
+  EdgeOneNuxtServerHandler,
+  createEdgeOneNuxtServerHandler,
+  nuxt_server_default as default,
+  defaultEdgeOneNuxtConfig
+};

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

@@ -0,0 +1,148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/run/handlers/request-context.cts
+var request_context_exports = {};
+__export(request_context_exports, {
+  createRequestContext: () => createRequestContext,
+  getLogger: () => getLogger,
+  getRequestContext: () => getRequestContext,
+  runWithRequestContext: () => runWithRequestContext
+});
+module.exports = __toCommonJS(request_context_exports);
+var import_node_async_hooks = require("node:async_hooks");
+
+// node_modules/@netlify/functions/dist/internal.js
+var import_process = require("process");
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 1] = "Debug";
+  LogLevel2[LogLevel2["Log"] = 2] = "Log";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  return LogLevel2;
+})(LogLevel || {});
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (import_process.env.NETLIFY_DEV && !import_process.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+      return;
+    }
+    logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    if (this.logLevel > 2) {
+      return;
+    }
+    this.doLog(console.log, message);
+  }
+  debug(message) {
+    if (this.logLevel > 1) {
+      return;
+    }
+    this.doLog(console.debug, message);
+  }
+  error(message) {
+    if (this.logLevel > 3) {
+      return;
+    }
+    this.doLog(console.error, message);
+  }
+  withLogLevel(level) {
+    return new _SystemLogger(this.fields, level);
+  }
+  withFields(fields) {
+    return new _SystemLogger(
+      {
+        ...this.fields,
+        ...fields
+      },
+      this.logLevel
+    );
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+};
+var systemLogger = new SystemLogger();
+
+// src/run/handlers/request-context.cts
+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 createRequestContext(request, context) {
+  const backgroundWorkPromises = [];
+  const logger = systemLogger.withLogLevel(LogLevel.Log);
+  return {
+    isBackgroundRevalidation: false,
+    captureServerTiming: false,
+    trackBackgroundWork: (promise) => {
+      if (context?.waitUntil) {
+        context.waitUntil(promise);
+      } else {
+        backgroundWorkPromises.push(promise);
+      }
+    },
+    get backgroundWorkPromise() {
+      return Promise.allSettled(backgroundWorkPromises);
+    },
+    logger,
+    requestID: ""
+  };
+}
+var requestContextAsyncLocalStorage;
+function getRequestContextAsyncLocalStorage() {
+  if (requestContextAsyncLocalStorage) {
+    return requestContextAsyncLocalStorage;
+  }
+  if (extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY]) {
+    return extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY];
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  requestContextAsyncLocalStorage = storage;
+  extendedGlobalThis[REQUEST_CONTEXT_GLOBAL_KEY] = storage;
+  return storage;
+}
+var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
+function runWithRequestContext(requestContext, fn) {
+  return getRequestContextAsyncLocalStorage().run(requestContext, fn);
+}
+function getLogger() {
+  return getRequestContext()?.logger ?? systemLogger;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequestContext,
+  getLogger,
+  getRequestContext,
+  runWithRequestContext
+});

package/dist/run/handlers/server.js

@@ -0,0 +1,77 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  getTracer
+} from "../../esm-chunks/chunk-UOPC2N5A.js";
+import "../../esm-chunks/chunk-V2LFVP3C.js";
+import {
+  getRunConfig,
+  setFetchBeforeNuxtPatchedIt,
+  setRunConfig
+} from "../../esm-chunks/chunk-HY3HNABZ.js";
+import {
+  getLogger,
+  getRequestContext
+} from "../../esm-chunks/chunk-KGYBHZC3.js";
+import "../../esm-chunks/chunk-HBXUWFGE.js";
+import {
+  setCacheControlHeaders,
+  setCacheStatusHeader
+} from "../../esm-chunks/chunk-5YBUNNZ4.js";
+import "../../esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/run/handlers/wait-until.cts
+var NEXT_REQUEST_CONTEXT_SYMBOL = Symbol.for("@next/request-context");
+function setupWaitUntil() {
+  ;
+  globalThis[NEXT_REQUEST_CONTEXT_SYMBOL] = {
+    get() {
+      return { waitUntil: getRequestContext()?.trackBackgroundWork };
+    }
+  };
+}
+
+// src/run/handlers/server.ts
+setFetchBeforeNuxtPatchedIt(globalThis.fetch);
+var { nextConfig, nuxtConfig } = await getRunConfig();
+setRunConfig(nextConfig);
+setupWaitUntil();
+var nuxtImportPromise = import(process.cwd() + "/app/.output/server/index.mjs");
+var nuxtHandler;
+var server_default = async (request, _context, topLevelSpan, requestContext) => {
+  const tracer = getTracer();
+  if (!nuxtHandler) {
+    await tracer.withActiveSpan("initialize nuxt server", async () => {
+      const nuxtApp = await nuxtImportPromise;
+      nuxtHandler = nuxtApp.default;
+    });
+  }
+  return await tracer.withActiveSpan("generate response", async (span) => {
+    try {
+      const response = await nuxtHandler(request);
+      if (requestContext.responseCacheKey) {
+        topLevelSpan.setAttribute("responseCacheKey", requestContext.responseCacheKey);
+      }
+      setCacheControlHeaders(response, request, requestContext);
+      setCacheStatusHeader(response.headers, null);
+      return response;
+    } catch (error) {
+      getLogger().withError(error).error("nuxt handler error");
+      console.error(error);
+      span.setAttribute("http.status_code", 500);
+      return new Response("Internal Server Error", {
+        status: 500,
+        headers: {
+          "Content-Type": "text/plain"
+        }
+      });
+    }
+  });
+};
+export {
+  server_default as default
+};