@stacksjs/error-handling 0.70.88 → 0.70.91

package/dist/handler.js

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import { dirname } from "node:path";
+import * as process from "node:process";
+function italic(str) {
+  return `\x1B[3m${str}\x1B[23m`;
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*m/g, "");
+}
+import * as path from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+
+export class ErrorHandler {
+  static isTestEnvironment = !1;
+  static shouldExitProcess = !1;
+  static handle(err, options) {
+    if (!this.isTestEnvironment)
+      this.shouldExitProcess = options?.shouldExit === !0;
+    if (options?.silent !== !0)
+      this.writeErrorToConsole(err);
+    let errorMessage;
+    if (options?.message)
+      errorMessage = options.message;
+    else if (err instanceof Error)
+      errorMessage = err.message;
+    else if (typeof err === "string")
+      errorMessage = err;
+    else
+      errorMessage = JSON.stringify(err);
+    const error = Error(errorMessage);
+    if (err instanceof Error)
+      Object.assign(error, err);
+    this.writeErrorToFile(error).catch((e) => console.error(e));
+    return error;
+  }
+  static handleError(err, options) {
+    this.handle(err, options);
+    return err;
+  }
+  static async writeErrorToFile(err, context) {
+    if (!(err instanceof Error)) {
+      console.error("Error is not an instance of Error:", err);
+      return;
+    }
+    const contextStr = context ? ` | url=${context.url || "N/A"} method=${context.method || "N/A"} user=${context.userId || "anonymous"}` : "", stackLine = err.stack ? `
+${err.stack.split(`
+`).slice(1, 4).join(`
+`)}` : "", formattedError = `[${new Date().toISOString()}] ${err.name}: ${err.message}${contextStr}${stackLine}
+`, logFilePath = path.logsPath("stacks.log") ?? path.logsPath("errors.log");
+    try {
+      await fs.promises.mkdir(path.dirname(logFilePath), { recursive: !0 });
+      await fs.promises.appendFile(logFilePath, formattedError);
+    } catch (error) {
+      console.error("Failed to write to error file:", error);
+    }
+  }
+  static writeErrorToConsole(err) {
+    let errorString;
+    if (err instanceof Error)
+      errorString = err.message;
+    else if (typeof err === "string")
+      errorString = err;
+    else
+      errorString = JSON.stringify(err);
+    console.error(errorString);
+    if (errorString.includes("bunx --bun cdk destroy") || errorString === `Failed to execute command: ${italic("bunx --bun eslint . --fix")}` || errorString === `Failed to execute command: ${italic("bun storage/framework/core/actions/src/lint/fix.ts")}`) {
+      if (!this.isTestEnvironment) {
+        console.log("No need to worry. The edge function is currently being destroyed. Please run `buddy undeploy` shortly again, and continue doing so until it succeeds running.");
+        console.log("Hoping to see you back soon!");
+      }
+    }
+    if (this.shouldExitProcess)
+      process.exit(ExitCode.FatalError);
+  }
+}
+let defaultLogPath = "storage/logs/stacks.log";
+export function setLogPath(path) {
+  defaultLogPath = path;
+}
+export async function writeToLogFile(message, options) {
+  const formattedMessage = `[${new Date().toISOString()}] ${message}
+`, logFile = options?.logFile ?? defaultLogPath, dirPath = dirname(logFile);
+  await fs.promises.mkdir(dirPath, { recursive: !0 });
+  await fs.promises.appendFile(logFile, formattedMessage);
+}
+export function handleError(err, options) {
+  let errorMessage, contextData, errorOptions;
+  if (options && typeof options === "object" && (("shouldExit" in options) || ("silent" in options)))
+    errorOptions = options;
+  else if (options !== void 0)
+    contextData = options && typeof options === "object" ? options : { error: options };
+  const errMsg = err instanceof Error ? err.message : typeof err === "string" ? err : JSON.stringify(err);
+  if (errorOptions?.message)
+    errorMessage = `${errMsg}: ${errorOptions.message}`;
+  else
+    errorMessage = errMsg;
+  let logMessage = `ERROR: ${stripAnsi(errorMessage)}`;
+  if (contextData)
+    logMessage += `
+Context: ${JSON.stringify(contextData, null, 2)}`;
+  writeToLogFile(logMessage).catch((err) => {
+    console.error("Failed to write error log:", err);
+  });
+  const error = Error(errorMessage);
+  if (err instanceof Error)
+    Object.assign(error, err);
+  return ErrorHandler.handle(error, errorOptions);
+}

package/dist/http.d.ts

@@ -0,0 +1,49 @@
+import type { ErrorPageConfig, RequestContext, RoutingContext } from './error-page';
+/**
+ * Create a new HTTP error handler
+ */
+export declare function createHttpErrorHandler(options?: {
+  isDevelopment?: boolean
+  config?: ErrorPageConfig
+}): HttpErrorHandler;
+/**
+ * Quick helper to render an error page for HTTP errors
+ */
+export declare function renderHttpError(error: Error, request?: Request, options?: {
+    status?: number
+    isDevelopment?: boolean
+    config?: ErrorPageConfig
+  }): Promise<Response>;
+/**
+ * Express/Hono style error middleware
+ */
+export declare function errorMiddleware(options?: {
+  isDevelopment?: boolean
+  config?: ErrorPageConfig
+}): void;
+export declare class HttpError extends Error {
+  details?: unknown;
+  public status: number;
+  constructor(status: number, message: string, details?: unknown);
+}
+/**
+ * HTTP error handler with Ignition-style error pages
+ */
+export declare class HttpErrorHandler {
+  constructor(options?: {
+    isDevelopment?: boolean
+    config?: ErrorPageConfig
+  });
+  setRequest(request: Request | RequestContext): this;
+  setRouting(routing: RoutingContext): this;
+  addQuery(query: string, time?: number, connection?: string): this;
+  handle(error: Error, status?: number): Promise<Response>;
+  notFound(message?: string): Promise<Response>;
+  serverError(error: Error): Promise<Response>;
+  forbidden(message?: string): Promise<Response>;
+  unauthorized(message?: string): Promise<Response>;
+  badRequest(message?: string): Promise<Response>;
+  validationError(message?: string): Promise<Response>;
+  tooManyRequests(message?: string): Promise<Response>;
+  serviceUnavailable(message?: string): Promise<Response>;
+}

package/dist/http.js

@@ -0,0 +1,165 @@
+import {
+  createErrorHandler,
+  HTTP_ERRORS,
+  renderProductionErrorPage
+} from "./error-page";
+
+export class HttpError extends Error {
+  status;
+  details;
+  constructor(status, message, details) {
+    super(message);
+    this.status = status;
+    this.name = httpStatusName(status);
+    if (details !== void 0)
+      this.details = details;
+  }
+}
+function httpStatusName(status) {
+  switch (status) {
+    case 400:
+      return "Bad Request";
+    case 401:
+      return "Unauthorized";
+    case 402:
+      return "Payment Required";
+    case 403:
+      return "Forbidden";
+    case 404:
+      return "Not Found";
+    case 405:
+      return "Method Not Allowed";
+    case 408:
+      return "Request Timeout";
+    case 409:
+      return "Conflict";
+    case 410:
+      return "Gone";
+    case 413:
+      return "Payload Too Large";
+    case 415:
+      return "Unsupported Media Type";
+    case 422:
+      return "Unprocessable Entity";
+    case 423:
+      return "Locked";
+    case 425:
+      return "Too Early";
+    case 426:
+      return "Upgrade Required";
+    case 428:
+      return "Precondition Required";
+    case 429:
+      return "Too Many Requests";
+    case 431:
+      return "Request Header Fields Too Large";
+    case 451:
+      return "Unavailable For Legal Reasons";
+    case 500:
+      return "Internal Server Error";
+    case 501:
+      return "Not Implemented";
+    case 502:
+      return "Bad Gateway";
+    case 503:
+      return "Service Unavailable";
+    case 504:
+      return "Gateway Timeout";
+    case 507:
+      return "Insufficient Storage";
+    case 508:
+      return "Loop Detected";
+    case 511:
+      return "Network Authentication Required";
+    default:
+      return status >= 400 && status < 500 ? "Client Error" : "Server Error";
+  }
+}
+
+export class HttpErrorHandler {
+  handler = createErrorHandler();
+  isDevelopment;
+  constructor(options) {
+    this.isDevelopment = options?.isDevelopment ?? !0;
+    if (options?.config)
+      this.handler = createErrorHandler(options.config);
+    this.handler.setFramework("Stacks");
+  }
+  setRequest(request) {
+    this.handler.setRequest(request);
+    return this;
+  }
+  setRouting(routing) {
+    this.handler.setRouting(routing);
+    return this;
+  }
+  addQuery(query, time, connection) {
+    this.handler.addQuery(query, time, connection);
+    return this;
+  }
+  async handle(error, status = 500) {
+    if (this.isDevelopment)
+      return this.handler.handleError(error, status);
+    return new Response(renderProductionErrorPage(status), {
+      status,
+      headers: { "Content-Type": "text/html; charset=utf-8" }
+    });
+  }
+  notFound(message) {
+    const error = new HttpError(404, message || "The requested resource could not be found.");
+    return this.handle(error, 404);
+  }
+  serverError(error) {
+    return this.handle(error, 500);
+  }
+  forbidden(message) {
+    const error = new HttpError(403, message || "You do not have permission to access this resource.");
+    return this.handle(error, 403);
+  }
+  unauthorized(message) {
+    const error = new HttpError(401, message || "Authentication is required to access this resource.");
+    return this.handle(error, 401);
+  }
+  badRequest(message) {
+    const error = new HttpError(400, message || "The request was malformed or invalid.");
+    return this.handle(error, 400);
+  }
+  validationError(message) {
+    const error = new HttpError(422, message || "The request was well-formed but could not be processed.");
+    return this.handle(error, 422);
+  }
+  tooManyRequests(message) {
+    const error = new HttpError(429, message || "You have exceeded the rate limit.");
+    return this.handle(error, 429);
+  }
+  serviceUnavailable(message) {
+    const error = new HttpError(503, message || "The service is temporarily unavailable.");
+    return this.handle(error, 503);
+  }
+}
+export function createHttpErrorHandler(options) {
+  return new HttpErrorHandler(options);
+}
+export async function renderHttpError(error, request, options) {
+  const handler = createHttpErrorHandler({
+    isDevelopment: options?.isDevelopment,
+    config: options?.config
+  });
+  if (request)
+    handler.setRequest(request);
+  return handler.handle(error, options?.status);
+}
+export function errorMiddleware(options) {
+  const handler = createHttpErrorHandler(options);
+  return async (error, request) => {
+    handler.setRequest(request);
+    let status = 500;
+    if (error instanceof HttpError)
+      status = error.status;
+    else if ("status" in error && typeof error.status === "number")
+      status = error.status;
+    else if ("statusCode" in error && typeof error.statusCode === "number")
+      status = error.statusCode;
+    return handler.handle(error, status);
+  };
+}

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+// Result type exports
+export type {
+  Err,
+  Ok,
+  Result,
+  ResultAsync,
+} from 'ts-error-handling';
+// Error page exports (Ignition-style) - local implementation
+export type {
+  CodeSnippet,
+  EnvironmentContext,
+  ErrorPageConfig,
+  ErrorPageData,
+  HttpError as HttpErrorInfo,
+  HttpStatusCode,
+  JobContext,
+  QueryInfo,
+  RequestContext,
+  RoutingContext,
+  StackFrame,
+  UserContext,
+} from './error-page';
+export * from './handler';
+export * from './http';
+export * from './model';
+export * from './utils';
+export {
+  err,
+  fromPromise,
+  ok,
+} from 'ts-error-handling';
+export {
+  createErrorHandler,
+  ERROR_PAGE_CSS,
+  ErrorPageHandler,
+  errorResponse,
+  HTTP_ERRORS,
+  renderError,
+  renderErrorPage,
+  renderHttpErrorHints,
+  renderProductionErrorPage,
+} from './error-page';

package/dist/index.js

@@ -0,0 +1,20 @@
+export * from "./handler";
+export * from "./http";
+export * from "./model";
+export * from "./utils";
+export {
+  err,
+  fromPromise,
+  ok
+} from "ts-error-handling";
+export {
+  createErrorHandler,
+  ERROR_PAGE_CSS,
+  ErrorPageHandler,
+  errorResponse,
+  HTTP_ERRORS,
+  renderError,
+  renderErrorPage,
+  renderHttpErrorHints,
+  renderProductionErrorPage
+} from "./error-page";

package/dist/model.d.ts

@@ -0,0 +1,4 @@
+export declare class ModelNotFoundException extends Error {
+  public status: number;
+  constructor(status: number, message: string);
+}

package/dist/model.js

@@ -0,0 +1,8 @@
+export class ModelNotFoundException extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ModelNotFoundException";
+  }
+}

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function rescue<T, F>(fn: () => T | Promise<T>, fallback: F, onError?: (error: Error) => void): T | F | Promise<T | F>;

package/dist/utils.js

@@ -0,0 +1,17 @@
+import { ErrorHandler } from "./handler";
+export function rescue(fn, fallback, onError) {
+  try {
+    const result = fn();
+    if (result instanceof Promise)
+      return result.catch((error) => {
+        if (onError)
+          onError(ErrorHandler.handle(error));
+        return fallback;
+      });
+    return result;
+  } catch (error) {
+    if (onError)
+      onError(ErrorHandler.handle(error));
+    return fallback;
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/error-handling",
   "type": "module",
-  "version": "0.70.88",
+  "version": "0.70.91",
   "description": "Type safe error handling.",
   "author": "Chris Breuer",
   "contributors": [
@@ -57,12 +57,12 @@
     "ts-syntax-highlighter": "^0.2.1"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.88",
-    "@stacksjs/config": "0.70.88",
+    "@stacksjs/cli": "0.70.91",
+    "@stacksjs/config": "0.70.91",
     "better-dx": "^0.2.16",
-    "@stacksjs/path": "0.70.88",
-    "@stacksjs/types": "0.70.88",
-    "@stacksjs/validation": "0.70.88"
+    "@stacksjs/path": "0.70.91",
+    "@stacksjs/types": "0.70.91",
+    "@stacksjs/validation": "0.70.91"
   },
   "sideEffects": false
 }