@logtape/hono 1.3.0 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/hono",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Hono adapter for LogTape logging library",
   "keywords": [
     "logging",
@@ -50,9 +50,12 @@
     "./package.json": "./package.json"
   },
   "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
   "peerDependencies": {
     "hono": "^4.0.0",
-    "@logtape/logtape": "^1.3.0"
+    "@logtape/logtape": "^1.3.2"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",

package/deno.json

@@ -1,34 +0,0 @@
-{
-  "name": "@logtape/hono",
-  "version": "1.3.0",
-  "license": "MIT",
-  "exports": "./src/mod.ts",
-  "exclude": [
-    "coverage/",
-    "npm/",
-    "dist/"
-  ],
-  "tasks": {
-    "build": "pnpm build",
-    "test": "deno test --allow-env --allow-sys --allow-net",
-    "test:node": {
-      "dependencies": [
-        "build"
-      ],
-      "command": "node --experimental-transform-types --test"
-    },
-    "test:bun": {
-      "dependencies": [
-        "build"
-      ],
-      "command": "bun test"
-    },
-    "test-all": {
-      "dependencies": [
-        "test",
-        "test:node",
-        "test:bun"
-      ]
-    }
-  }
-}

package/src/mod.test.ts

@@ -1,670 +0,0 @@
-import { suite } from "@alinea/suite";
-import { assert, assertEquals, assertExists } from "@std/assert";
-import { configure, type LogRecord, reset } from "@logtape/logtape";
-import { Hono } from "hono";
-import { honoLogger } from "./mod.ts";
-
-const test = suite(import.meta);
-
-// Test fixture: Collect log records, filtering out internal LogTape meta logs
-function createTestSink(): {
-  sink: (record: LogRecord) => void;
-  logs: LogRecord[];
-} {
-  const logs: LogRecord[] = [];
-  return {
-    sink: (record: LogRecord) => {
-      if (record.category[0] !== "logtape") {
-        logs.push(record);
-      }
-    },
-    logs,
-  };
-}
-
-// Setup helper
-async function setupLogtape(): Promise<{
-  logs: LogRecord[];
-  cleanup: () => Promise<void>;
-}> {
-  const { sink, logs } = createTestSink();
-  await configure({
-    sinks: { test: sink },
-    loggers: [{ category: [], sinks: ["test"] }],
-  });
-  return { logs, cleanup: () => reset() };
-}
-
-// ============================================
-// Basic Middleware Creation Tests
-// ============================================
-
-test("honoLogger(): creates a middleware function", async () => {
-  const { cleanup } = await setupLogtape();
-  try {
-    const middleware = honoLogger();
-    assertEquals(typeof middleware, "function");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): logs request after response", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-
-    const res = await app.request("/test");
-    assertEquals(res.status, 200);
-    assertEquals(logs.length, 1);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Category Configuration Tests
-// ============================================
-
-test("honoLogger(): uses default category ['hono']", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["hono"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): uses custom category array", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ category: ["myapp", "http"] }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["myapp", "http"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): accepts string category", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ category: "myapp" }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["myapp"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Log Level Tests
-// ============================================
-
-test("honoLogger(): uses default log level 'info'", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "info");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): uses custom log level 'debug'", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ level: "debug" }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "debug");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): uses custom log level 'warning'", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ level: "warning" }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "warning");
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Combined (default)
-// ============================================
-
-test("honoLogger(): combined format logs structured properties", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ format: "combined" }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test", {
-      headers: {
-        "User-Agent": "test-agent/1.0",
-        "Referer": "http://example.com",
-      },
-    });
-
-    assertEquals(logs.length, 1);
-    const props = logs[0].properties;
-    assertEquals(props.method, "GET");
-    assert((props.url as string).includes("/test"));
-    assertEquals(props.path, "/test");
-    assertEquals(props.status, 200);
-    assertExists(props.responseTime);
-    assertEquals(props.userAgent, "test-agent/1.0");
-    assertEquals(props.referrer, "http://example.com");
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Common
-// ============================================
-
-test("honoLogger(): common format excludes referrer and userAgent", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ format: "common" }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test", {
-      headers: {
-        "User-Agent": "test-agent/1.0",
-        "Referer": "http://example.com",
-      },
-    });
-
-    assertEquals(logs.length, 1);
-    const props = logs[0].properties;
-    assertEquals(props.method, "GET");
-    assertEquals(props.path, "/test");
-    assertEquals(props.status, 200);
-    assertEquals(props.referrer, undefined);
-    assertEquals(props.userAgent, undefined);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Dev
-// ============================================
-
-test("honoLogger(): dev format returns string message", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ format: "dev" }));
-    app.post("/api/users", (c) => {
-      c.status(201);
-      return c.text("Created");
-    });
-
-    await app.request("/api/users", { method: "POST" });
-
-    assertEquals(logs.length, 1);
-    const msg = logs[0].rawMessage;
-    assert(msg.includes("POST"));
-    assert(msg.includes("/api/users"));
-    assert(msg.includes("201"));
-    assert(msg.includes("ms"));
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Short
-// ============================================
-
-test("honoLogger(): short format includes url", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ format: "short" }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    const msg = logs[0].rawMessage;
-    assert(msg.includes("GET"));
-    assert(msg.includes("/test"));
-    assert(msg.includes("200"));
-    assert(msg.includes("ms"));
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Tiny
-// ============================================
-
-test("honoLogger(): tiny format is minimal", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ format: "tiny" }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    const res = await app.request("/test");
-    assertEquals(res.status, 200);
-
-    assertEquals(logs.length, 1);
-    const msg = logs[0].rawMessage;
-    assert(msg.includes("GET"));
-    assert(msg.includes("/test"));
-    assert(msg.includes("200"));
-    assert(msg.includes("ms"));
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Custom Format Function Tests
-// ============================================
-
-test("honoLogger(): custom format returning string", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({
-      format: (c, _responseTime) => `Custom: ${c.req.method} ${c.res.status}`,
-    }));
-    app.delete("/test", (c) => {
-      c.status(204);
-      return c.body(null);
-    });
-
-    await app.request("/test", { method: "DELETE" });
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].rawMessage, "Custom: DELETE 204");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): custom format returning object", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({
-      format: (c, responseTime) => ({
-        customMethod: c.req.method,
-        customStatus: c.res.status,
-        customDuration: responseTime,
-      }),
-    }));
-    app.patch("/test", (c) => {
-      c.status(202);
-      return c.text("Accepted");
-    });
-
-    await app.request("/test", { method: "PATCH" });
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.customMethod, "PATCH");
-    assertEquals(logs[0].properties.customStatus, 202);
-    assertExists(logs[0].properties.customDuration);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Skip Function Tests
-// ============================================
-
-test("honoLogger(): skip function prevents logging when returns true", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({
-      skip: () => true,
-    }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 0);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): skip function allows logging when returns false", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({
-      skip: () => false,
-    }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): skip function receives context", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({
-      skip: (c) => c.req.path === "/health",
-    }));
-    app.get("/test", (c) => c.text("Hello"));
-    app.get("/health", (c) => c.text("OK"));
-
-    // Health endpoint should be skipped
-    await app.request("/health");
-    assertEquals(logs.length, 0);
-
-    // Other endpoints should be logged
-    await app.request("/test");
-    assertEquals(logs.length, 1);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// logRequest (Immediate) Mode Tests
-// ============================================
-
-test("honoLogger(): logRequest mode logs at request start", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ logRequest: true }));
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.responseTime, 0); // Zero because it's immediate
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): non-logRequest mode logs after response", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger({ logRequest: false }));
-    app.get("/test", async (c) => {
-      // Small delay to ensure non-zero response time
-      await new Promise((resolve) => setTimeout(resolve, 5));
-      return c.text("Hello");
-    });
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assert((logs[0].properties.responseTime as number) >= 0);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Request Property Tests
-// ============================================
-
-test("honoLogger(): logs correct method", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-    app.post("/test", (c) => c.text("Hello"));
-    app.put("/test", (c) => c.text("Hello"));
-    app.delete("/test", (c) => c.text("Hello"));
-
-    const methods = ["GET", "POST", "PUT", "DELETE"];
-    for (const method of methods) {
-      await app.request("/test", { method });
-    }
-
-    assertEquals(logs.length, methods.length);
-    for (let i = 0; i < methods.length; i++) {
-      assertEquals(logs[i].properties.method, methods[i]);
-    }
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): logs path correctly", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/api/v1/users", (c) => c.text("Hello"));
-
-    await app.request("/api/v1/users");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.path, "/api/v1/users");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): logs status code", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-
-    app.get("/200", (c) => c.text("OK"));
-    app.get("/201", (c) => {
-      c.status(201);
-      return c.text("Created");
-    });
-    app.get("/400", (c) => {
-      c.status(400);
-      return c.text("Bad Request");
-    });
-    app.get("/500", (c) => {
-      c.status(500);
-      return c.text("Error");
-    });
-
-    const paths = ["/200", "/201", "/400", "/500"];
-    const expectedStatuses = [200, 201, 400, 500];
-
-    for (const path of paths) {
-      await app.request(path);
-    }
-
-    assertEquals(logs.length, paths.length);
-    for (let i = 0; i < paths.length; i++) {
-      assertEquals(logs[i].properties.status, expectedStatuses[i]);
-    }
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): logs response time as number", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(typeof logs[0].properties.responseTime, "number");
-    assert((logs[0].properties.responseTime as number) >= 0);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): logs user agent", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test", {
-      headers: { "User-Agent": "TestClient/1.0" },
-    });
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.userAgent, "TestClient/1.0");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): logs referrer", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test", {
-      headers: { "Referer": "https://example.com/page" },
-    });
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.referrer, "https://example.com/page");
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Multiple Requests Tests
-// ============================================
-
-test("honoLogger(): handles multiple sequential requests", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/path/:id", (c) => c.text(`Path: ${c.req.param("id")}`));
-
-    for (let i = 0; i < 5; i++) {
-      await app.request(`/path/${i}`);
-    }
-
-    assertEquals(logs.length, 5);
-    for (let i = 0; i < 5; i++) {
-      assertEquals(logs[i].properties.path, `/path/${i}`);
-    }
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Edge Cases
-// ============================================
-
-test("honoLogger(): handles missing user-agent", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.userAgent, undefined);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): handles missing referrer", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/test", (c) => c.text("Hello"));
-
-    await app.request("/test");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.referrer, undefined);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("honoLogger(): handles query parameters in url", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const app = new Hono();
-    app.use(honoLogger());
-    app.get("/search", (c) => c.text(`Query: ${c.req.query("q")}`));
-
-    await app.request("/search?q=test&limit=10");
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.path, "/search");
-    assert((logs[0].properties.url as string).includes("q=test"));
-    assert((logs[0].properties.url as string).includes("limit=10"));
-  } finally {
-    await cleanup();
-  }
-});

package/src/mod.ts

@@ -1,356 +0,0 @@
-import { getLogger, type LogLevel } from "@logtape/logtape";
-import { createMiddleware } from "hono/factory";
-import type { MiddlewareHandler } from "hono";
-
-export type { LogLevel } from "@logtape/logtape";
-
-/**
- * Minimal Hono Context interface for compatibility across Hono versions.
- * @since 1.3.0
- */
-export interface HonoContext {
-  req: {
-    method: string;
-    url: string;
-    path: string;
-    header(name: string): string | undefined;
-  };
-  res: {
-    status: number;
-    headers: {
-      get(name: string): string | null;
-    };
-  };
-}
-
-/**
- * Predefined log format names compatible with Morgan.
- * @since 1.3.0
- */
-export type PredefinedFormat = "combined" | "common" | "dev" | "short" | "tiny";
-
-/**
- * Custom format function for request logging.
- *
- * @param c The Hono context object.
- * @param responseTime The response time in milliseconds.
- * @returns A string message or an object with structured properties.
- * @since 1.3.0
- */
-export type FormatFunction = (
-  c: HonoContext,
-  responseTime: number,
-) => string | Record<string, unknown>;
-
-/**
- * Structured log properties for HTTP requests.
- * @since 1.3.0
- */
-export interface RequestLogProperties {
-  /** HTTP request method */
-  method: string;
-  /** Request URL */
-  url: string;
-  /** Request path */
-  path: string;
-  /** HTTP response status code */
-  status: number;
-  /** Response time in milliseconds */
-  responseTime: number;
-  /** Response content-length header value */
-  contentLength: string | undefined;
-  /** User-Agent header value */
-  userAgent: string | undefined;
-  /** Referrer header value */
-  referrer: string | undefined;
-}
-
-/**
- * Options for configuring the Hono LogTape middleware.
- * @since 1.3.0
- */
-export interface HonoLogTapeOptions {
-  /**
-   * The LogTape category to use for logging.
-   * @default ["hono"]
-   */
-  readonly category?: string | readonly string[];
-
-  /**
-   * The log level to use for request logging.
-   * @default "info"
-   */
-  readonly level?: LogLevel;
-
-  /**
-   * The format for log output.
-   * Can be a predefined format name or a custom format function.
-   *
-   * Predefined formats:
-   * - `"combined"` - Apache Combined Log Format (structured, default)
-   * - `"common"` - Apache Common Log Format (structured, no referrer/userAgent)
-   * - `"dev"` - Concise colored output for development (string)
-   * - `"short"` - Shorter than common (string)
-   * - `"tiny"` - Minimal output (string)
-   *
-   * @default "combined"
-   */
-  readonly format?: PredefinedFormat | FormatFunction;
-
-  /**
-   * Function to determine whether logging should be skipped.
-   * Return `true` to skip logging for a request.
-   *
-   * @example Skip logging for health check endpoint
-   * ```typescript
-   * app.use(honoLogger({
-   *   skip: (c) => c.req.path === "/health",
-   * }));
-   * ```
-   *
-   * @default () => false
-   */
-  readonly skip?: (c: HonoContext) => boolean;
-
-  /**
-   * If `true`, logs are written immediately when the request is received.
-   * If `false` (default), logs are written after the response is sent.
-   *
-   * Note: When `logRequest` is `true`, response-related properties
-   * (status, responseTime, contentLength) will not be available.
-   *
-   * @default false
-   */
-  readonly logRequest?: boolean;
-}
-
-/**
- * Get referrer from request headers.
- */
-function getReferrer(c: HonoContext): string | undefined {
-  return c.req.header("referrer") || c.req.header("referer");
-}
-
-/**
- * Get user agent from request headers.
- */
-function getUserAgent(c: HonoContext): string | undefined {
-  return c.req.header("user-agent");
-}
-
-/**
- * Get content length from response headers.
- */
-function getContentLength(c: HonoContext): string | undefined {
-  const contentLength = c.res.headers.get("content-length");
-  if (contentLength === null) return undefined;
-  return contentLength;
-}
-
-/**
- * Build structured log properties from context.
- */
-function buildProperties(
-  c: HonoContext,
-  responseTime: number,
-): RequestLogProperties {
-  return {
-    method: c.req.method,
-    url: c.req.url,
-    path: c.req.path,
-    status: c.res.status,
-    responseTime,
-    contentLength: getContentLength(c),
-    userAgent: getUserAgent(c),
-    referrer: getReferrer(c),
-  };
-}
-
-/**
- * Combined format (Apache Combined Log Format).
- * Returns all structured properties.
- */
-function formatCombined(
-  c: HonoContext,
-  responseTime: number,
-): Record<string, unknown> {
-  return { ...buildProperties(c, responseTime) };
-}
-
-/**
- * Common format (Apache Common Log Format).
- * Like combined but without referrer and userAgent.
- */
-function formatCommon(
-  c: HonoContext,
-  responseTime: number,
-): Record<string, unknown> {
-  const props = buildProperties(c, responseTime);
-  const { referrer: _referrer, userAgent: _userAgent, ...rest } = props;
-  return rest;
-}
-
-/**
- * Dev format (colored output for development).
- * :method :path :status :response-time ms - :res[content-length]
- */
-function formatDev(
-  c: HonoContext,
-  responseTime: number,
-): string {
-  const contentLength = getContentLength(c) ?? "-";
-  return `${c.req.method} ${c.req.path} ${c.res.status} ${
-    responseTime.toFixed(3)
-  } ms - ${contentLength}`;
-}
-
-/**
- * Short format.
- * :method :url :status :res[content-length] - :response-time ms
- */
-function formatShort(
-  c: HonoContext,
-  responseTime: number,
-): string {
-  const contentLength = getContentLength(c) ?? "-";
-  return `${c.req.method} ${c.req.url} ${c.res.status} ${contentLength} - ${
-    responseTime.toFixed(3)
-  } ms`;
-}
-
-/**
- * Tiny format (minimal output).
- * :method :path :status :res[content-length] - :response-time ms
- */
-function formatTiny(
-  c: HonoContext,
-  responseTime: number,
-): string {
-  const contentLength = getContentLength(c) ?? "-";
-  return `${c.req.method} ${c.req.path} ${c.res.status} ${contentLength} - ${
-    responseTime.toFixed(3)
-  } ms`;
-}
-
-/**
- * Map of predefined format functions.
- */
-const predefinedFormats: Record<PredefinedFormat, FormatFunction> = {
-  combined: formatCombined,
-  common: formatCommon,
-  dev: formatDev,
-  short: formatShort,
-  tiny: formatTiny,
-};
-
-/**
- * Normalize category to array format.
- */
-function normalizeCategory(
-  category: string | readonly string[],
-): readonly string[] {
-  return typeof category === "string" ? [category] : category;
-}
-
-/**
- * Creates Hono middleware for HTTP request logging using LogTape.
- *
- * This middleware provides Morgan-compatible request logging with LogTape
- * as the backend, supporting structured logging and customizable formats.
- *
- * @example Basic usage
- * ```typescript
- * import { Hono } from "hono";
- * import { configure, getConsoleSink } from "@logtape/logtape";
- * import { honoLogger } from "@logtape/hono";
- *
- * await configure({
- *   sinks: { console: getConsoleSink() },
- *   loggers: [
- *     { category: ["hono"], sinks: ["console"], lowestLevel: "info" }
- *   ],
- * });
- *
- * const app = new Hono();
- * app.use(honoLogger());
- *
- * app.get("/", (c) => c.json({ hello: "world" }));
- *
- * export default app;
- * ```
- *
- * @example With custom options
- * ```typescript
- * app.use(honoLogger({
- *   category: ["myapp", "http"],
- *   level: "debug",
- *   format: "dev",
- *   skip: (c) => c.req.path === "/health",
- * }));
- * ```
- *
- * @example With custom format function
- * ```typescript
- * app.use(honoLogger({
- *   format: (c, responseTime) => ({
- *     method: c.req.method,
- *     path: c.req.path,
- *     status: c.res.status,
- *     duration: responseTime,
- *   }),
- * }));
- * ```
- *
- * @param options Configuration options for the middleware.
- * @returns Hono middleware function.
- * @since 1.3.0
- */
-export function honoLogger(
-  options: HonoLogTapeOptions = {},
-): MiddlewareHandler {
-  const category = normalizeCategory(options.category ?? ["hono"]);
-  const logger = getLogger(category);
-  const level = options.level ?? "info";
-  const formatOption = options.format ?? "combined";
-  const skip = options.skip ?? (() => false);
-  const logRequest = options.logRequest ?? false;
-
-  // Resolve format function
-  const formatFn: FormatFunction = typeof formatOption === "string"
-    ? predefinedFormats[formatOption]
-    : formatOption;
-
-  const logMethod = logger[level].bind(logger);
-
-  return createMiddleware(async (c, next) => {
-    const startTime = Date.now();
-
-    // For immediate logging, log when request arrives
-    if (logRequest) {
-      if (!skip(c as unknown as HonoContext)) {
-        const result = formatFn(c as unknown as HonoContext, 0);
-        if (typeof result === "string") {
-          logMethod(result);
-        } else {
-          logMethod("{method} {url}", result);
-        }
-      }
-      await next();
-      return;
-    }
-
-    // Log after response is sent
-    await next();
-
-    if (skip(c as unknown as HonoContext)) return;
-
-    const responseTime = Date.now() - startTime;
-    const result = formatFn(c as unknown as HonoContext, responseTime);
-
-    if (typeof result === "string") {
-      logMethod(result);
-    } else {
-      logMethod("{method} {url} {status} - {responseTime} ms", result);
-    }
-  });
-}

package/tsdown.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-  entry: "src/mod.ts",
-  dts: {
-    sourcemap: true,
-  },
-  format: ["esm", "cjs"],
-  platform: "node",
-  unbundle: true,
-});