hono-ban 0.2.4 → 0.2.6

package/src/__tests__/utils/validate.test.ts

@@ -1,35 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { validateStatusCode } from "../../utils/validate";
-
-describe("validateStatusCode", () => {
-  it("returns the same code for valid error status codes", () => {
-    expect(validateStatusCode(400)).toBe(400);
-    expect(validateStatusCode(404)).toBe(404);
-    expect(validateStatusCode(500)).toBe(500);
-    expect(validateStatusCode(503)).toBe(503);
-  });
-
-  it("returns 500 for status codes below 400", () => {
-    expect(validateStatusCode(100)).toBe(500);
-    expect(validateStatusCode(200)).toBe(500);
-    expect(validateStatusCode(300)).toBe(500);
-    expect(validateStatusCode(399)).toBe(500);
-  });
-
-  it("returns 500 for status codes at or above 600", () => {
-    expect(validateStatusCode(600)).toBe(500);
-    expect(validateStatusCode(700)).toBe(500);
-    expect(validateStatusCode(999)).toBe(500);
-  });
-
-  it("handles edge cases", () => {
-    // @ts-expect-error - Testing with invalid input
-    expect(validateStatusCode(null)).toBe(500);
-    // @ts-expect-error - Testing with invalid input
-    expect(validateStatusCode(undefined)).toBe(500);
-    // @ts-expect-error - Testing with invalid input
-    expect(validateStatusCode("400")).toBe(500);
-
-    expect(validateStatusCode(NaN)).toBe(500);
-  });
-});

package/src/constants/index.ts

@@ -1,6 +0,0 @@
-/**
- * Constants exports
- * @module hono-ban/constants
- */
-
-export * from "./status-codes";

package/src/constants/status-codes.ts

@@ -1,52 +0,0 @@
-/**
- * HTTP status code constants
- * @module hono-ban/constants/status-codes
- */
-
-import type { ErrorStatusCode } from "../types/error";
-
-/**
- * Map of HTTP error status codes to their default messages
- */
-export const STATUS_CODES: Record<ErrorStatusCode, string> = {
-  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",
-  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",
-};

package/src/core/convert-error.ts

@@ -1,74 +0,0 @@
-/**
- * Error conversion utilities
- * @module hono-ban/core/convert-error
- */
-
-import type { BanError, BanOptions } from "../types";
-import { createError } from "./create-error";
-
-/**
- * Type guard to check if a value is a BanError
- * @param err - Value to check
- * @param statusCode - Optional status code to match
- */
-export function isBanError(err: unknown, statusCode?: number): err is BanError {
-  return (
-    typeof err === "object" &&
-    err !== null &&
-    "isBan" in err &&
-    err.isBan === true &&
-    (!statusCode || (err as BanError).status === statusCode)
-  );
-}
-
-/**
- * Convert any error into a BanError
- * @param err - Error to convert
- * @param options - Additional options
- */
-export function convertToBanError<T = unknown>(
-  err: unknown,
-  options: BanOptions<T> = {}
-): BanError<T> {
-  // If already a BanError, merge options
-  if (isBanError(err)) {
-    const merged: BanError<T> = {
-      status: options.statusCode ?? err.status,
-      message: options.message ?? err.message,
-      isBan: true,
-      data: (options.data !== undefined ? options.data : err.data) as
-        | T
-        | undefined,
-      headers: {
-        ...err.headers,
-        ...options.headers,
-      },
-      allow: options.allow
-        ? Array.isArray(options.allow)
-          ? [...options.allow]
-          : [options.allow]
-        : err.allow,
-      cause: options.cause ?? err.cause,
-      stack: err.stack,
-    };
-
-    return merged;
-  }
-
-  // Convert Error instance
-  if (err instanceof Error) {
-    return createError<T>({
-      ...options,
-      message: options.message ?? err.message,
-      cause: err,
-    });
-  }
-
-  // Handle unknown error types
-  return createError<T>({
-    ...options,
-    message:
-      options.message ?? (typeof err === "string" ? err : "Unknown error"),
-    cause: err,
-  });
-}

package/src/core/create-error.ts

@@ -1,65 +0,0 @@
-/**
- * Error creation utilities
- * @module hono-ban/core/create-error
- */
-
-import { STATUS_CODES } from "../constants/status-codes";
-import type { BanError, BanOptions } from "../types";
-import { validateStatusCode } from "../utils/validate";
-
-/**
- * Create a new error object with the given options
- * @param options - Error creation options
- * @returns A BanError object
- *
- * @example
- * // Basic usage
- * const error = createError({ statusCode: 404, message: "User not found" });
- *
- * @example
- * // With custom data
- * const error = createError({
- *   statusCode: 400,
- *   message: "Validation failed",
- *   data: { field: "email", issue: "invalid format" }
- * });
- */
-export function createError<T = unknown>(options: BanOptions<T>): BanError<T> {
-  // Validate and normalize status code
-  const status = validateStatusCode(options.statusCode ?? 500);
-
-  // Create the error object
-  const error: BanError<T> = {
-    status,
-    message: options.message ?? STATUS_CODES[status],
-    isBan: true,
-  };
-
-  // Add optional properties
-  if (options.data !== undefined) {
-    error.data = options.data;
-  }
-
-  if (options.headers) {
-    error.headers = { ...options.headers };
-  }
-
-  if (options.allow) {
-    error.allow = Array.isArray(options.allow)
-      ? [...options.allow]
-      : [options.allow];
-  }
-
-  if (options.cause) {
-    error.cause = options.cause;
-    // Keep cause stack separately rather than overwriting the main stack
-    if (options.cause instanceof Error) {
-      error.causeStack = options.cause.stack;
-    }
-  }
-
-  // Always capture a fresh stack trace for the BanError itself
-  Error.captureStackTrace(error, createError);
-
-  return error;
-}

package/src/core/format-error.ts

@@ -1,76 +0,0 @@
-/**
- * Error formatting utilities
- * @module hono-ban/core/format-error
- */
-
-import { STATUS_CODES } from "../constants";
-import type { BanError, ErrorFormatter, FormatOptions } from "../types";
-
-/**
- * Format an error using the provided formatter
- * @param error - Error to format
- * @param formatter - Formatter to use
- * @param options - Formatting options
- */
-export function formatError(
-  error: BanError,
-  formatter: ErrorFormatter,
-  options: FormatOptions = {}
-): unknown {
-  // Directly format the error without caching
-  return formatter.format(
-    error,
-    options.headers,
-    options.sanitize,
-    options.includeStackTrace
-  );
-}
-
-/**
- * Create a Response object from a formatted error
- * @param error - Error to create response from
- * @param formatted - Formatted error output
- */
-export function createErrorResponse(
-  error: BanError,
-  formatted: unknown
-): Response {
-  const headers = new Headers({
-    "Content-Type": "application/json",
-    ...error.headers,
-  });
-
-  if (error.allow?.length) {
-    headers.set("Allow", error.allow.join(", "));
-  }
-
-  // Check if this is a developer error in production
-  const isDeveloperError =
-    error.data &&
-    typeof error.data === "object" &&
-    "isDeveloperError" in error.data &&
-    error.data.isDeveloperError === true;
-
-  // Sanitize developer errors in production
-  if (isDeveloperError && process.env.NODE_ENV === "production") {
-    // Create a sanitized version without sensitive data
-    const sanitizedFormatted = {
-      statusCode: error.status,
-      payload: {
-        statusCode: error.status,
-        error: STATUS_CODES[error.status],
-        message: "An internal server error occurred",
-      },
-    };
-
-    return new Response(JSON.stringify(sanitizedFormatted), {
-      status: error.status,
-      headers,
-    });
-  }
-
-  return new Response(JSON.stringify(formatted), {
-    status: error.status,
-    headers,
-  });
-}

package/src/core/index.ts

@@ -1,8 +0,0 @@
-/**
- * Core functionality exports
- * @module hono-ban/core
- */
-
-export * from "./create-error";
-export * from "./convert-error";
-export * from "./format-error";