hono-ban 0.2.4 → 0.2.6

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.

package/src/__tests__/middleware/ban-middleware.test.ts.disabled

@@ -1,23 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { ban } from "../../middleware/ban-middleware";
-
-/**
- * NOTE: Full middleware tests are currently 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.
- *
- * Possible workarounds for future implementation include:
- * - 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
- *
- * These tests should be expanded when the Bun testing framework is more stable.
- */
-
-describe("ban middleware", () => {
-  it("exports a function", () => {
-    expect(typeof ban).toBe("function");
-  });
-
-  // Additional tests are disabled due to Bun testing framework issues
-  // See the note above for more information
-});

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

@@ -1,117 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { sanitizeObject } from "../../utils/sanitize";
-
-describe("sanitizeObject", () => {
-  it("returns the original object if no keys to remove", () => {
-    const obj = { a: 1, b: 2, c: 3 };
-    expect(sanitizeObject(obj, [])).toBe(obj);
-  });
-
-  it("removes specified keys from a simple object", () => {
-    const obj = { a: 1, b: 2, c: 3, password: "secret" };
-    const result = sanitizeObject(obj, ["password"]) as Record<string, unknown>;
-
-    expect(result).toEqual({ a: 1, b: 2, c: 3 });
-    expect("password" in result).toBe(false);
-  });
-
-  it("removes multiple specified keys", () => {
-    const obj = {
-      a: 1,
-      password: "secret",
-      token: "abc123",
-      username: "user",
-    };
-
-    const result = sanitizeObject(obj, ["password", "token"]) as Record<
-      string,
-      unknown
-    >;
-
-    expect(result).toEqual({ a: 1, username: "user" });
-    expect("password" in result).toBe(false);
-    expect("token" in result).toBe(false);
-  });
-
-  it("handles nested objects", () => {
-    const obj = {
-      user: {
-        name: "John",
-        password: "secret",
-        profile: {
-          bio: "Developer",
-          token: "xyz789",
-        },
-      },
-      settings: {
-        theme: "dark",
-        token: "abc123",
-      },
-    };
-
-    const result = sanitizeObject(obj, ["password", "token"]);
-
-    expect(result).toEqual({
-      user: {
-        name: "John",
-        profile: {
-          bio: "Developer",
-        },
-      },
-      settings: {
-        theme: "dark",
-      },
-    });
-  });
-
-  it("handles arrays", () => {
-    const arr = [
-      { id: 1, name: "Item 1", token: "abc" },
-      { id: 2, name: "Item 2", password: "secret" },
-      { id: 3, name: "Item 3" },
-    ];
-
-    const result = sanitizeObject(arr, ["token", "password"]);
-
-    expect(result).toEqual([
-      { id: 1, name: "Item 1" },
-      { id: 2, name: "Item 2" },
-      { id: 3, name: "Item 3" },
-    ]);
-  });
-
-  it("handles arrays within objects", () => {
-    const obj = {
-      users: [
-        { id: 1, name: "User 1", password: "pass1" },
-        { id: 2, name: "User 2", password: "pass2" },
-      ],
-      settings: { token: "abc123" },
-    };
-
-    const result = sanitizeObject(obj, ["password", "token"]);
-
-    expect(result).toEqual({
-      users: [
-        { id: 1, name: "User 1" },
-        { id: 2, name: "User 2" },
-      ],
-      settings: {},
-    });
-  });
-
-  it("handles primitive values", () => {
-    expect(sanitizeObject("string", ["key"])).toBe("string");
-    expect(sanitizeObject(123, ["key"])).toBe(123);
-    expect(sanitizeObject(true, ["key"])).toBe(true);
-    expect(sanitizeObject(null, ["key"])).toBe(null);
-    expect(sanitizeObject(undefined, ["key"])).toBe(undefined);
-  });
-
-  it("returns empty object when all keys are removed", () => {
-    const obj = { password: "secret", token: "abc123" };
-    const result = sanitizeObject(obj, ["password", "token"]);
-
-    expect(result).toEqual({});
-  });
-});