@b9g/http-errors 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@b9g/http-errors",
+  "version": "0.1.0",
+  "description": "HTTP error classes for web applications",
+  "keywords": [
+    "http",
+    "errors",
+    "web",
+    "status-codes"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "@b9g/libuild": "^0.1.10",
+    "bun-types": "latest"
+  },
+  "type": "module",
+  "types": "src/index.d.ts",
+  "module": "src/index.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./package.json": "./package.json",
+    "./index": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./index.js": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    }
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Modern HTTP error classes for Shovel
+ * Lightweight alternative to http-errors with native Error cause support
+ */
+/**
+ * Options for creating HTTP errors
+ */
+export interface HTTPErrorOptions {
+    /** Original error that caused this HTTP error */
+    cause?: Error;
+    /** Custom headers to include in the error */
+    headers?: Record<string, string>;
+    /** Whether the error details should be exposed to clients (defaults based on status) */
+    expose?: boolean;
+    /** Additional properties to attach to the error */
+    [key: string]: any;
+}
+/**
+ * Base HTTP error class
+ */
+export declare class HTTPError extends Error {
+    readonly status: number;
+    readonly statusCode: number;
+    readonly expose: boolean;
+    readonly headers?: Record<string, string>;
+    constructor(status: number, message?: string, options?: HTTPErrorOptions);
+    /**
+     * Convert error to a plain object for serialization
+     */
+    toJSON(): {
+        name: string;
+        message: string;
+        status: number;
+        statusCode: number;
+        expose: boolean;
+        headers: Record<string, string>;
+    };
+    /**
+     * Create a Response object from this error
+     */
+    toResponse(): Response;
+}
+/**
+ * Special error for middleware fallthrough (not an HTTP error)
+ */
+export declare class NotHandled extends Error {
+    constructor(message?: string);
+}
+/**
+ * Check if a value is an HTTP error
+ */
+export declare function isHTTPError(value: any): value is HTTPError;
+/**
+ * Create an HTTP error with the given status code
+ */
+export declare function createHTTPError(status: number, message?: string, options?: HTTPErrorOptions): HTTPError;
+export declare class BadRequest extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class Unauthorized extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class Forbidden extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class NotFound extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class MethodNotAllowed extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class Conflict extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class UnprocessableEntity extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class TooManyRequests extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class InternalServerError extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class NotImplemented extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class BadGateway extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class ServiceUnavailable extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export declare class GatewayTimeout extends HTTPError {
+    constructor(message?: string, options?: HTTPErrorOptions);
+}
+export default createHTTPError;

package/src/index.js

@@ -0,0 +1,183 @@
+/// <reference types="./index.d.ts" />
+// src/index.ts
+var STATUS_CODES = {
+  // 4xx Client Errors
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a Teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  // 5xx Server Errors
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+var HTTPError = class extends Error {
+  status;
+  statusCode;
+  expose;
+  headers;
+  constructor(status, message, options = {}) {
+    const defaultMessage = STATUS_CODES[status] || "Unknown Error";
+    super(message || defaultMessage, { cause: options.cause });
+    this.name = this.constructor.name;
+    this.status = this.statusCode = status;
+    this.expose = options.expose ?? status < 500;
+    this.headers = options.headers;
+    Object.assign(this, options);
+  }
+  /**
+   * Convert error to a plain object for serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      statusCode: this.statusCode,
+      expose: this.expose,
+      headers: this.headers
+    };
+  }
+  /**
+   * Create a Response object from this error
+   */
+  toResponse() {
+    const body = this.expose ? this.message : STATUS_CODES[this.status];
+    return new Response(body, {
+      status: this.status,
+      statusText: STATUS_CODES[this.status],
+      headers: this.headers
+    });
+  }
+};
+var NotHandled = class extends Error {
+  constructor(message = "Request not handled by middleware") {
+    super(message);
+    this.name = "NotHandled";
+  }
+};
+function isHTTPError(value) {
+  return value instanceof HTTPError || value instanceof Error && typeof value.status === "number" && typeof value.statusCode === "number" && value.status === value.statusCode;
+}
+function createHTTPError(status, message, options) {
+  return new HTTPError(status, message, options);
+}
+var BadRequest = class extends HTTPError {
+  constructor(message, options) {
+    super(400, message, options);
+  }
+};
+var Unauthorized = class extends HTTPError {
+  constructor(message, options) {
+    super(401, message, options);
+  }
+};
+var Forbidden = class extends HTTPError {
+  constructor(message, options) {
+    super(403, message, options);
+  }
+};
+var NotFound = class extends HTTPError {
+  constructor(message, options) {
+    super(404, message, options);
+  }
+};
+var MethodNotAllowed = class extends HTTPError {
+  constructor(message, options) {
+    super(405, message, options);
+  }
+};
+var Conflict = class extends HTTPError {
+  constructor(message, options) {
+    super(409, message, options);
+  }
+};
+var UnprocessableEntity = class extends HTTPError {
+  constructor(message, options) {
+    super(422, message, options);
+  }
+};
+var TooManyRequests = class extends HTTPError {
+  constructor(message, options) {
+    super(429, message, options);
+  }
+};
+var InternalServerError = class extends HTTPError {
+  constructor(message, options) {
+    super(500, message, options);
+  }
+};
+var NotImplemented = class extends HTTPError {
+  constructor(message, options) {
+    super(501, message, options);
+  }
+};
+var BadGateway = class extends HTTPError {
+  constructor(message, options) {
+    super(502, message, options);
+  }
+};
+var ServiceUnavailable = class extends HTTPError {
+  constructor(message, options) {
+    super(503, message, options);
+  }
+};
+var GatewayTimeout = class extends HTTPError {
+  constructor(message, options) {
+    super(504, message, options);
+  }
+};
+var src_default = createHTTPError;
+export {
+  BadGateway,
+  BadRequest,
+  Conflict,
+  Forbidden,
+  GatewayTimeout,
+  HTTPError,
+  InternalServerError,
+  MethodNotAllowed,
+  NotFound,
+  NotHandled,
+  NotImplemented,
+  ServiceUnavailable,
+  TooManyRequests,
+  Unauthorized,
+  UnprocessableEntity,
+  createHTTPError,
+  src_default as default,
+  isHTTPError
+};