hono-ban 0.2.5 → 0.2.7

package/src/__tests__/core/format-error.test.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect, mock } from "bun:test";
-import { formatError, createErrorResponse } from "../../core/format-error";
-import { createError } from "../../core/create-error";
-import type { BanError, ErrorFormatter } from "../../types";
-
-describe("formatError", () => {
-  it("calls the formatter with the error", () => {
-    const error = createError({ statusCode: 404, message: "Not found" });
-
-    const mockFormatter: ErrorFormatter = {
-      contentType: "application/json",
-      format: mock((err) => ({ formatted: true, status: err.status })),
-    };
-
-    const result = formatError(error, mockFormatter);
-
-    expect(mockFormatter.format).toHaveBeenCalledWith(
-      error,
-      undefined,
-      undefined,
-      undefined
-    );
-    expect(result).toEqual({ formatted: true, status: 404 });
-  });
-
-  it("passes options to the formatter", () => {
-    const error = createError({ statusCode: 500 });
-    const headers = { "X-Test": "value" };
-    const sanitize = ["password", "token"];
-
-    const mockFormatter: ErrorFormatter = {
-      contentType: "application/json",
-      format: mock(() => ({ formatted: true })),
-    };
-
-    formatError(error, mockFormatter, {
-      headers,
-      sanitize,
-      includeStackTrace: true,
-    });
-
-    expect(mockFormatter.format).toHaveBeenCalledWith(
-      error,
-      headers,
-      sanitize,
-      true
-    );
-  });
-});
-
-describe("createErrorResponse", () => {
-  it("creates a Response with the formatted error", () => {
-    const error = createError({ statusCode: 400, message: "Bad request" });
-    const formatted = { statusCode: 400, message: "Bad request" };
-
-    const response = createErrorResponse(error, formatted);
-
-    expect(response).toBeInstanceOf(Response);
-    expect(response.status).toBe(400);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-  });
-
-  it("includes custom headers from the error", () => {
-    const error = createError({
-      statusCode: 400,
-      headers: { "X-Custom": "value" },
-    });
-
-    const response = createErrorResponse(error, {});
-
-    expect(response.headers.get("X-Custom")).toBe("value");
-  });
-
-  it("adds Allow header for errors with allow property", () => {
-    const error = createError({
-      statusCode: 405,
-      allow: ["GET", "POST"],
-    });
-
-    const response = createErrorResponse(error, {});
-
-    expect(response.headers.get("Allow")).toBe("GET, POST");
-  });
-
-  it("sanitizes developer errors in production", async () => {
-    // Mock process.env.NODE_ENV
-    const originalNodeEnv = process.env.NODE_ENV;
-    process.env.NODE_ENV = "production";
-
-    try {
-      const error = createError({
-        statusCode: 500,
-        message: "Internal server error with sensitive details",
-        data: { isDeveloperError: true, sensitiveInfo: "secret" },
-      });
-
-      const formatted = {
-        statusCode: 500,
-        payload: {
-          message: "Original error message",
-          data: { sensitiveInfo: "secret" },
-        },
-      };
-
-      const response = createErrorResponse(error, formatted);
-
-      // Get the response body as text
-      const responseText = await response.text();
-      const body = JSON.parse(responseText) as {
-        statusCode: number;
-        payload: {
-          statusCode: number;
-          error: string;
-          message: string;
-          data?: unknown;
-        };
-      };
-
-      // Should use sanitized message
-      expect(body.payload.message).toBe("An internal server error occurred");
-      // Should not include sensitive data
-      expect(body.payload.data).toBeUndefined();
-    } finally {
-      // Restore original NODE_ENV
-      process.env.NODE_ENV = originalNodeEnv;
-    }
-  });
-
-  it("preserves the original formatted error in non-production", async () => {
-    // Mock process.env.NODE_ENV
-    const originalNodeEnv = process.env.NODE_ENV;
-    process.env.NODE_ENV = "development";
-
-    try {
-      const error = createError({
-        statusCode: 500,
-        message: "Detailed error",
-        data: { isDeveloperError: true, details: "stack trace" },
-      });
-
-      const formatted = {
-        statusCode: 500,
-        payload: {
-          message: "Detailed error",
-          data: { details: "stack trace" },
-        },
-      };
-
-      const response = createErrorResponse(error, formatted);
-
-      // Get the response body as text
-      const responseText = await response.text();
-      const responseJson = JSON.parse(responseText);
-
-      // The response body should match the original formatted error
-      expect(responseJson).toEqual(formatted);
-    } finally {
-      // Restore original NODE_ENV
-      process.env.NODE_ENV = originalNodeEnv;
-    }
-  });
-});

package/src/__tests__/factories/factories.test.ts

@@ -1,380 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import {
-  badRequest,
-  notFound,
-  unauthorized,
-  paymentRequired,
-  forbidden,
-  methodNotAllowed,
-  notAcceptable,
-  clientTimeout,
-  conflict,
-  resourceGone,
-  badData,
-  tooManyRequests,
-  teapot,
-  illegal,
-  lengthRequired,
-  preconditionFailed,
-  entityTooLarge,
-  uriTooLong,
-  unsupportedMediaType,
-  rangeNotSatisfiable,
-  expectationFailed,
-} from "../../factories/client-errors";
-import {
-  internal,
-  badImplementation,
-  serverUnavailable,
-  notImplemented,
-  badGateway,
-  gatewayTimeout,
-  httpVersionNotSupported,
-  insufficientStorage,
-  loopDetected,
-  variantAlsoNegotiates,
-  notExtended,
-  networkAuthRequired,
-} from "../../factories/server-errors";
-import { STATUS_CODES } from "../../constants";
-
-describe("Error factories", () => {
-  describe("Client error factories", () => {
-    it("creates a 400 Bad Request error", () => {
-      const error = badRequest();
-      expect(error.status).toBe(400);
-      expect(error.message).toBe(STATUS_CODES[400]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 401 Unauthorized error", () => {
-      const error = unauthorized();
-      expect(error.status).toBe(401);
-      expect(error.message).toBe(STATUS_CODES[401]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 402 Payment Required error", () => {
-      const error = paymentRequired();
-      expect(error.status).toBe(402);
-      expect(error.message).toBe(STATUS_CODES[402]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 403 Forbidden error", () => {
-      const error = forbidden();
-      expect(error.status).toBe(403);
-      expect(error.message).toBe(STATUS_CODES[403]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 404 Not Found error", () => {
-      const error = notFound();
-      expect(error.status).toBe(404);
-      expect(error.message).toBe(STATUS_CODES[404]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 405 Method Not Allowed error", () => {
-      const error = methodNotAllowed();
-      expect(error.status).toBe(405);
-      expect(error.message).toBe(STATUS_CODES[405]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 406 Not Acceptable error", () => {
-      const error = notAcceptable();
-      expect(error.status).toBe(406);
-      expect(error.message).toBe(STATUS_CODES[406]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 408 Request Timeout error", () => {
-      const error = clientTimeout();
-      expect(error.status).toBe(408);
-      expect(error.message).toBe(STATUS_CODES[408]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 409 Conflict error", () => {
-      const error = conflict();
-      expect(error.status).toBe(409);
-      expect(error.message).toBe(STATUS_CODES[409]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 410 Gone error", () => {
-      const error = resourceGone();
-      expect(error.status).toBe(410);
-      expect(error.message).toBe(STATUS_CODES[410]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 411 Length Required error", () => {
-      const error = lengthRequired();
-      expect(error.status).toBe(411);
-      expect(error.message).toBe(STATUS_CODES[411]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 412 Precondition Failed error", () => {
-      const error = preconditionFailed();
-      expect(error.status).toBe(412);
-      expect(error.message).toBe(STATUS_CODES[412]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 413 Payload Too Large error", () => {
-      const error = entityTooLarge();
-      expect(error.status).toBe(413);
-      expect(error.message).toBe(STATUS_CODES[413]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 414 URI Too Long error", () => {
-      const error = uriTooLong();
-      expect(error.status).toBe(414);
-      expect(error.message).toBe(STATUS_CODES[414]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 415 Unsupported Media Type error", () => {
-      const error = unsupportedMediaType();
-      expect(error.status).toBe(415);
-      expect(error.message).toBe(STATUS_CODES[415]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 416 Range Not Satisfiable error", () => {
-      const error = rangeNotSatisfiable();
-      expect(error.status).toBe(416);
-      expect(error.message).toBe(STATUS_CODES[416]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 417 Expectation Failed error", () => {
-      const error = expectationFailed();
-      expect(error.status).toBe(417);
-      expect(error.message).toBe(STATUS_CODES[417]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 418 I'm a Teapot error", () => {
-      const error = teapot();
-      expect(error.status).toBe(418);
-      expect(error.message).toBe(STATUS_CODES[418]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 422 Unprocessable Entity error", () => {
-      const error = badData();
-      expect(error.status).toBe(422);
-      expect(error.message).toBe(STATUS_CODES[422]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 429 Too Many Requests error", () => {
-      const error = tooManyRequests();
-      expect(error.status).toBe(429);
-      expect(error.message).toBe(STATUS_CODES[429]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 451 Unavailable For Legal Reasons error", () => {
-      const error = illegal();
-      expect(error.status).toBe(451);
-      expect(error.message).toBe(STATUS_CODES[451]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("accepts a custom message", () => {
-      const message = "Custom error message";
-      const error = unauthorized(message);
-      expect(error.status).toBe(401);
-      expect(error.message).toBe(message);
-    });
-
-    it("accepts options object", () => {
-      const options = {
-        message: "Custom message",
-        data: { field: "test" },
-        headers: { "X-Custom": "value" },
-      };
-
-      const error = badRequest(options);
-
-      expect(error.status).toBe(400);
-      expect(error.message).toBe(options.message);
-      expect(error.data).toEqual(options.data);
-      expect(error.headers).toEqual(options.headers);
-    });
-
-    it("accepts message and options separately", () => {
-      const message = "Custom message";
-      const options = {
-        data: { field: "test" },
-        headers: { "X-Custom": "value" },
-      };
-
-      const error = notFound(message, options);
-
-      expect(error.status).toBe(404);
-      expect(error.message).toBe(message);
-      expect(error.data).toEqual(options.data);
-      expect(error.headers).toEqual(options.headers);
-    });
-  });
-
-  describe("Server error factories", () => {
-    it("creates a 500 Internal Server Error", () => {
-      const error = internal();
-      expect(error.status).toBe(500);
-      expect(error.message).toBe(STATUS_CODES[500]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 501 Not Implemented error", () => {
-      const error = notImplemented();
-      expect(error.status).toBe(501);
-      expect(error.message).toBe(STATUS_CODES[501]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 502 Bad Gateway error", () => {
-      const error = badGateway();
-      expect(error.status).toBe(502);
-      expect(error.message).toBe(STATUS_CODES[502]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 503 Service Unavailable error", () => {
-      const error = serverUnavailable();
-      expect(error.status).toBe(503);
-      expect(error.message).toBe(STATUS_CODES[503]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 504 Gateway Timeout error", () => {
-      const error = gatewayTimeout();
-      expect(error.status).toBe(504);
-      expect(error.message).toBe(STATUS_CODES[504]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 505 HTTP Version Not Supported error", () => {
-      const error = httpVersionNotSupported();
-      expect(error.status).toBe(505);
-      expect(error.message).toBe(STATUS_CODES[505]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 507 Insufficient Storage error", () => {
-      const error = insufficientStorage();
-      expect(error.status).toBe(507);
-      expect(error.message).toBe(STATUS_CODES[507]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 508 Loop Detected error", () => {
-      const error = loopDetected();
-      expect(error.status).toBe(508);
-      expect(error.message).toBe(STATUS_CODES[508]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 506 Variant Also Negotiates error", () => {
-      const error = variantAlsoNegotiates();
-      expect(error.status).toBe(506);
-      expect(error.message).toBe(STATUS_CODES[506]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 510 Not Extended error", () => {
-      const error = notExtended();
-      expect(error.status).toBe(510);
-      expect(error.message).toBe(STATUS_CODES[510]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("creates a 511 Network Authentication Required error", () => {
-      const error = networkAuthRequired();
-      expect(error.status).toBe(511);
-      expect(error.message).toBe(STATUS_CODES[511]);
-      expect(error.isBan).toBe(true);
-    });
-
-    it("accepts a custom message", () => {
-      const message = "Custom error message";
-      const error = internal(message);
-      expect(error.status).toBe(500);
-      expect(error.message).toBe(message);
-    });
-
-    it("accepts options object", () => {
-      const options = {
-        message: "Custom message",
-        data: { field: "test" },
-        headers: { "X-Custom": "value" },
-      };
-
-      const error = serverUnavailable(options);
-
-      expect(error.status).toBe(503);
-      expect(error.message).toBe(options.message);
-      expect(error.data).toEqual(options.data);
-      expect(error.headers).toEqual(options.headers);
-    });
-
-    it("accepts message and options separately", () => {
-      const message = "Custom message";
-      const options = {
-        data: { field: "test" },
-        headers: { "X-Custom": "value" },
-      };
-
-      const error = internal(message, options);
-
-      expect(error.status).toBe(500);
-      expect(error.message).toBe(message);
-      expect(error.data).toEqual(options.data);
-      expect(error.headers).toEqual(options.headers);
-    });
-  });
-
-  describe("badImplementation", () => {
-    it("creates a developer error", () => {
-      const error = badImplementation();
-
-      expect(error.status).toBe(500);
-      expect(error.message).toBe(STATUS_CODES[500]);
-      expect(error.data).toEqual({ isDeveloperError: true });
-    });
-
-    it("merges custom data with isDeveloperError flag", () => {
-      const error = badImplementation({
-        data: { field: "test" },
-      });
-
-      // Use type assertion to check the data structure
-      const data = error.data as { isDeveloperError: boolean; field: string };
-      expect(data.isDeveloperError).toBe(true);
-      expect(data.field).toBe("test");
-    });
-
-    it("accepts message and options separately", () => {
-      const message = "Developer error";
-      const options = {
-        data: { field: "test" },
-      };
-
-      const error = badImplementation(message, options);
-
-      expect(error.status).toBe(500);
-      expect(error.message).toBe(message);
-      // Use type assertion to check the data structure
-      const data = error.data as { isDeveloperError: boolean; field: string };
-      expect(data.isDeveloperError).toBe(true);
-      expect(data.field).toBe("test");
-    });
-  });
-});

package/src/__tests__/formatters/default-formatter.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { defaultFormatter } from "../../formatters/default";
-import { createError } from "../../core/create-error";
-import { STATUS_CODES } from "../../constants";
-
-describe("defaultFormatter", () => {
-  it("has the correct content type", () => {
-    expect(defaultFormatter.contentType).toBe("application/json");
-  });
-
-  it("formats a basic error", () => {
-    const error = createError({ statusCode: 404, message: "Not found" });
-    const formatted = defaultFormatter.format(error);
-
-    expect(formatted).toEqual({
-      statusCode: 404,
-      payload: {
-        statusCode: 404,
-        error: STATUS_CODES[404],
-        message: "Not found",
-      },
-    });
-  });
-
-  it("passes custom headers to the formatter but doesn't include them in output", () => {
-    const error = createError({ statusCode: 400 });
-    const headers = { "X-Custom": "value" };
-
-    const formatted = defaultFormatter.format(error, headers);
-
-    // Headers should not be in the formatted output
-    expect((formatted as any).headers).toBeUndefined();
-  });
-
-  it("doesn't add the Allow header to the response body", () => {
-    const error = createError({
-      statusCode: 405,
-      allow: ["GET", "POST"],
-    });
-
-    const formatted = defaultFormatter.format(error);
-
-    // The formatted output should not have headers
-    expect((formatted as any).headers).toBeUndefined();
-  });
-
-  it("includes stack trace when includeStackTrace is true", () => {
-    const error = createError({ statusCode: 500 });
-    const formatted = defaultFormatter.format(error, {}, [], true);
-
-    expect(formatted.payload.stack).toBeDefined();
-  });
-
-  it("includes stack trace for developer errors", () => {
-    const error = createError({
-      statusCode: 500,
-      data: { isDeveloperError: true },
-    });
-
-    const formatted = defaultFormatter.format(error);
-
-    expect(formatted.payload.stack).toBeDefined();
-  });
-
-  it("includes cause stack when available", () => {
-    const cause = new Error("Original error");
-    const error = createError({
-      statusCode: 500,
-      cause,
-    });
-
-    const formatted = defaultFormatter.format(error, {}, [], true);
-
-    expect(formatted.payload.causeStack).toBeDefined();
-  });
-
-  it("includes error data when provided", () => {
-    const data = { field: "email", reason: "invalid format" };
-    const error = createError({
-      statusCode: 400,
-      data,
-    });
-
-    const formatted = defaultFormatter.format(error);
-
-    expect(formatted.payload.data).toEqual(data);
-  });
-
-  it("sanitizes specified fields", () => {
-    const data = {
-      user: {
-        id: 123,
-        password: "secret",
-        email: "user@example.com",
-        profile: {
-          token: "abc123",
-        },
-      },
-    };
-
-    const error = createError({
-      statusCode: 400,
-      data,
-    });
-
-    const formatted = defaultFormatter.format(error, {}, ["password", "token"]);
-
-    // Data should be sanitized
-    expect(formatted.payload.data).toEqual({
-      user: {
-        id: 123,
-        email: "user@example.com",
-        profile: {},
-      },
-    });
-  });
-});

package/src/__tests__/middleware/README.md

@@ -1,49 +0,0 @@
-# Middleware Tests
-
-## Ban Middleware Tests
-
-The tests for the `ban-middleware.ts` file are currently disabled (renamed to `ban-middleware.test.ts.disabled`) due to a known issue with Bun's testing framework. There's a bug related to mocking in Bun that causes errors when testing middleware.
-
-### Error Details
-
-When running the middleware tests, the following error occurs:
-
-```
-# Unhandled error between tests
--------------------------------
-1 | (function (entry fetcher)
-              ^
-SyntaxError: export 'ErrorFormatter' not found in '../types'
--------------------------------
-```
-
-### Possible Workarounds
-
-For future implementation, consider these workarounds:
-
-- Using [bun-bagel](https://github.com/DRFR0ST/bun-bagel)
-- Using [bun-mock-fetch](https://github.com/aryzing/bun-mock-fetch)
-- Using `spyOn` for global.fetch:
-
-```typescript
-const mockFetch = spyOn(globalThis, "fetch");
-
-beforeEach(() => {
-  mockFetch.mockReset();
-});
-
-afterAll(() => {
-  mockFetch.mockRestore();
-});
-
-test("fetches example.com", () => {
-  mockFetch.mockImplementation(async (url, opts) => {
-    // Test implementation
-    return new Response('{"success":true}');
-  });
-
-  // Test code
-});
-```
-
-These tests should be re-enabled when the Bun testing framework is more stable.