@stacksjs/error-handling 0.70.87 → 0.70.88

package/dist/handler.js

@@ -1,108 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,42 +0,0 @@
-// 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

@@ -1,20 +0,0 @@
-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

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

package/dist/model.js

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

package/dist/utils.d.ts

@@ -1 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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;
-  }
-}