nitro 2.2.27 → 3.0.0-alpha.0

package/dist/node_modules/youch-core/build/index.js

@@ -0,0 +1,316 @@
+// src/parser.ts
+import { fileURLToPath } from "url";
+import { readFile } from "fs/promises";
+import { Exception } from "@poppinss/exception";
+import { parse } from "error-stack-parser-es";
+
+// src/debug.ts
+import { debuglog } from "util";
+var debug_default = debuglog("youch:core");
+
+// src/source_file.ts
+var SourceFile = class {
+  #contents;
+  constructor(options) {
+    if ("contents" in options) {
+      this.#contents = options.contents;
+    }
+  }
+  /**
+   * Slice the file contents for the buffer size around a given
+   * line number.
+   *
+   * @example
+   * ```ts
+   * const chunks = sourceFile.slice(11, 7)
+   * // Here chunks will be an array of 7 items from line number
+   * // 8 to 14
+   * ```
+   */
+  slice(lineNumber, bufferSize) {
+    if (!this.#contents) {
+      return void 0;
+    }
+    const lines = this.#contents.split(/\n|\r\n/);
+    const contentSize = lines.length;
+    const chunkSize = Math.ceil((bufferSize - 1) / 2);
+    let startIndex = chunkSize >= lineNumber ? 0 : lineNumber - chunkSize - 1;
+    if (contentSize - lineNumber < chunkSize) {
+      startIndex = Math.max(startIndex - (chunkSize - (contentSize - lineNumber)), 0);
+    }
+    const sourceIndex = lineNumber - 1;
+    const startRemainder = startIndex - sourceIndex + chunkSize;
+    const endIndex = startRemainder + chunkSize + lineNumber;
+    debug_default("slicing file contents", {
+      startIndex,
+      endIndex,
+      sourceIndex,
+      contentSize,
+      bufferSize,
+      chunkSize
+    });
+    return lines.slice(startIndex, endIndex).map((chunk, index) => {
+      return {
+        chunk,
+        lineNumber: startIndex + index + 1
+      };
+    });
+  }
+};
+
+// src/parser.ts
+var ErrorParser = class _ErrorParser {
+  /**
+   * FS source loader reads the file contents from the filesystem
+   * for all non-native frames
+   */
+  static fsSourceLoader = async (frame) => {
+    if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
+      return void 0;
+    }
+    debug_default("reading contents for source file %s", frame.fileName);
+    try {
+      return {
+        contents: await readFile(frame.fileName, "utf-8")
+      };
+    } catch (error) {
+      debug_default(`Unable to read source file %s, error %s`, frame.fileName, error.message);
+    }
+  };
+  /**
+   * Native frames filename identifiers for Node.js and
+   * Deno
+   */
+  #nativeFramesIdentifiers = ["node:", "ext:"];
+  /**
+   * Native frames filename identifier for Bun. In case of
+   * bun, the filename exactly matches the keyword "native"
+   */
+  #bunNativeIdentifier = "native";
+  /**
+   * Cache of preloaded source files along with their absolute
+   * path
+   */
+  #sourceFiles = /* @__PURE__ */ new Map();
+  /**
+   * The offset can be used to skip initial frames from the
+   * error stack
+   */
+  #offset;
+  /**
+   * Custom source loader to consult for reading the sourcefile
+   * contents
+   */
+  #sourceLoader = _ErrorParser.fsSourceLoader;
+  /**
+   * Parsers are used to prepare the source value for parsing
+   */
+  #parsers = [];
+  /**
+   * Transformers are used to post process the parsed error and
+   * attach additional information to it.
+   */
+  #transformers = [];
+  constructor(options) {
+    options = options ?? {};
+    this.#offset = options.offset;
+  }
+  /**
+   * Normalizes the unknown error to be an Error
+   */
+  #normalizeError(source) {
+    if (source instanceof Error) {
+      return source;
+    }
+    if (typeof source === "object" && source && "message" in source && "stack" in source) {
+      return source;
+    }
+    const error = new Exception(JSON.stringify(source));
+    error.help = 'To get as much information as possible from your errors, make sure to throw Error objects. See <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error</a> for more information.';
+    return error;
+  }
+  /**
+   * Returns the source chunks for a given file and the
+   * line number.
+   */
+  async #getSource(frame) {
+    let sourceFile = this.#sourceFiles.get(frame.fileName);
+    if (sourceFile) {
+      debug_default("reading sourcefile from cache %s", frame.fileName);
+      return sourceFile.slice(frame.lineNumber ?? 1, 11);
+    }
+    const contents = await this.#sourceLoader(frame);
+    if (contents) {
+      sourceFile = new SourceFile(contents);
+      debug_default("caching sourcefile instance for %s", frame.fileName);
+      this.#sourceFiles.set(frame.fileName, sourceFile);
+      return sourceFile.slice(frame.lineNumber ?? 1, 11);
+    }
+  }
+  /**
+   * Syntax errors in JavaScript does not contain the source file
+   * location within the stack trace, since the error has
+   * happened in the language parser.
+   *
+   * However, Node.js includes the absolute path to the file within
+   * the stack trace contents as the first line. So we parse
+   * that out in this function.
+   */
+  #parseSyntaxError(error) {
+    const [sourceIdentifier] = error.stack?.split("\n") || [];
+    const tokens = sourceIdentifier.split(":");
+    const lineNumber = Number(tokens.pop());
+    const fileName = tokens.join(":");
+    if (fileName && !Number.isNaN(lineNumber)) {
+      return [
+        {
+          fileName,
+          lineNumber,
+          source: sourceIdentifier
+        }
+      ];
+    }
+    return [];
+  }
+  /**
+   * Applies the offset on the frames to skip certain frames
+   * from the start
+   */
+  #applyOffset(frames) {
+    if (this.#offset) {
+      return frames.slice(this.#offset);
+    }
+    return frames;
+  }
+  /**
+   * Replaces windows slash to unix slash
+   */
+  #toUnixSlash(fileName) {
+    const isExtendedLengthPath = fileName.startsWith("\\\\?\\");
+    return isExtendedLengthPath ? fileName : fileName.replace(/\\/g, "/");
+  }
+  /**
+   * Normalizes the filename to be a path with unix slash. The
+   * URL style paths are also converted to normalized file
+   * paths
+   */
+  #normalizeFileName(fileName) {
+    if (fileName.startsWith("file:")) {
+      return this.#toUnixSlash(fileURLToPath(fileName));
+    }
+    return this.#toUnixSlash(fileName);
+  }
+  /**
+   * Returns the type of the frame.
+   */
+  #getFrameType(fileName) {
+    return this.#nativeFramesIdentifiers.some((identifier) => fileName.includes(identifier)) || fileName === this.#bunNativeIdentifier ? "native" : fileName.includes("node_modules/") ? "module" : "app";
+  }
+  /**
+   * Returns the source type of the frame.
+   */
+  #getFrameSourceType(fileName) {
+    return fileName.startsWith("http://") ? "http" : fileName.startsWith("https://") ? "https" : "fs";
+  }
+  /**
+   * Enhances a frame to contain additional information
+   */
+  async #enhanceFrames(frames) {
+    let stackFrames = [];
+    for (const { source: raw, ...frame } of frames) {
+      const stackFrame = {
+        ...frame,
+        raw
+      };
+      if (!stackFrame.fileName) {
+        stackFrames.push(stackFrame);
+        continue;
+      }
+      stackFrame.fileName = this.#normalizeFileName(stackFrame.fileName);
+      stackFrame.type = this.#getFrameType(stackFrame.fileName);
+      stackFrame.fileType = this.#getFrameSourceType(stackFrame.fileName);
+      stackFrame.source = await this.#getSource(stackFrame);
+      debug_default("stack frame %O", stackFrame);
+      stackFrames.push(stackFrame);
+    }
+    return stackFrames;
+  }
+  /**
+   * Register a parser. Parsers are synchronous functions
+   * that can be used to pre-process the source value
+   * before it get parsed.
+   *
+   * @example
+   * ```ts
+   * sourceFile.useParser((source) => {
+   *   if (valueCanBeParsed) {
+   *     return newValue
+   *   }
+   *   return source
+   * })
+   * ```
+   */
+  useParser(parser) {
+    this.#parsers.push(parser);
+    return this;
+  }
+  /**
+   * Register a transformer. Transformers can be async functions
+   * to post-process the parsed error value.
+   *
+   * @example
+   * ```ts
+   * sourceFile.useTransformer((error, source) => {
+   *   // mutate "error" properties
+   * })
+   * ```
+   */
+  useTransformer(transformer) {
+    this.#transformers.push(transformer);
+    return this;
+  }
+  /**
+   * Define a custom source loader to load the contents of the
+   * source file within the error stack.
+   *
+   * For example: You might want to register a custom source loader
+   * that makes an fetch call to the server to read the source of
+   * the file within the error stack.
+   */
+  defineSourceLoader(loader) {
+    this.#sourceLoader = loader;
+    return this;
+  }
+  /**
+   * Parse an unknown value into a parsed error object.
+   */
+  async parse(source) {
+    debug_default("parsing source %O", source);
+    source = this.#parsers.reduce((result, parser) => {
+      result = parser(result);
+      return result;
+    }, source);
+    let error = this.#normalizeError(source);
+    debug_default("error normalized to %O", error);
+    let esFrames = error instanceof SyntaxError ? this.#parseSyntaxError(error) : [];
+    esFrames = esFrames.concat(parse(error, { allowEmpty: true }));
+    esFrames = this.#applyOffset(esFrames);
+    const parsedError = {
+      message: error.message,
+      name: error.name,
+      frames: await this.#enhanceFrames(esFrames),
+      hint: "hint" in error && error.hint ? String(error.hint) : "help" in error && error.help ? String(error.help) : void 0,
+      code: "code" in error ? String(error.code) : void 0,
+      cause: error.cause,
+      stack: error.stack,
+      raw: error
+    };
+    for (const transformer of this.#transformers) {
+      await transformer(parsedError, error);
+    }
+    return parsedError;
+  }
+};
+export {
+  ErrorParser
+};

package/dist/node_modules/youch-core/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "youch-core",
+  "description": "Error parser to parse an error instance into a collection of frames",
+  "version": "0.3.3",
+  "type": "module",
+  "files": [
+    "build",
+    "!build/bin",
+    "!build/examples",
+    "!build/tests"
+  ],
+  "main": "build/index.js",
+  "exports": {
+    ".": "./build/index.js",
+    "./types": "./build/src/types.js"
+  },
+  "scripts": {
+    "pretest": "npm run lint",
+    "test": "c8 npm run quick:test",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "typecheck": "tsc --noEmit",
+    "precompile": "npm run lint",
+    "compile": "tsup-node && tsc --emitDeclarationOnly --declaration",
+    "build": "npm run compile",
+    "version": "npm run build",
+    "prepublishOnly": "npm run build",
+    "release": "release-it",
+    "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts"
+  },
+  "devDependencies": {
+    "@adonisjs/eslint-config": "^3.0.0-next.0",
+    "@adonisjs/prettier-config": "^1.4.5",
+    "@adonisjs/tsconfig": "^2.0.0-next.0",
+    "@japa/assert": "^4.0.1",
+    "@japa/expect": "^3.0.4",
+    "@japa/expect-type": "^2.0.3",
+    "@japa/file-system": "^2.3.2",
+    "@japa/runner": "^4.2.0",
+    "@poppinss/ts-exec": "^1.4.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/node": "^24.0.10",
+    "ansis": "^4.1.0",
+    "axios": "^1.10.0",
+    "c8": "^10.1.3",
+    "eslint": "^9.30.1",
+    "got": "^14.4.7",
+    "prettier": "^3.6.2",
+    "release-it": "^19.0.3",
+    "strip-ansi": "^7.1.0",
+    "tinyhighlight": "^0.3.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "undici": "^7.11.0"
+  },
+  "dependencies": {
+    "@poppinss/exception": "^1.2.2",
+    "error-stack-parser-es": "^1.0.5"
+  },
+  "homepage": "https://github.com/poppinss/youch-core#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poppinss/youch-core.git"
+  },
+  "bugs": {
+    "url": "https://github.com/poppinss/youch-core/issues"
+  },
+  "keywords": [
+    "pretty-print",
+    "pretty-error"
+  ],
+  "author": "Harminder Virk <virk@adonisjs.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "tsup": {
+    "entry": [
+      "index.ts",
+      "src/types.ts"
+    ],
+    "outDir": "./build",
+    "clean": true,
+    "format": "esm",
+    "dts": false,
+    "sourcemap": false,
+    "target": "esnext"
+  },
+  "release-it": {
+    "git": {
+      "requireCleanWorkingDir": true,
+      "requireUpstream": true,
+      "commitMessage": "chore(release): ${version}",
+      "tagAnnotation": "v${version}",
+      "push": true,
+      "tagName": "v${version}"
+    },
+    "github": {
+      "release": true
+    },
+    "npm": {
+      "publish": true,
+      "skipChecks": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**"
+    ]
+  },
+  "prettier": "@adonisjs/prettier-config"
+}

package/dist/presets/_nitro/runtime/nitro-dev.d.mts

@@ -0,0 +1 @@
+import "#nitro-internal-pollyfills";

package/dist/presets/_nitro/runtime/nitro-dev.mjs

@@ -0,0 +1,62 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { trapUnhandledNodeErrors } from "nitro/runtime/internal";
+import { startScheduleRunner } from "nitro/runtime/internal";
+import { Server } from "node:http";
+import nodeCrypto from "node:crypto";
+import { parentPort, threadId } from "node:worker_threads";
+import wsAdapter from "crossws/adapters/node";
+import { toNodeHandler } from "srvx/node";
+import { getSocketAddress, isSocketSupported } from "get-port-please";
+if (!globalThis.crypto) {
+  globalThis.crypto = nodeCrypto;
+}
+trapUnhandledNodeErrors();
+parentPort?.on("message", (msg) => {
+  if (msg && msg.event === "shutdown") {
+    shutdown();
+  }
+});
+const nitroApp = useNitroApp();
+const server = new Server(toNodeHandler(nitroApp.fetch));
+let listener;
+listen().catch((error) => {
+  console.error("Dev worker failed to listen:", error);
+  return shutdown();
+});
+if (import.meta._websocket) {
+  const { handleUpgrade } = wsAdapter(nitroApp.h3App.websocket);
+  server.on("upgrade", handleUpgrade);
+}
+if (import.meta._tasks) {
+  startScheduleRunner();
+}
+async function listen() {
+  const listenAddr = await isSocketSupported() ? getSocketAddress({
+    name: `nitro-dev-${threadId}`,
+    pid: true,
+    random: true
+  }) : { port: 0, host: "localhost" };
+  return new Promise((resolve, reject) => {
+    try {
+      listener = server.listen(listenAddr, () => {
+        const address = server.address();
+        parentPort?.postMessage({
+          event: "listen",
+          address: typeof address === "string" ? { socketPath: address } : { host: "localhost", port: address?.port }
+        });
+        resolve();
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+async function shutdown() {
+  server.closeAllConnections?.();
+  await Promise.all([
+    new Promise((resolve) => listener?.close(resolve)),
+    nitroApp.hooks.callHook("close").catch(console.error)
+  ]);
+  parentPort?.postMessage({ event: "exit" });
+}

package/dist/presets/_nitro/runtime/nitro-prerenderer.d.mts

@@ -0,0 +1,3 @@
+import "#nitro-internal-pollyfills";
+export declare const appFetch: any;
+export declare const closePrerenderer: () => any;

package/dist/presets/_nitro/runtime/nitro-prerenderer.mjs

@@ -0,0 +1,18 @@
+import "#nitro-internal-pollyfills";
+import consola from "consola";
+import { useNitroApp } from "nitro/runtime";
+import { trapUnhandledNodeErrors } from "nitro/runtime/internal";
+const nitroApp = useNitroApp();
+export const appFetch = nitroApp.fetch;
+export const closePrerenderer = () => nitroApp.hooks.callHook("close");
+nitroApp.hooks.hook("error", (error, context) => {
+  if (!error.unhandled && error.status >= 500 && context.event?.req?.headers instanceof Headers && context.event.req.headers.get("x-nitro-prerender")) {
+    consola.error(
+      `[prerender error]`,
+      `[${context.event.req.method}]`,
+      `[${context.event.req.url}]`,
+      error
+    );
+  }
+});
+trapUnhandledNodeErrors();

package/dist/presets/_nitro/runtime/service-worker.d.mts

@@ -0,0 +1 @@
+import "#nitro-internal-pollyfills";

package/dist/presets/_nitro/runtime/service-worker.mjs

@@ -0,0 +1,21 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { isPublicAssetURL } from "#nitro-internal-virtual/public-assets";
+const nitroApp = useNitroApp();
+addEventListener("fetch", (event) => {
+  const url = new URL(event.request.url);
+  if (isPublicAssetURL(url.pathname) || url.pathname.includes("/_server/")) {
+    return;
+  }
+  const req = event.request;
+  req.runtime ??= { name: "service-worker" };
+  req.runtime.serviceWorker ??= { event };
+  req.waitUntil = event.waitUntil.bind(event);
+  event.respondWith(nitroApp.fetch(req));
+});
+self.addEventListener("install", () => {
+  self.skipWaiting();
+});
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});

package/dist/presets/aws-amplify/runtime/aws-amplify.d.mts

@@ -0,0 +1 @@
+import "#nitro-internal-pollyfills";

package/dist/presets/aws-amplify/runtime/aws-amplify.mjs

@@ -0,0 +1,13 @@
+import "#nitro-internal-pollyfills";
+import { useNitroApp } from "nitro/runtime";
+import { Server } from "node:http";
+import { toNodeHandler } from "srvx/node";
+const nitroApp = useNitroApp();
+const server = new Server(toNodeHandler(nitroApp.fetch));
+server.listen(3e3, (err) => {
+  if (err) {
+    console.error(err);
+  } else {
+    console.log(`Listening on http://localhost:3000 (AWS Amplify Hosting)`);
+  }
+});

package/dist/presets/aws-lambda/runtime/_utils.d.mts

@@ -0,0 +1,18 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyEventV2 } from "aws-lambda";
+import type { ServerRequest } from "srvx";
+export declare function awsRequest(event: APIGatewayProxyEvent | APIGatewayProxyEventV2, context: unknown): ServerRequest;
+export declare function awsResponseHeaders(response: Response): {
+    headers: any;
+    cookies: string[];
+    multiValueHeaders: {
+        "set-cookie": string[];
+    };
+} | {
+    headers: any;
+    cookies?: undefined;
+    multiValueHeaders?: undefined;
+};
+export declare function awsResponseBody(response: Response): Promise<{
+    body: string;
+    isBase64Encoded?: boolean;
+}>;

package/dist/presets/aws-lambda/runtime/_utils.mjs

@@ -0,0 +1,102 @@
+import { stringifyQuery } from "ufo";
+export function awsRequest(event, context) {
+  const method = awsEventMethod(event);
+  const url = awsEventURL(event);
+  const headers = awsEventHeaders(event);
+  const body = awsEventBody(event);
+  const req = new Request(url, { method, headers, body });
+  req.runtime ??= { name: "aws-lambda" };
+  req.runtime.aws ??= { event, context };
+  return new Request(url, { method, headers, body });
+}
+function awsEventMethod(event) {
+  return event.httpMethod || event.requestContext?.http?.method || "GET";
+}
+function awsEventURL(event) {
+  const hostname = event.headers.host || event.headers.Host || event.requestContext?.domainName || ".";
+  const path = event.path || event.rawPath;
+  const query = awsEventQuery(event);
+  const protocol = (event.headers["X-Forwarded-Proto"] || event.headers["x-forwarded-proto"]) === "http" ? "http" : "https";
+  return new URL(
+    `${path}${query ? `?${query}` : ""}`,
+    `${protocol}://${hostname}`
+  );
+}
+function awsEventQuery(event) {
+  if (typeof event.rawQueryString === "string") {
+    return event.rawQueryString;
+  }
+  const queryObj = {
+    ...event.queryStringParameters,
+    ...event.multiValueQueryStringParameters
+  };
+  return stringifyQuery(queryObj);
+}
+function awsEventHeaders(event) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(event.headers)) {
+    if (value) {
+      headers.set(key, value);
+    }
+  }
+  if ("cookies" in event && event.cookies) {
+    for (const cookie of event.cookies) {
+      headers.append("cookie", cookie);
+    }
+  }
+  return headers;
+}
+function awsEventBody(event) {
+  if (!event.body) {
+    return void 0;
+  }
+  if (event.isBase64Encoded) {
+    return Buffer.from(event.body || "", "base64");
+  }
+  return event.body;
+}
+export function awsResponseHeaders(response) {
+  const headers = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of response.headers) {
+    if (value) {
+      headers[key] = Array.isArray(value) ? value.join(",") : String(value);
+    }
+  }
+  const cookies = response.headers.getSetCookie();
+  return cookies.length > 0 ? {
+    headers,
+    cookies,
+    // ApiGateway v2
+    multiValueHeaders: { "set-cookie": cookies }
+    // ApiGateway v1
+  } : { headers };
+}
+export async function awsResponseBody(response) {
+  if (!response.body) {
+    return { body: "" };
+  }
+  const buffer = await toBuffer(response.body);
+  const contentType = response.headers.get("content-type") || "";
+  return isTextType(contentType) ? { body: buffer.toString("utf8") } : { body: buffer.toString("base64"), isBase64Encoded: true };
+}
+function isTextType(contentType = "") {
+  return /^text\/|\/(javascript|json|xml)|utf-?8/i.test(contentType);
+}
+function toBuffer(data) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    data.pipeTo(
+      new WritableStream({
+        write(chunk) {
+          chunks.push(chunk);
+        },
+        close() {
+          resolve(Buffer.concat(chunks));
+        },
+        abort(reason) {
+          reject(reason);
+        }
+      })
+    ).catch(reject);
+  });
+}