@visulima/error-handler 1.0.0

package/dist/error-handler/json-error-handler.d.ts

@@ -0,0 +1,17 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from '../packem_shared/types.d-DLy8CCca.js';
+
+type JsonErrorBody = Record<string, unknown> | unknown[];
+type JsonErrorFormatter = (params: {
+    error: Error;
+    request: IncomingMessage;
+    response: ServerResponse;
+    reasonPhrase: string;
+    statusCode: number;
+}) => JsonErrorBody | Promise<JsonErrorBody>;
+type JsonErrorHandlerOptions = {
+    formatter?: JsonErrorFormatter;
+};
+declare const jsonErrorHandler: (options?: JsonErrorHandlerOptions) => ErrorHandler;
+
+export { type JsonErrorBody, type JsonErrorFormatter, type JsonErrorHandlerOptions, jsonErrorHandler };

package/dist/error-handler/json-error-handler.js

@@ -0,0 +1,31 @@
+import { getReasonPhrase } from 'http-status-codes';
+import { a as addStatusCodeToResponse } from '../packem_shared/add-status-code-to-response-DdfxTQsK.js';
+import { s as sendJson } from '../packem_shared/send-json-o-t1rNfw.js';
+import { s as setErrorHeaders } from '../packem_shared/set-error-headers-B6ZeX5k4.js';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const jsonErrorHandler = /* @__PURE__ */ __name((options = {}) => {
+  return async (error, request, response) => {
+    addStatusCodeToResponse(response, error);
+    setErrorHeaders(response, error);
+    const statusCode = response.statusCode;
+    const reasonPhrase = getReasonPhrase(statusCode) || "An error occurred";
+    if (options.formatter) {
+      const body = await options.formatter({ error, request, response, reasonPhrase, statusCode });
+      sendJson(response, body);
+      return;
+    }
+    const expose = error.expose;
+    sendJson(response, {
+      statusCode,
+      // eslint-disable-next-line perfectionist/sort-objects
+      error: reasonPhrase,
+      // eslint-disable-next-line perfectionist/sort-objects
+      message: error.message || reasonPhrase,
+      ...expose ? { stack: error.stack } : {}
+    });
+  };
+}, "jsonErrorHandler");
+
+export { jsonErrorHandler };

package/dist/error-handler/jsonapi-error-handler.d.ts

@@ -0,0 +1,6 @@
+import { a as ErrorHandler } from '../packem_shared/types.d-DLy8CCca.js';
+import 'node:http';
+
+declare const jsonapiErrorHandler: ErrorHandler;
+
+export { jsonapiErrorHandler as default };

package/dist/error-handler/jsonapi-error-handler.js

@@ -0,0 +1,46 @@
+import { isHttpError } from 'http-errors';
+import { getReasonPhrase } from 'http-status-codes';
+import tsJapi from 'ts-japi';
+import { a as addStatusCodeToResponse } from '../packem_shared/add-status-code-to-response-DdfxTQsK.js';
+import { s as sendJson } from '../packem_shared/send-json-o-t1rNfw.js';
+import { s as setErrorHeaders } from '../packem_shared/set-error-headers-B6ZeX5k4.js';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const defaultTitle = "An error occurred";
+const jsonapiErrorHandler = /* @__PURE__ */ __name((error, _request, response) => {
+  addStatusCodeToResponse(response, error);
+  setErrorHeaders(response, error);
+  if (error instanceof tsJapi.JapiError || tsJapi.JapiError.isLikeJapiError(error)) {
+    const serializer = new tsJapi.ErrorSerializer();
+    sendJson(response, serializer.serialize(error));
+  } else if (isHttpError(error)) {
+    const statusCode = "statusCode" in error && typeof error.statusCode === "number" ? error.statusCode : "status" in error && typeof error.status === "number" ? error.status : response.statusCode;
+    const title = "title" in error && typeof error.title === "string" ? error.title : void 0;
+    const message = "message" in error && typeof error.message === "string" ? error.message : "";
+    sendJson(response, {
+      errors: [
+        {
+          code: statusCode ?? response.statusCode,
+          title: title || getReasonPhrase(statusCode) || defaultTitle,
+          // eslint-disable-next-line perfectionist/sort-objects
+          detail: message
+        }
+      ]
+    });
+  } else {
+    const { message } = error;
+    sendJson(response, {
+      errors: [
+        {
+          code: "500",
+          title: getReasonPhrase(response.statusCode) || defaultTitle,
+          // eslint-disable-next-line perfectionist/sort-objects
+          detail: message
+        }
+      ]
+    });
+  }
+}, "jsonapiErrorHandler");
+
+export { jsonapiErrorHandler as default };

package/dist/error-handler/jsonp-error-handler.d.ts

@@ -0,0 +1,18 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from '../packem_shared/types.d-DLy8CCca.js';
+
+type JsonpErrorBody = Record<string, unknown> | unknown[];
+type JsonpErrorFormatter = (params: {
+    error: Error;
+    request: IncomingMessage;
+    response: ServerResponse;
+    reasonPhrase: string;
+    statusCode: number;
+}) => JsonpErrorBody | Promise<JsonpErrorBody>;
+type JsonpErrorHandlerOptions = {
+    callbackParamName?: string;
+    formatter?: JsonpErrorFormatter;
+};
+declare const jsonpErrorHandler: (options?: JsonpErrorHandlerOptions) => ErrorHandler;
+
+export { type JsonpErrorBody, type JsonpErrorFormatter, type JsonpErrorHandlerOptions, jsonpErrorHandler };

package/dist/error-handler/jsonp-error-handler.js

@@ -0,0 +1,36 @@
+import { getReasonPhrase } from 'http-status-codes';
+import { a as addStatusCodeToResponse } from '../packem_shared/add-status-code-to-response-DdfxTQsK.js';
+import { s as setErrorHeaders } from '../packem_shared/set-error-headers-B6ZeX5k4.js';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const defaultCallbackParam = "callback";
+const jsonpErrorHandler = /* @__PURE__ */ __name((options = {}) => {
+  return async (error, request, response) => {
+    addStatusCodeToResponse(response, error);
+    setErrorHeaders(response, error);
+    const statusCode = response.statusCode;
+    const reasonPhrase = getReasonPhrase(statusCode) || "An error occurred";
+    const url = new URL(request.url ?? "http://localhost", "http://localhost");
+    const callbackParamName = options.callbackParamName || defaultCallbackParam;
+    const callbackName = url.searchParams.get(callbackParamName) || "callback";
+    let payload;
+    if (options.formatter) {
+      payload = await options.formatter({ error, request, response, reasonPhrase, statusCode });
+    } else {
+      const expose = error.expose;
+      payload = {
+        statusCode,
+        // eslint-disable-next-line perfectionist/sort-objects
+        error: reasonPhrase,
+        // eslint-disable-next-line perfectionist/sort-objects
+        message: error.message || reasonPhrase,
+        ...expose ? { stack: error.stack } : {}
+      };
+    }
+    response.setHeader("content-type", "application/javascript; charset=utf-8");
+    response.end(`${callbackName}(${JSON.stringify(payload)});`);
+  };
+}, "jsonpErrorHandler");
+
+export { jsonpErrorHandler };

package/dist/error-handler/problem-error-handler.d.ts

@@ -0,0 +1,6 @@
+import { a as ErrorHandler } from '../packem_shared/types.d-DLy8CCca.js';
+import 'node:http';
+
+declare const problemErrorHandler: ErrorHandler;
+
+export { problemErrorHandler as default };

package/dist/error-handler/problem-error-handler.js

@@ -0,0 +1,53 @@
+import { isHttpError } from 'http-errors';
+import { getReasonPhrase } from 'http-status-codes';
+import { a as addStatusCodeToResponse } from '../packem_shared/add-status-code-to-response-DdfxTQsK.js';
+import { s as sendJson } from '../packem_shared/send-json-o-t1rNfw.js';
+import { s as setErrorHeaders } from '../packem_shared/set-error-headers-B6ZeX5k4.js';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const defaultType = "about:blank";
+const defaultTitle = "An error occurred";
+const problemErrorHandler = /* @__PURE__ */ __name((error, _request, response) => {
+  const { message, stack } = error;
+  if (isHttpError(error)) {
+    const expose = "expose" in error ? error.expose : void 0;
+    const statusCode = "statusCode" in error && typeof error.statusCode === "number" ? error.statusCode : "status" in error && typeof error.status === "number" ? error.status : response.statusCode;
+    const title = "title" in error && typeof error.title === "string" ? error.title : void 0;
+    const type = "type" in error && typeof error.type === "string" ? error.type : void 0;
+    response.statusCode = statusCode;
+    setErrorHeaders(response, error);
+    sendJson(
+      response,
+      {
+        type: type || defaultType,
+        // eslint-disable-next-line perfectionist/sort-objects
+        title: title || getReasonPhrase(statusCode) || defaultTitle,
+        // eslint-disable-next-line perfectionist/sort-objects
+        status: statusCode,
+        // eslint-disable-next-line perfectionist/sort-objects
+        detail: message,
+        ...expose ? { trace: stack } : {}
+      },
+      "application/problem+json"
+    );
+  } else {
+    addStatusCodeToResponse(response, error);
+    sendJson(
+      response,
+      {
+        type: defaultType,
+        // eslint-disable-next-line perfectionist/sort-objects
+        title: getReasonPhrase(response.statusCode) || defaultTitle,
+        // eslint-disable-next-line perfectionist/sort-objects
+        status: response.statusCode,
+        // eslint-disable-next-line perfectionist/sort-objects
+        detail: message,
+        ...error.expose ? { trace: stack } : {}
+      },
+      "application/problem+json"
+    );
+  }
+}, "problemErrorHandler");
+
+export { problemErrorHandler as default };

package/dist/error-handler/text-error-handler.d.ts

@@ -0,0 +1,16 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from '../packem_shared/types.d-DLy8CCca.js';
+
+type TextErrorFormatter = (params: {
+    error: Error;
+    request: IncomingMessage;
+    response: ServerResponse;
+    reasonPhrase: string;
+    statusCode: number;
+}) => string | Promise<string>;
+type TextErrorHandlerOptions = {
+    formatter?: TextErrorFormatter;
+};
+declare const textErrorHandler: (options?: TextErrorHandlerOptions) => ErrorHandler;
+
+export { type TextErrorFormatter, type TextErrorHandlerOptions, textErrorHandler };

package/dist/error-handler/text-error-handler.js

@@ -0,0 +1,28 @@
+import { getReasonPhrase } from 'http-status-codes';
+import { a as addStatusCodeToResponse } from '../packem_shared/add-status-code-to-response-DdfxTQsK.js';
+import { s as setErrorHeaders } from '../packem_shared/set-error-headers-B6ZeX5k4.js';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const textErrorHandler = /* @__PURE__ */ __name((options = {}) => {
+  return async (error, request, response) => {
+    addStatusCodeToResponse(response, error);
+    setErrorHeaders(response, error);
+    const statusCode = response.statusCode;
+    const reasonPhrase = getReasonPhrase(statusCode) || "Error";
+    response.setHeader("content-type", "text/plain; charset=utf-8");
+    if (options.formatter) {
+      const text = await options.formatter({ error, request, response, reasonPhrase, statusCode });
+      response.end(text);
+      return;
+    }
+    const message = error.message || reasonPhrase;
+    const expose = error.expose;
+    const stack = expose ? error.stack : void 0;
+    response.end(stack ? `${message}
+
+${stack}` : message);
+  };
+}, "textErrorHandler");
+
+export { textErrorHandler };

package/dist/error-handler/xml-error-handler.d.ts

@@ -0,0 +1,29 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { a as ErrorHandler } from '../packem_shared/types.d-DLy8CCca.js';
+
+type XmlErrorBody = Record<string, unknown> | unknown[];
+type XmlErrorFormatter = (params: {
+    error: Error;
+    request: IncomingMessage;
+    response: ServerResponse;
+    reasonPhrase: string;
+    statusCode: number;
+}) => XmlErrorBody | Promise<XmlErrorBody>;
+type ToXmlOptions = {
+    indent?: string;
+    header?: string | boolean;
+    attributeReplacements?: Record<string, string>;
+    attributeFilter?: (key: string, value: unknown) => boolean;
+    attributeExplicitTrue?: boolean;
+    contentMap?: (content: string) => string;
+    contentReplacements?: Record<string, string>;
+    selfCloseTags?: boolean;
+};
+type XmlErrorHandlerOptions = {
+    formatter?: XmlErrorFormatter;
+    xmlHeader?: boolean;
+    toXml?: ToXmlOptions;
+};
+declare const xmlErrorHandler: (options?: XmlErrorHandlerOptions) => ErrorHandler;
+
+export { type ToXmlOptions, type XmlErrorBody, type XmlErrorFormatter, type XmlErrorHandlerOptions, xmlErrorHandler };

package/dist/error-handler/xml-error-handler.js

@@ -0,0 +1,45 @@
+import { getReasonPhrase } from 'http-status-codes';
+import { toXML } from 'jstoxml';
+import { a as addStatusCodeToResponse } from '../packem_shared/add-status-code-to-response-DdfxTQsK.js';
+import { s as setErrorHeaders } from '../packem_shared/set-error-headers-B6ZeX5k4.js';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const xmlErrorHandler = /* @__PURE__ */ __name((options = {}) => {
+  return async (error, request, response) => {
+    addStatusCodeToResponse(response, error);
+    setErrorHeaders(response, error);
+    const statusCode = response.statusCode;
+    const reasonPhrase = getReasonPhrase(statusCode) || "An error occurred";
+    let payload;
+    if (options.formatter) {
+      payload = await options.formatter({ error, request, response, reasonPhrase, statusCode });
+    } else {
+      const expose = error.expose;
+      payload = {
+        error: {
+          statusCode,
+          // eslint-disable-next-line perfectionist/sort-objects
+          name: reasonPhrase,
+          // eslint-disable-next-line perfectionist/sort-objects
+          message: error.message || reasonPhrase,
+          ...expose ? { stack: error.stack } : {}
+        }
+      };
+    }
+    const xml = toXML(payload, {
+      header: options.toXml?.header ?? options.xmlHeader ?? true,
+      indent: options.toXml?.indent ?? "  ",
+      ...options.toXml?.attributeReplacements ? { attributeReplacements: options.toXml.attributeReplacements } : {},
+      ...options.toXml?.attributeFilter ? { attributeFilter: options.toXml.attributeFilter } : {},
+      ...options.toXml?.attributeExplicitTrue !== void 0 ? { attributeExplicitTrue: options.toXml.attributeExplicitTrue } : {},
+      ...options.toXml?.contentMap ? { contentMap: options.toXml.contentMap } : {},
+      ...options.toXml?.contentReplacements ? { contentReplacements: options.toXml.contentReplacements } : {},
+      ...options.toXml?.selfCloseTags !== void 0 ? { selfCloseTags: options.toXml.selfCloseTags } : {}
+    });
+    response.setHeader("content-type", "application/xml; charset=utf-8");
+    response.end(xml);
+  };
+}, "xmlErrorHandler");
+
+export { xmlErrorHandler };

package/dist/handler/cli-handler.d.ts

@@ -0,0 +1,30 @@
+import { RenderErrorOptions } from '@visulima/error/error';
+import { SolutionFinder } from '@visulima/error/solution';
+
+type CliLogger = {
+    error: (...arguments_: unknown[]) => void;
+    log: (...arguments_: unknown[]) => void;
+};
+type ColorizeMethod = (value: string) => string;
+type BaseCliOptions = {
+    solutionTitle?: string;
+    solutionFinders?: SolutionFinder[];
+    debug?: boolean;
+} & Partial<Omit<RenderErrorOptions, "color">> & {
+    color?: {
+        codeFrame?: RenderErrorOptions["color"];
+        boxen?: {
+            headerTextColor?: ColorizeMethod;
+            textColor?: ColorizeMethod;
+            borderColor?: ColorizeMethod;
+        };
+    };
+};
+type CliHandlerOptions = BaseCliOptions & {
+    logger?: CliLogger;
+};
+
+declare const ansiHandler: (error: Error, options?: BaseCliOptions) => Promise<string>;
+declare const cliHandler: (error: Error, options?: CliHandlerOptions) => Promise<void>;
+
+export { type BaseCliOptions, type CliHandlerOptions, ansiHandler, cliHandler };

package/dist/handler/cli-handler.js

@@ -0,0 +1,173 @@
+import { parseStacktrace } from '@visulima/error/stacktrace';
+import { boxen } from '@visulima/boxen';
+import { renderError } from '@visulima/error/error';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { ruleBasedFinder, errorHintFinder } from '@visulima/error/solution';
+
+var __defProp$3 = Object.defineProperty;
+var __name$3 = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+const ALTERNATIVE_JS_EXTS = ["cjs", "mjs"];
+const ALTERNATIVE_MD_EXTS = ["mdoc"];
+const findLanguageBasedOnExtension = /* @__PURE__ */ __name$3((file) => {
+  const cleaned = file.split("?")[0] ?? file;
+  const extension = cleaned.split(".").pop()?.toLowerCase();
+  if (!extension) {
+    return "javascript";
+  }
+  if (ALTERNATIVE_JS_EXTS.includes(extension)) {
+    return "javascript";
+  }
+  if (ALTERNATIVE_MD_EXTS.includes(extension)) {
+    return "markdown";
+  }
+  switch (extension) {
+    case "js": {
+      return "javascript";
+    }
+    case "json": {
+      return "json";
+    }
+    case "json5": {
+      return "json5";
+    }
+    case "jsonc": {
+      return "jsonc";
+    }
+    case "jsx": {
+      return "jsx";
+    }
+    case "sql": {
+      return "sql";
+    }
+    case "ts": {
+      return "typescript";
+    }
+    case "tsx": {
+      return "tsx";
+    }
+    case "xml": {
+      return "xml";
+    }
+    case "md": {
+      return "markdown";
+    }
+    case "mdx": {
+      return "mdx";
+    }
+    default: {
+      return "javascript";
+    }
+  }
+}, "findLanguageBasedOnExtension");
+
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
+const cache = /* @__PURE__ */ new Map();
+const getFileSource = /* @__PURE__ */ __name$2(async (file) => {
+  if (!/^(?:http|https|file|data):/.test(file)) {
+    return void 0;
+  }
+  if (cache.has(file)) {
+    return cache.get(file);
+  }
+  if (file.startsWith("file:")) {
+    try {
+      const path = fileURLToPath(file);
+      const source = await readFile(path, "utf8");
+      cache.set(file, source);
+      return source;
+    } catch (error) {
+      console.log(error);
+      return void 0;
+    }
+  }
+  try {
+    const response = await fetch(file);
+    if (!response.ok) {
+      return void 0;
+    }
+    const source = await response.text();
+    cache.set(file, source);
+    return source;
+  } catch (error) {
+    console.log(error);
+    return void 0;
+  }
+}, "getFileSource");
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const sanitizeTitle = /* @__PURE__ */ __name$1((title) => title.replace(/^\s*#+\s*/, "").trim(), "sanitizeTitle");
+const runSolutionFinders = /* @__PURE__ */ __name$1(async (error, solutionFinders, debug = false) => {
+  const candidates = [...solutionFinders, ruleBasedFinder, errorHintFinder];
+  const firstTrace = parseStacktrace(error, { frameLimit: 1 })[0] ?? {};
+  for await (const handler of candidates.sort((a, b) => a.priority - b.priority)) {
+    const { handle, name } = handler;
+    if (debug) {
+      console.debug(`Running solution finder: ${name}`);
+    }
+    if (typeof handle !== "function") {
+      continue;
+    }
+    const hint = await handle(error, {
+      file: firstTrace.file ?? "",
+      language: findLanguageBasedOnExtension(firstTrace.file ?? ""),
+      line: firstTrace.line ?? 0,
+      snippet: firstTrace.file ? await getFileSource(firstTrace.file) : ""
+    });
+    if (hint) {
+      return hint;
+    }
+  }
+  return void 0;
+}, "runSolutionFinders");
+const buildOutput = /* @__PURE__ */ __name$1(async (error, options) => {
+  const { solutionFinders = [], solutionTitle, color, debug = false, ...renderOptions } = options;
+  const errorAnsi = renderError(error, {
+    ...renderOptions,
+    ...color?.codeFrame
+  });
+  const hint = await runSolutionFinders(error, solutionFinders, debug);
+  if (!hint) {
+    return { errorAnsi, solutionBox: void 0 };
+  }
+  const header = sanitizeTitle(hint.header ?? solutionTitle ?? "A possible solution to this error");
+  const solutionBox = boxen(hint.body, {
+    borderStyle: "round",
+    padding: { top: 1, right: 2, bottom: 1, left: 2 },
+    margin: { top: 0, right: 0, bottom: 0, left: 0 },
+    headerText: `💡 ${header}`,
+    headerAlignment: "left",
+    textAlignment: "left",
+    ...color?.boxen
+  });
+  return {
+    errorAnsi,
+    solutionBox
+  };
+}, "buildOutput");
+const terminalOutput = /* @__PURE__ */ __name$1(async (error, options = {}) => {
+  const { logger = console, ...rest } = options;
+  const { errorAnsi, solutionBox } = await buildOutput(error, rest);
+  logger.error(errorAnsi);
+  if (solutionBox) {
+    logger.log("");
+    logger.log(solutionBox);
+  }
+}, "terminalOutput");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ansiHandler = /* @__PURE__ */ __name(async (error, options = {}) => {
+  const { errorAnsi, solutionBox } = await buildOutput(error, options);
+  if (solutionBox === void 0) {
+    return errorAnsi;
+  }
+  return `${errorAnsi}
+
+${solutionBox}`;
+}, "ansiHandler");
+const cliHandler = terminalOutput;
+
+export { ansiHandler, cliHandler };

package/dist/handler/http/fetch-handler.d.ts

@@ -0,0 +1,11 @@
+import { HtmlErrorHandlerOptions } from '../../error-handler/html-error-handler.js';
+import { F as FetchErrorHandlers } from '../../packem_shared/types.d-DLy8CCca.js';
+import 'node:http';
+
+declare const fetchHandler: (error: Error, options?: HtmlErrorHandlerOptions & {
+    showTrace?: boolean;
+    extraHandlers?: FetchErrorHandlers;
+    onError?: (error: Error, request: Request) => void | Promise<void>;
+}) => Promise<(request: Request) => Promise<Response>>;
+
+export { fetchHandler as default };