@logtape/hono 1.3.0-dev.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2025 Hong Minhee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,121 @@
+<!-- deno-fmt-ignore-file -->
+
+@logtape/hono
+=============
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+This package provides [Hono] middleware for HTTP request logging using
+[LogTape] as the backend, as an alternative to Hono's built-in logger
+middleware.
+
+[JSR]: https://jsr.io/@logtape/hono
+[JSR badge]: https://jsr.io/badges/@logtape/hono
+[npm]: https://www.npmjs.com/package/@logtape/hono
+[npm badge]: https://img.shields.io/npm/v/@logtape/hono?logo=npm
+[Hono]: https://hono.dev/
+[LogTape]: https://logtape.org/
+
+
+Installation
+------------
+
+~~~~ sh
+deno add jsr:@logtape/hono  # for Deno
+npm  add     @logtape/hono  # for npm
+pnpm add     @logtape/hono  # for pnpm
+yarn add     @logtape/hono  # for Yarn
+bun  add     @logtape/hono  # for Bun
+~~~~
+
+
+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;
+~~~~
+
+
+Options
+-------
+
+The `honoLogger()` function accepts an optional options object:
+
+~~~~ typescript
+app.use(honoLogger({
+  category: ["myapp", "http"],  // Custom category (default: ["hono"])
+  level: "debug",                // Log level (default: "info")
+  format: "dev",                 // Predefined format (default: "combined")
+  skip: (c) => c.req.path === "/health",  // Skip logging for specific paths
+  logRequest: true,              // Log at request start (default: false)
+}));
+~~~~
+
+
+Predefined formats
+------------------
+
+The middleware supports Morgan-compatible predefined formats:
+
+- `"combined"`: Apache Combined Log Format with all properties (default)
+- `"common"`: Apache Common Log Format (without referrer/userAgent)
+- `"dev"`: Concise output for development (e.g., `GET /path 200 1.234 ms - 123`)
+- `"short"`: Shorter format with remote address
+- `"tiny"`: Minimal output
+
+
+Custom format function
+----------------------
+
+You can also provide a custom format function:
+
+~~~~ typescript
+app.use(honoLogger({
+  format: (c, responseTime) => ({
+    method: c.req.method,
+    path: c.req.path,
+    status: c.res.status,
+    duration: responseTime,
+  }),
+}));
+~~~~
+
+
+Structured logging output
+-------------------------
+
+When using the `"combined"` format (default), the middleware logs structured
+data that includes:
+
+- `method`: HTTP request method
+- `url`: Request URL
+- `path`: Request path
+- `status`: HTTP response status code
+- `responseTime`: Response time in milliseconds
+- `contentLength`: Response content-length header value
+- `userAgent`: User-Agent header value
+- `referrer`: Referrer header value
+
+
+See also
+--------
+
+For more information, see the [LogTape documentation][LogTape].

package/deno.json

@@ -0,0 +1,34 @@
+{
+  "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/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/mod.cjs

@@ -0,0 +1,180 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+const hono_factory = require_rolldown_runtime.__toESM(require("hono/factory"));
+
+//#region src/mod.ts
+/**
+* Get referrer from request headers.
+*/
+function getReferrer(c) {
+	return c.req.header("referrer") || c.req.header("referer");
+}
+/**
+* Get user agent from request headers.
+*/
+function getUserAgent(c) {
+	return c.req.header("user-agent");
+}
+/**
+* Get content length from response headers.
+*/
+function getContentLength(c) {
+	const contentLength = c.res.headers.get("content-length");
+	if (contentLength === null) return void 0;
+	return contentLength;
+}
+/**
+* Build structured log properties from context.
+*/
+function buildProperties(c, responseTime) {
+	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, responseTime) {
+	return { ...buildProperties(c, responseTime) };
+}
+/**
+* Common format (Apache Common Log Format).
+* Like combined but without referrer and userAgent.
+*/
+function formatCommon(c, responseTime) {
+	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, responseTime) {
+	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, responseTime) {
+	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, responseTime) {
+	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 = {
+	combined: formatCombined,
+	common: formatCommon,
+	dev: formatDev,
+	short: formatShort,
+	tiny: formatTiny
+};
+/**
+* Normalize category to array format.
+*/
+function normalizeCategory(category) {
+	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
+*/
+function honoLogger(options = {}) {
+	const category = normalizeCategory(options.category ?? ["hono"]);
+	const logger = (0, __logtape_logtape.getLogger)(category);
+	const level = options.level ?? "info";
+	const formatOption = options.format ?? "combined";
+	const skip = options.skip ?? (() => false);
+	const logRequest = options.logRequest ?? false;
+	const formatFn = typeof formatOption === "string" ? predefinedFormats[formatOption] : formatOption;
+	const logMethod = logger[level].bind(logger);
+	return (0, hono_factory.createMiddleware)(async (c, next) => {
+		const startTime = Date.now();
+		if (logRequest) {
+			if (!skip(c)) {
+				const result$1 = formatFn(c, 0);
+				if (typeof result$1 === "string") logMethod(result$1);
+				else logMethod("{method} {url}", result$1);
+			}
+			await next();
+			return;
+		}
+		await next();
+		if (skip(c)) return;
+		const responseTime = Date.now() - startTime;
+		const result = formatFn(c, responseTime);
+		if (typeof result === "string") logMethod(result);
+		else logMethod("{method} {url} {status} - {responseTime} ms", result);
+	});
+}
+
+//#endregion
+exports.honoLogger = honoLogger;

package/dist/mod.d.cts

@@ -0,0 +1,171 @@
+import { LogLevel, LogLevel as LogLevel$1 } from "@logtape/logtape";
+import { MiddlewareHandler } from "hono";
+
+//#region src/mod.d.ts
+
+/**
+ * Minimal Hono Context interface for compatibility across Hono versions.
+ * @since 1.3.0
+ */
+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
+ */
+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
+ */
+type FormatFunction = (c: HonoContext, responseTime: number) => string | Record<string, unknown>;
+/**
+ * Structured log properties for HTTP requests.
+ * @since 1.3.0
+ */
+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
+ */
+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$1;
+  /**
+   * 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;
+}
+/**
+ * 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
+ */
+declare function honoLogger(options?: HonoLogTapeOptions): MiddlewareHandler;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { FormatFunction, HonoContext, HonoLogTapeOptions, LogLevel, PredefinedFormat, RequestLogProperties, honoLogger };
+//# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AAmBA;AAUA;AAA0B,UA7BT,WAAA,CA6BS;EAAA,GACrB,EAAA;IAES,MAAA,EAAA,MAAA;IAAM,GAAA,EAAA,MAAA;IAMH,IAAA,EAAA,MAAA;IAuBA,MAAA,CAAA,IAAA,EAAA,MAAkB,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,CAAA;EAAA,GAWhB,EAAA;IAeC,MAAA,EAAA,MAAA;IAAmB,OAAA,EAAA;MAejB,GAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA,GAAA,IAAA;IAAW,CAAA;EAmMjB,CAAA;;;;AAEI;;KAxRR,gBAAA;;;;;;;;;KAUA,cAAA,OACP,+CAES;;;;;UAMG,oBAAA;;;;;;;;;;;;;;;;;;;;;;UAuBA,kBAAA;;;;;;;;;;mBAWE;;;;;;;;;;;;;;oBAeC,mBAAmB;;;;;;;;;;;;;;sBAejB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmMN,UAAA,WACL,qBACR"}