@logtape/elysia 1.4.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,140 @@
+<!-- deno-fmt-ignore-file -->
+
+@logtape/elysia
+===============
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+This package provides an [Elysia] plugin for HTTP request logging using
+[LogTape] as the backend.
+
+[JSR]: https://jsr.io/@logtape/elysia
+[JSR badge]: https://jsr.io/badges/@logtape/elysia
+[npm]: https://www.npmjs.com/package/@logtape/elysia
+[npm badge]: https://img.shields.io/npm/v/@logtape/elysia?logo=npm
+[Elysia]: https://elysiajs.com/
+[LogTape]: https://logtape.org/
+
+
+Installation
+------------
+
+~~~~ sh
+deno add jsr:@logtape/elysia  # for Deno
+npm  add     @logtape/elysia  # for npm
+pnpm add     @logtape/elysia  # for pnpm
+yarn add     @logtape/elysia  # for Yarn
+bun  add     @logtape/elysia  # for Bun
+~~~~
+
+
+Usage
+-----
+
+~~~~ typescript
+import { Elysia } from "elysia";
+import { configure, getConsoleSink } from "@logtape/logtape";
+import { elysiaLogger } from "@logtape/elysia";
+
+await configure({
+  sinks: { console: getConsoleSink() },
+  loggers: [
+    { category: ["elysia"], sinks: ["console"], lowestLevel: "info" }
+  ],
+});
+
+const app = new Elysia()
+  .use(elysiaLogger())
+  .get("/", () => ({ hello: "world" }))
+  .listen(3000);
+
+console.log(`Server running at ${app.server?.url}`);
+~~~~
+
+
+Options
+-------
+
+The `elysiaLogger()` function accepts an optional options object:
+
+~~~~ typescript
+app.use(elysiaLogger({
+  category: ["myapp", "http"],  // Custom category (default: ["elysia"])
+  level: "debug",                // Log level (default: "info")
+  format: "dev",                 // Predefined format (default: "combined")
+  skip: (ctx) => ctx.path === "/health",  // Skip logging for specific paths
+  logRequest: true,              // Log at request start (default: false)
+  scope: "global",               // Plugin scope (default: "global")
+}));
+~~~~
+
+
+Plugin scope
+------------
+
+Elysia supports plugin scoping to control how lifecycle hooks propagate:
+
+- `"global"`: Hooks apply to all routes in the application (default)
+- `"scoped"`: Hooks apply to the parent instance where the plugin is used
+- `"local"`: Hooks only apply within the plugin itself
+
+
+Predefined formats
+------------------
+
+The plugin 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(elysiaLogger({
+  format: (ctx, responseTime) => ({
+    method: ctx.request.method,
+    path: ctx.path,
+    status: ctx.set.status,
+    duration: responseTime,
+  }),
+}));
+~~~~
+
+
+Error logging
+-------------
+
+The plugin automatically logs errors at the error level using Elysia's
+`onError` hook.  Error logs include the error message and error code
+in addition to standard request properties.
+
+
+Structured logging output
+-------------------------
+
+When using the `"combined"` format (default), the plugin 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
+- `remoteAddr`: Remote client address (from X-Forwarded-For header)
+- `userAgent`: User-Agent header value
+- `referrer`: Referrer header value
+
+
+See also
+--------
+
+For more information, see the [LogTape documentation][LogTape].

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,214 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const elysia = require_rolldown_runtime.__toESM(require("elysia"));
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/mod.ts
+/**
+* Get referrer from request headers.
+*/
+function getReferrer(request) {
+	return request.headers.get("referrer") ?? request.headers.get("referer") ?? void 0;
+}
+/**
+* Get user agent from request headers.
+*/
+function getUserAgent(request) {
+	return request.headers.get("user-agent") ?? void 0;
+}
+/**
+* Get remote address from X-Forwarded-For header.
+*/
+function getRemoteAddr(request) {
+	const forwarded = request.headers.get("x-forwarded-for");
+	if (forwarded) {
+		const firstIp = forwarded.split(",")[0].trim();
+		return firstIp || void 0;
+	}
+	return void 0;
+}
+/**
+* Get content length from response headers.
+*/
+function getContentLength(headers) {
+	const contentLength = headers["content-length"];
+	if (contentLength === void 0 || contentLength === null) return void 0;
+	return contentLength;
+}
+/**
+* Build structured log properties from context.
+*/
+function buildProperties(ctx, responseTime) {
+	return {
+		method: ctx.request.method,
+		url: ctx.request.url,
+		path: ctx.path,
+		status: ctx.set.status,
+		responseTime,
+		contentLength: getContentLength(ctx.set.headers),
+		remoteAddr: getRemoteAddr(ctx.request),
+		userAgent: getUserAgent(ctx.request),
+		referrer: getReferrer(ctx.request)
+	};
+}
+/**
+* Combined format (Apache Combined Log Format).
+* Returns all structured properties.
+*/
+function formatCombined(ctx, responseTime) {
+	return { ...buildProperties(ctx, responseTime) };
+}
+/**
+* Common format (Apache Common Log Format).
+* Like combined but without referrer and userAgent.
+*/
+function formatCommon(ctx, responseTime) {
+	const props = buildProperties(ctx, 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(ctx, responseTime) {
+	const contentLength = getContentLength(ctx.set.headers) ?? "-";
+	return `${ctx.request.method} ${ctx.path} ${ctx.set.status} ${responseTime.toFixed(3)} ms - ${contentLength}`;
+}
+/**
+* Short format.
+* :remote-addr :method :url :status :res[content-length] - :response-time ms
+*/
+function formatShort(ctx, responseTime) {
+	const remoteAddr = getRemoteAddr(ctx.request) ?? "-";
+	const contentLength = getContentLength(ctx.set.headers) ?? "-";
+	return `${remoteAddr} ${ctx.request.method} ${ctx.request.url} ${ctx.set.status} ${contentLength} - ${responseTime.toFixed(3)} ms`;
+}
+/**
+* Tiny format (minimal output).
+* :method :path :status :res[content-length] - :response-time ms
+*/
+function formatTiny(ctx, responseTime) {
+	const contentLength = getContentLength(ctx.set.headers) ?? "-";
+	return `${ctx.request.method} ${ctx.path} ${ctx.set.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 Elysia plugin for HTTP request logging using LogTape.
+*
+* This plugin provides Morgan-compatible request logging with LogTape
+* as the backend, supporting structured logging and customizable formats.
+*
+* @example Basic usage
+* ```typescript
+* import { Elysia } from "elysia";
+* import { configure, getConsoleSink } from "@logtape/logtape";
+* import { elysiaLogger } from "@logtape/elysia";
+*
+* await configure({
+*   sinks: { console: getConsoleSink() },
+*   loggers: [
+*     { category: ["elysia"], sinks: ["console"], lowestLevel: "info" }
+*   ],
+* });
+*
+* const app = new Elysia()
+*   .use(elysiaLogger())
+*   .get("/", () => ({ hello: "world" }))
+*   .listen(3000);
+* ```
+*
+* @example With custom options
+* ```typescript
+* app.use(elysiaLogger({
+*   category: ["myapp", "http"],
+*   level: "debug",
+*   format: "dev",
+*   skip: (ctx) => ctx.path === "/health",
+*   scope: "scoped",
+* }));
+* ```
+*
+* @example With custom format function
+* ```typescript
+* app.use(elysiaLogger({
+*   format: (ctx, responseTime) => ({
+*     method: ctx.request.method,
+*     path: ctx.path,
+*     status: ctx.set.status,
+*     duration: responseTime,
+*   }),
+* }));
+* ```
+*
+* @param options Configuration options for the plugin.
+* @returns Elysia plugin instance.
+* @since 1.4.0
+*/
+function elysiaLogger(options = {}) {
+	const category = normalizeCategory(options.category ?? ["elysia"]);
+	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 scope = options.scope ?? "global";
+	const formatFn = typeof formatOption === "string" ? predefinedFormats[formatOption] : formatOption;
+	const logMethod = logger[level].bind(logger);
+	const errorLogMethod = logger.error.bind(logger);
+	let plugin = new elysia.Elysia({
+		name: "@logtape/elysia",
+		seed: options
+	}).state("startTime", 0).onRequest(({ store }) => {
+		store.startTime = performance.now();
+	});
+	if (logRequest) plugin = plugin.onRequest((ctx) => {
+		if (!skip(ctx)) {
+			const result = formatFn(ctx, 0);
+			if (typeof result === "string") logMethod(result);
+			else logMethod("{method} {url}", result);
+		}
+	});
+	else plugin = plugin.onAfterHandle((ctx) => {
+		if (skip(ctx)) return;
+		const store = ctx.store;
+		const responseTime = performance.now() - store.startTime;
+		const result = formatFn(ctx, responseTime);
+		if (typeof result === "string") logMethod(result);
+		else logMethod("{method} {url} {status} - {responseTime} ms", result);
+	});
+	plugin = plugin.onError((ctx) => {
+		const store = ctx.store;
+		const responseTime = performance.now() - store.startTime;
+		const elysiaCtx = ctx;
+		if (skip(elysiaCtx)) return;
+		const props = buildProperties(elysiaCtx, responseTime);
+		const error = ctx.error;
+		const errorMessage = error?.message ?? "Unknown error";
+		errorLogMethod("Error: {method} {url} {status} - {responseTime} ms - {errorMessage}", {
+			...props,
+			errorMessage,
+			errorCode: ctx.code
+		});
+	});
+	if (scope === "global") return plugin.as("global");
+	else if (scope === "scoped") return plugin.as("scoped");
+	return plugin;
+}
+
+//#endregion
+exports.elysiaLogger = elysiaLogger;

package/dist/mod.d.cts

@@ -0,0 +1,181 @@
+import { Elysia } from "elysia";
+import { LogLevel, LogLevel as LogLevel$1 } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * Minimal Elysia Context interface for compatibility.
+ * @since 1.4.0
+ */
+interface ElysiaContext {
+  request: Request;
+  path: string;
+  set: {
+    status: number;
+    headers: Record<string, string | undefined>;
+  };
+}
+/**
+ * Plugin scope options for controlling hook propagation.
+ * @since 1.4.0
+ */
+type PluginScope = "global" | "scoped" | "local";
+/**
+ * Predefined log format names compatible with Morgan.
+ * @since 1.4.0
+ */
+type PredefinedFormat = "combined" | "common" | "dev" | "short" | "tiny";
+/**
+ * Custom format function for request logging.
+ *
+ * @param ctx The Elysia context object.
+ * @param responseTime The response time in milliseconds.
+ * @returns A string message or an object with structured properties.
+ * @since 1.4.0
+ */
+type FormatFunction = (ctx: ElysiaContext, responseTime: number) => string | Record<string, unknown>;
+/**
+ * Structured log properties for HTTP requests.
+ * @since 1.4.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;
+  /** Remote client address (from X-Forwarded-For header) */
+  remoteAddr: string | undefined;
+  /** User-Agent header value */
+  userAgent: string | undefined;
+  /** Referrer header value */
+  referrer: string | undefined;
+}
+/**
+ * Options for configuring the Elysia LogTape middleware.
+ * @since 1.4.0
+ */
+interface ElysiaLogTapeOptions {
+  /**
+   * The LogTape category to use for logging.
+   * @default ["elysia"]
+   */
+  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(elysiaLogger({
+   *   skip: (ctx) => ctx.path === "/health",
+   * }));
+   * ```
+   *
+   * @default () => false
+   */
+  readonly skip?: (ctx: ElysiaContext) => 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;
+  /**
+   * The plugin scope for controlling how lifecycle hooks are propagated.
+   *
+   * - `"global"` - Hooks apply to all routes in the application
+   * - `"scoped"` - Hooks apply to the parent instance where the plugin is used
+   * - `"local"` - Hooks only apply within the plugin itself
+   *
+   * @default "global"
+   */
+  readonly scope?: PluginScope;
+}
+/**
+ * Creates Elysia plugin for HTTP request logging using LogTape.
+ *
+ * This plugin provides Morgan-compatible request logging with LogTape
+ * as the backend, supporting structured logging and customizable formats.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { Elysia } from "elysia";
+ * import { configure, getConsoleSink } from "@logtape/logtape";
+ * import { elysiaLogger } from "@logtape/elysia";
+ *
+ * await configure({
+ *   sinks: { console: getConsoleSink() },
+ *   loggers: [
+ *     { category: ["elysia"], sinks: ["console"], lowestLevel: "info" }
+ *   ],
+ * });
+ *
+ * const app = new Elysia()
+ *   .use(elysiaLogger())
+ *   .get("/", () => ({ hello: "world" }))
+ *   .listen(3000);
+ * ```
+ *
+ * @example With custom options
+ * ```typescript
+ * app.use(elysiaLogger({
+ *   category: ["myapp", "http"],
+ *   level: "debug",
+ *   format: "dev",
+ *   skip: (ctx) => ctx.path === "/health",
+ *   scope: "scoped",
+ * }));
+ * ```
+ *
+ * @example With custom format function
+ * ```typescript
+ * app.use(elysiaLogger({
+ *   format: (ctx, responseTime) => ({
+ *     method: ctx.request.method,
+ *     path: ctx.path,
+ *     status: ctx.set.status,
+ *     duration: responseTime,
+ *   }),
+ * }));
+ * ```
+ *
+ * @param options Configuration options for the plugin.
+ * @returns Elysia plugin instance.
+ * @since 1.4.0
+ */
+declare function elysiaLogger(options?: ElysiaLogTapeOptions): Elysia<any>;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { ElysiaContext, ElysiaLogTapeOptions, FormatFunction, LogLevel, PluginScope, PredefinedFormat, RequestLogProperties, elysiaLogger };
+//# 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":";;;;;;AASA;;;AAKa,UALI,aAAA,CAKJ;EAAM,OAAA,EAJR,OAIQ;EAQP,IAAA,EAAA,MAAA;EAMA,GAAA,EAAA;IAUA,MAAA,EAAA,MAAc;IAAA,OAAA,EAxBb,MAwBa,CAAA,MAAA,EAAA,MAAA,GAAA,SAAA,CAAA;EAAA,CAAA;;AAGN;AAMpB;AAyBA;;AAWmB,KA7DP,WAAA,GA6DO,QAAA,GAAA,QAAA,GAAA,OAAA;;;;;AAoDW,KA3GlB,gBAAA,GA2GkB,UAAA,GAAA,QAAA,GAAA,KAAA,GAAA,OAAA,GAAA,MAAA;AAyM9B;;;;AAAwE;;;;KA1S5D,cAAA,SACL,iDAEO;;;;;UAMG,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;UAyBA,oBAAA;;;;;;;;;;mBAWE;;;;;;;;;;;;;;oBAeC,mBAAmB;;;;;;;;;;;;;;wBAef;;;;;;;;;;;;;;;;;;;;mBAsBL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyMH,YAAA,WAAsB,uBAA4B"}

package/dist/mod.d.ts

@@ -0,0 +1,181 @@
+import { Elysia } from "elysia";
+import { LogLevel, LogLevel as LogLevel$1 } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * Minimal Elysia Context interface for compatibility.
+ * @since 1.4.0
+ */
+interface ElysiaContext {
+  request: Request;
+  path: string;
+  set: {
+    status: number;
+    headers: Record<string, string | undefined>;
+  };
+}
+/**
+ * Plugin scope options for controlling hook propagation.
+ * @since 1.4.0
+ */
+type PluginScope = "global" | "scoped" | "local";
+/**
+ * Predefined log format names compatible with Morgan.
+ * @since 1.4.0
+ */
+type PredefinedFormat = "combined" | "common" | "dev" | "short" | "tiny";
+/**
+ * Custom format function for request logging.
+ *
+ * @param ctx The Elysia context object.
+ * @param responseTime The response time in milliseconds.
+ * @returns A string message or an object with structured properties.
+ * @since 1.4.0
+ */
+type FormatFunction = (ctx: ElysiaContext, responseTime: number) => string | Record<string, unknown>;
+/**
+ * Structured log properties for HTTP requests.
+ * @since 1.4.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;
+  /** Remote client address (from X-Forwarded-For header) */
+  remoteAddr: string | undefined;
+  /** User-Agent header value */
+  userAgent: string | undefined;
+  /** Referrer header value */
+  referrer: string | undefined;
+}
+/**
+ * Options for configuring the Elysia LogTape middleware.
+ * @since 1.4.0
+ */
+interface ElysiaLogTapeOptions {
+  /**
+   * The LogTape category to use for logging.
+   * @default ["elysia"]
+   */
+  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(elysiaLogger({
+   *   skip: (ctx) => ctx.path === "/health",
+   * }));
+   * ```
+   *
+   * @default () => false
+   */
+  readonly skip?: (ctx: ElysiaContext) => 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;
+  /**
+   * The plugin scope for controlling how lifecycle hooks are propagated.
+   *
+   * - `"global"` - Hooks apply to all routes in the application
+   * - `"scoped"` - Hooks apply to the parent instance where the plugin is used
+   * - `"local"` - Hooks only apply within the plugin itself
+   *
+   * @default "global"
+   */
+  readonly scope?: PluginScope;
+}
+/**
+ * Creates Elysia plugin for HTTP request logging using LogTape.
+ *
+ * This plugin provides Morgan-compatible request logging with LogTape
+ * as the backend, supporting structured logging and customizable formats.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { Elysia } from "elysia";
+ * import { configure, getConsoleSink } from "@logtape/logtape";
+ * import { elysiaLogger } from "@logtape/elysia";
+ *
+ * await configure({
+ *   sinks: { console: getConsoleSink() },
+ *   loggers: [
+ *     { category: ["elysia"], sinks: ["console"], lowestLevel: "info" }
+ *   ],
+ * });
+ *
+ * const app = new Elysia()
+ *   .use(elysiaLogger())
+ *   .get("/", () => ({ hello: "world" }))
+ *   .listen(3000);
+ * ```
+ *
+ * @example With custom options
+ * ```typescript
+ * app.use(elysiaLogger({
+ *   category: ["myapp", "http"],
+ *   level: "debug",
+ *   format: "dev",
+ *   skip: (ctx) => ctx.path === "/health",
+ *   scope: "scoped",
+ * }));
+ * ```
+ *
+ * @example With custom format function
+ * ```typescript
+ * app.use(elysiaLogger({
+ *   format: (ctx, responseTime) => ({
+ *     method: ctx.request.method,
+ *     path: ctx.path,
+ *     status: ctx.set.status,
+ *     duration: responseTime,
+ *   }),
+ * }));
+ * ```
+ *
+ * @param options Configuration options for the plugin.
+ * @returns Elysia plugin instance.
+ * @since 1.4.0
+ */
+declare function elysiaLogger(options?: ElysiaLogTapeOptions): Elysia<any>;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { ElysiaContext, ElysiaLogTapeOptions, FormatFunction, LogLevel, PluginScope, PredefinedFormat, RequestLogProperties, elysiaLogger };
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;AAKa,UALI,aAAA,CAKJ;EAAM,OAAA,EAJR,OAIQ;EAQP,IAAA,EAAA,MAAA;EAMA,GAAA,EAAA;IAUA,MAAA,EAAA,MAAc;IAAA,OAAA,EAxBb,MAwBa,CAAA,MAAA,EAAA,MAAA,GAAA,SAAA,CAAA;EAAA,CAAA;;AAGN;AAMpB;AAyBA;;AAWmB,KA7DP,WAAA,GA6DO,QAAA,GAAA,QAAA,GAAA,OAAA;;;;;AAoDW,KA3GlB,gBAAA,GA2GkB,UAAA,GAAA,QAAA,GAAA,KAAA,GAAA,OAAA,GAAA,MAAA;AAyM9B;;;;AAAwE;;;;KA1S5D,cAAA,SACL,iDAEO;;;;;UAMG,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;UAyBA,oBAAA;;;;;;;;;;mBAWE;;;;;;;;;;;;;;oBAeC,mBAAmB;;;;;;;;;;;;;;wBAef;;;;;;;;;;;;;;;;;;;;mBAsBL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyMH,YAAA,WAAsB,uBAA4B"}

package/dist/mod.js

@@ -0,0 +1,214 @@
+import { Elysia } from "elysia";
+import { getLogger } from "@logtape/logtape";
+
+//#region src/mod.ts
+/**
+* Get referrer from request headers.
+*/
+function getReferrer(request) {
+	return request.headers.get("referrer") ?? request.headers.get("referer") ?? void 0;
+}
+/**
+* Get user agent from request headers.
+*/
+function getUserAgent(request) {
+	return request.headers.get("user-agent") ?? void 0;
+}
+/**
+* Get remote address from X-Forwarded-For header.
+*/
+function getRemoteAddr(request) {
+	const forwarded = request.headers.get("x-forwarded-for");
+	if (forwarded) {
+		const firstIp = forwarded.split(",")[0].trim();
+		return firstIp || void 0;
+	}
+	return void 0;
+}
+/**
+* Get content length from response headers.
+*/
+function getContentLength(headers) {
+	const contentLength = headers["content-length"];
+	if (contentLength === void 0 || contentLength === null) return void 0;
+	return contentLength;
+}
+/**
+* Build structured log properties from context.
+*/
+function buildProperties(ctx, responseTime) {
+	return {
+		method: ctx.request.method,
+		url: ctx.request.url,
+		path: ctx.path,
+		status: ctx.set.status,
+		responseTime,
+		contentLength: getContentLength(ctx.set.headers),
+		remoteAddr: getRemoteAddr(ctx.request),
+		userAgent: getUserAgent(ctx.request),
+		referrer: getReferrer(ctx.request)
+	};
+}
+/**
+* Combined format (Apache Combined Log Format).
+* Returns all structured properties.
+*/
+function formatCombined(ctx, responseTime) {
+	return { ...buildProperties(ctx, responseTime) };
+}
+/**
+* Common format (Apache Common Log Format).
+* Like combined but without referrer and userAgent.
+*/
+function formatCommon(ctx, responseTime) {
+	const props = buildProperties(ctx, 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(ctx, responseTime) {
+	const contentLength = getContentLength(ctx.set.headers) ?? "-";
+	return `${ctx.request.method} ${ctx.path} ${ctx.set.status} ${responseTime.toFixed(3)} ms - ${contentLength}`;
+}
+/**
+* Short format.
+* :remote-addr :method :url :status :res[content-length] - :response-time ms
+*/
+function formatShort(ctx, responseTime) {
+	const remoteAddr = getRemoteAddr(ctx.request) ?? "-";
+	const contentLength = getContentLength(ctx.set.headers) ?? "-";
+	return `${remoteAddr} ${ctx.request.method} ${ctx.request.url} ${ctx.set.status} ${contentLength} - ${responseTime.toFixed(3)} ms`;
+}
+/**
+* Tiny format (minimal output).
+* :method :path :status :res[content-length] - :response-time ms
+*/
+function formatTiny(ctx, responseTime) {
+	const contentLength = getContentLength(ctx.set.headers) ?? "-";
+	return `${ctx.request.method} ${ctx.path} ${ctx.set.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 Elysia plugin for HTTP request logging using LogTape.
+*
+* This plugin provides Morgan-compatible request logging with LogTape
+* as the backend, supporting structured logging and customizable formats.
+*
+* @example Basic usage
+* ```typescript
+* import { Elysia } from "elysia";
+* import { configure, getConsoleSink } from "@logtape/logtape";
+* import { elysiaLogger } from "@logtape/elysia";
+*
+* await configure({
+*   sinks: { console: getConsoleSink() },
+*   loggers: [
+*     { category: ["elysia"], sinks: ["console"], lowestLevel: "info" }
+*   ],
+* });
+*
+* const app = new Elysia()
+*   .use(elysiaLogger())
+*   .get("/", () => ({ hello: "world" }))
+*   .listen(3000);
+* ```
+*
+* @example With custom options
+* ```typescript
+* app.use(elysiaLogger({
+*   category: ["myapp", "http"],
+*   level: "debug",
+*   format: "dev",
+*   skip: (ctx) => ctx.path === "/health",
+*   scope: "scoped",
+* }));
+* ```
+*
+* @example With custom format function
+* ```typescript
+* app.use(elysiaLogger({
+*   format: (ctx, responseTime) => ({
+*     method: ctx.request.method,
+*     path: ctx.path,
+*     status: ctx.set.status,
+*     duration: responseTime,
+*   }),
+* }));
+* ```
+*
+* @param options Configuration options for the plugin.
+* @returns Elysia plugin instance.
+* @since 1.4.0
+*/
+function elysiaLogger(options = {}) {
+	const category = normalizeCategory(options.category ?? ["elysia"]);
+	const logger = getLogger(category);
+	const level = options.level ?? "info";
+	const formatOption = options.format ?? "combined";
+	const skip = options.skip ?? (() => false);
+	const logRequest = options.logRequest ?? false;
+	const scope = options.scope ?? "global";
+	const formatFn = typeof formatOption === "string" ? predefinedFormats[formatOption] : formatOption;
+	const logMethod = logger[level].bind(logger);
+	const errorLogMethod = logger.error.bind(logger);
+	let plugin = new Elysia({
+		name: "@logtape/elysia",
+		seed: options
+	}).state("startTime", 0).onRequest(({ store }) => {
+		store.startTime = performance.now();
+	});
+	if (logRequest) plugin = plugin.onRequest((ctx) => {
+		if (!skip(ctx)) {
+			const result = formatFn(ctx, 0);
+			if (typeof result === "string") logMethod(result);
+			else logMethod("{method} {url}", result);
+		}
+	});
+	else plugin = plugin.onAfterHandle((ctx) => {
+		if (skip(ctx)) return;
+		const store = ctx.store;
+		const responseTime = performance.now() - store.startTime;
+		const result = formatFn(ctx, responseTime);
+		if (typeof result === "string") logMethod(result);
+		else logMethod("{method} {url} {status} - {responseTime} ms", result);
+	});
+	plugin = plugin.onError((ctx) => {
+		const store = ctx.store;
+		const responseTime = performance.now() - store.startTime;
+		const elysiaCtx = ctx;
+		if (skip(elysiaCtx)) return;
+		const props = buildProperties(elysiaCtx, responseTime);
+		const error = ctx.error;
+		const errorMessage = error?.message ?? "Unknown error";
+		errorLogMethod("Error: {method} {url} {status} - {responseTime} ms - {errorMessage}", {
+			...props,
+			errorMessage,
+			errorCode: ctx.code
+		});
+	});
+	if (scope === "global") return plugin.as("global");
+	else if (scope === "scoped") return plugin.as("scoped");
+	return plugin;
+}
+
+//#endregion
+export { elysiaLogger };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["request: Request","headers: Record<string, string | undefined>","ctx: ElysiaContext","responseTime: number","predefinedFormats: Record<PredefinedFormat, FormatFunction>","category: string | readonly string[]","options: ElysiaLogTapeOptions","formatFn: FormatFunction"],"sources":["../src/mod.ts"],"sourcesContent":["import { Elysia } from \"elysia\";\nimport { getLogger, type LogLevel } from \"@logtape/logtape\";\n\nexport type { LogLevel } from \"@logtape/logtape\";\n\n/**\n * Minimal Elysia Context interface for compatibility.\n * @since 1.4.0\n */\nexport interface ElysiaContext {\n  request: Request;\n  path: string;\n  set: {\n    status: number;\n    headers: Record<string, string | undefined>;\n  };\n}\n\n/**\n * Plugin scope options for controlling hook propagation.\n * @since 1.4.0\n */\nexport type PluginScope = \"global\" | \"scoped\" | \"local\";\n\n/**\n * Predefined log format names compatible with Morgan.\n * @since 1.4.0\n */\nexport type PredefinedFormat = \"combined\" | \"common\" | \"dev\" | \"short\" | \"tiny\";\n\n/**\n * Custom format function for request logging.\n *\n * @param ctx The Elysia context object.\n * @param responseTime The response time in milliseconds.\n * @returns A string message or an object with structured properties.\n * @since 1.4.0\n */\nexport type FormatFunction = (\n  ctx: ElysiaContext,\n  responseTime: number,\n) => string | Record<string, unknown>;\n\n/**\n * Structured log properties for HTTP requests.\n * @since 1.4.0\n */\nexport interface RequestLogProperties {\n  /** HTTP request method */\n  method: string;\n  /** Request URL */\n  url: string;\n  /** Request path */\n  path: string;\n  /** HTTP response status code */\n  status: number;\n  /** Response time in milliseconds */\n  responseTime: number;\n  /** Response content-length header value */\n  contentLength: string | undefined;\n  /** Remote client address (from X-Forwarded-For header) */\n  remoteAddr: string | undefined;\n  /** User-Agent header value */\n  userAgent: string | undefined;\n  /** Referrer header value */\n  referrer: string | undefined;\n}\n\n/**\n * Options for configuring the Elysia LogTape middleware.\n * @since 1.4.0\n */\nexport interface ElysiaLogTapeOptions {\n  /**\n   * The LogTape category to use for logging.\n   * @default [\"elysia\"]\n   */\n  readonly category?: string | readonly string[];\n\n  /**\n   * The log level to use for request logging.\n   * @default \"info\"\n   */\n  readonly level?: LogLevel;\n\n  /**\n   * The format for log output.\n   * Can be a predefined format name or a custom format function.\n   *\n   * Predefined formats:\n   * - `\"combined\"` - Apache Combined Log Format (structured, default)\n   * - `\"common\"` - Apache Common Log Format (structured, no referrer/userAgent)\n   * - `\"dev\"` - Concise colored output for development (string)\n   * - `\"short\"` - Shorter than common (string)\n   * - `\"tiny\"` - Minimal output (string)\n   *\n   * @default \"combined\"\n   */\n  readonly format?: PredefinedFormat | FormatFunction;\n\n  /**\n   * Function to determine whether logging should be skipped.\n   * Return `true` to skip logging for a request.\n   *\n   * @example Skip logging for health check endpoint\n   * ```typescript\n   * app.use(elysiaLogger({\n   *   skip: (ctx) => ctx.path === \"/health\",\n   * }));\n   * ```\n   *\n   * @default () => false\n   */\n  readonly skip?: (ctx: ElysiaContext) => boolean;\n\n  /**\n   * If `true`, logs are written immediately when the request is received.\n   * If `false` (default), logs are written after the response is sent.\n   *\n   * Note: When `logRequest` is `true`, response-related properties\n   * (status, responseTime, contentLength) will not be available.\n   *\n   * @default false\n   */\n  readonly logRequest?: boolean;\n\n  /**\n   * The plugin scope for controlling how lifecycle hooks are propagated.\n   *\n   * - `\"global\"` - Hooks apply to all routes in the application\n   * - `\"scoped\"` - Hooks apply to the parent instance where the plugin is used\n   * - `\"local\"` - Hooks only apply within the plugin itself\n   *\n   * @default \"global\"\n   */\n  readonly scope?: PluginScope;\n}\n\n/**\n * Get referrer from request headers.\n */\nfunction getReferrer(request: Request): string | undefined {\n  return request.headers.get(\"referrer\") ??\n    request.headers.get(\"referer\") ??\n    undefined;\n}\n\n/**\n * Get user agent from request headers.\n */\nfunction getUserAgent(request: Request): string | undefined {\n  return request.headers.get(\"user-agent\") ?? undefined;\n}\n\n/**\n * Get remote address from X-Forwarded-For header.\n */\nfunction getRemoteAddr(request: Request): string | undefined {\n  const forwarded = request.headers.get(\"x-forwarded-for\");\n  if (forwarded) {\n    // X-Forwarded-For can contain multiple IPs, take the first one\n    const firstIp = forwarded.split(\",\")[0].trim();\n    return firstIp || undefined;\n  }\n  return undefined;\n}\n\n/**\n * Get content length from response headers.\n */\nfunction getContentLength(\n  headers: Record<string, string | undefined>,\n): string | undefined {\n  const contentLength = headers[\"content-length\"];\n  if (contentLength === undefined || contentLength === null) return undefined;\n  return contentLength;\n}\n\n/**\n * Build structured log properties from context.\n */\nfunction buildProperties(\n  ctx: ElysiaContext,\n  responseTime: number,\n): RequestLogProperties {\n  return {\n    method: ctx.request.method,\n    url: ctx.request.url,\n    path: ctx.path,\n    status: ctx.set.status,\n    responseTime,\n    contentLength: getContentLength(ctx.set.headers),\n    remoteAddr: getRemoteAddr(ctx.request),\n    userAgent: getUserAgent(ctx.request),\n    referrer: getReferrer(ctx.request),\n  };\n}\n\n/**\n * Combined format (Apache Combined Log Format).\n * Returns all structured properties.\n */\nfunction formatCombined(\n  ctx: ElysiaContext,\n  responseTime: number,\n): Record<string, unknown> {\n  return { ...buildProperties(ctx, responseTime) };\n}\n\n/**\n * Common format (Apache Common Log Format).\n * Like combined but without referrer and userAgent.\n */\nfunction formatCommon(\n  ctx: ElysiaContext,\n  responseTime: number,\n): Record<string, unknown> {\n  const props = buildProperties(ctx, responseTime);\n  const { referrer: _referrer, userAgent: _userAgent, ...rest } = props;\n  return rest;\n}\n\n/**\n * Dev format (colored output for development).\n * :method :path :status :response-time ms - :res[content-length]\n */\nfunction formatDev(ctx: ElysiaContext, responseTime: number): string {\n  const contentLength = getContentLength(ctx.set.headers) ?? \"-\";\n  return `${ctx.request.method} ${ctx.path} ${ctx.set.status} ${\n    responseTime.toFixed(3)\n  } ms - ${contentLength}`;\n}\n\n/**\n * Short format.\n * :remote-addr :method :url :status :res[content-length] - :response-time ms\n */\nfunction formatShort(ctx: ElysiaContext, responseTime: number): string {\n  const remoteAddr = getRemoteAddr(ctx.request) ?? \"-\";\n  const contentLength = getContentLength(ctx.set.headers) ?? \"-\";\n  return `${remoteAddr} ${ctx.request.method} ${ctx.request.url} ${ctx.set.status} ${contentLength} - ${\n    responseTime.toFixed(3)\n  } ms`;\n}\n\n/**\n * Tiny format (minimal output).\n * :method :path :status :res[content-length] - :response-time ms\n */\nfunction formatTiny(ctx: ElysiaContext, responseTime: number): string {\n  const contentLength = getContentLength(ctx.set.headers) ?? \"-\";\n  return `${ctx.request.method} ${ctx.path} ${ctx.set.status} ${contentLength} - ${\n    responseTime.toFixed(3)\n  } ms`;\n}\n\n/**\n * Map of predefined format functions.\n */\nconst predefinedFormats: Record<PredefinedFormat, FormatFunction> = {\n  combined: formatCombined,\n  common: formatCommon,\n  dev: formatDev,\n  short: formatShort,\n  tiny: formatTiny,\n};\n\n/**\n * Normalize category to array format.\n */\nfunction normalizeCategory(\n  category: string | readonly string[],\n): readonly string[] {\n  return typeof category === \"string\" ? [category] : category;\n}\n\n/**\n * Internal store type for timing.\n */\ninterface LoggerStore {\n  startTime: number;\n}\n\n/**\n * Creates Elysia plugin for HTTP request logging using LogTape.\n *\n * This plugin provides Morgan-compatible request logging with LogTape\n * as the backend, supporting structured logging and customizable formats.\n *\n * @example Basic usage\n * ```typescript\n * import { Elysia } from \"elysia\";\n * import { configure, getConsoleSink } from \"@logtape/logtape\";\n * import { elysiaLogger } from \"@logtape/elysia\";\n *\n * await configure({\n *   sinks: { console: getConsoleSink() },\n *   loggers: [\n *     { category: [\"elysia\"], sinks: [\"console\"], lowestLevel: \"info\" }\n *   ],\n * });\n *\n * const app = new Elysia()\n *   .use(elysiaLogger())\n *   .get(\"/\", () => ({ hello: \"world\" }))\n *   .listen(3000);\n * ```\n *\n * @example With custom options\n * ```typescript\n * app.use(elysiaLogger({\n *   category: [\"myapp\", \"http\"],\n *   level: \"debug\",\n *   format: \"dev\",\n *   skip: (ctx) => ctx.path === \"/health\",\n *   scope: \"scoped\",\n * }));\n * ```\n *\n * @example With custom format function\n * ```typescript\n * app.use(elysiaLogger({\n *   format: (ctx, responseTime) => ({\n *     method: ctx.request.method,\n *     path: ctx.path,\n *     status: ctx.set.status,\n *     duration: responseTime,\n *   }),\n * }));\n * ```\n *\n * @param options Configuration options for the plugin.\n * @returns Elysia plugin instance.\n * @since 1.4.0\n */\n// deno-lint-ignore no-explicit-any\nexport function elysiaLogger(options: ElysiaLogTapeOptions = {}): Elysia<any> {\n  const category = normalizeCategory(options.category ?? [\"elysia\"]);\n  const logger = getLogger(category);\n  const level = options.level ?? \"info\";\n  const formatOption = options.format ?? \"combined\";\n  const skip = options.skip ?? (() => false);\n  const logRequest = options.logRequest ?? false;\n  const scope = options.scope ?? \"global\";\n\n  // Resolve format function\n  const formatFn: FormatFunction = typeof formatOption === \"string\"\n    ? predefinedFormats[formatOption]\n    : formatOption;\n\n  const logMethod = logger[level].bind(logger);\n  const errorLogMethod = logger.error.bind(logger);\n\n  let plugin = new Elysia({\n    name: \"@logtape/elysia\",\n    seed: options,\n  })\n    .state(\"startTime\", 0)\n    .onRequest(({ store }) => {\n      (store as LoggerStore).startTime = performance.now();\n    });\n\n  if (logRequest) {\n    // Log immediately when request arrives\n    plugin = plugin.onRequest((ctx) => {\n      if (!skip(ctx as unknown as ElysiaContext)) {\n        const result = formatFn(ctx as unknown as ElysiaContext, 0);\n        if (typeof result === \"string\") {\n          logMethod(result);\n        } else {\n          logMethod(\"{method} {url}\", result);\n        }\n      }\n    });\n  } else {\n    // Log after handler completes\n    plugin = plugin.onAfterHandle((ctx) => {\n      if (skip(ctx as unknown as ElysiaContext)) return;\n\n      const store = ctx.store as LoggerStore;\n      const responseTime = performance.now() - store.startTime;\n      const result = formatFn(ctx as unknown as ElysiaContext, responseTime);\n\n      if (typeof result === \"string\") {\n        logMethod(result);\n      } else {\n        logMethod(\"{method} {url} {status} - {responseTime} ms\", result);\n      }\n    });\n  }\n\n  // Add error logging\n  plugin = plugin.onError((ctx) => {\n    const store = ctx.store as LoggerStore;\n    const responseTime = performance.now() - store.startTime;\n    const elysiaCtx = ctx as unknown as ElysiaContext;\n\n    if (skip(elysiaCtx)) return;\n\n    const props = buildProperties(elysiaCtx, responseTime);\n    // Extract error message safely\n    const error = ctx.error as { message?: string } | undefined;\n    const errorMessage = error?.message ?? \"Unknown error\";\n    errorLogMethod(\n      \"Error: {method} {url} {status} - {responseTime} ms - {errorMessage}\",\n      {\n        ...props,\n        errorMessage,\n        errorCode: ctx.code,\n      },\n    );\n  });\n\n  // Apply scope\n  if (scope === \"global\") {\n    // deno-lint-ignore no-explicit-any\n    return plugin.as(\"global\") as unknown as Elysia<any>;\n  } else if (scope === \"scoped\") {\n    // deno-lint-ignore no-explicit-any\n    return plugin.as(\"scoped\") as unknown as Elysia<any>;\n  }\n\n  // deno-lint-ignore no-explicit-any\n  return plugin as unknown as Elysia<any>;\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@logtape/elysia",
+  "version": "1.4.0-dev.1",
+  "description": "Elysia adapter for LogTape logging library",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "elysia",
+    "elysiajs",
+    "middleware",
+    "http",
+    "request",
+    "adapter",
+    "logtape",
+    "bun"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Hong Minhee",
+    "email": "hong@minhee.org",
+    "url": "https://hongminhee.org/"
+  },
+  "homepage": "https://logtape.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dahlia/logtape.git",
+    "directory": "packages/elysia/"
+  },
+  "bugs": {
+    "url": "https://github.com/dahlia/logtape/issues"
+  },
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "module": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts"
+      },
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
+  "peerDependencies": {
+    "elysia": "^1.4.0",
+    "@logtape/logtape": "^1.4.0"
+  },
+  "devDependencies": {
+    "@alinea/suite": "^0.6.3",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "@std/async": "npm:@jsr/std__async@^1.0.13",
+    "elysia": "^1.4.0",
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test --allow-env --allow-sys --allow-net",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test"
+  }
+}