@logtape/fastify 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/deno.json

@@ -0,0 +1,34 @@
+{
+  "name": "@logtape/fastify",
+  "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,123 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/mod.ts
+/**
+* Creates a Pino-compatible logger that wraps LogTape.
+* This logger can be used as Fastify's `loggerInstance`.
+*
+* @example Basic usage
+* ```typescript
+* import Fastify from "fastify";
+* import { configure } from "@logtape/logtape";
+* import { getLogTapeFastifyLogger } from "@logtape/fastify";
+*
+* await configure({
+*   // ... LogTape configuration
+* });
+*
+* const fastify = Fastify({
+*   loggerInstance: getLogTapeFastifyLogger(),
+* });
+* ```
+*
+* @example With custom category
+* ```typescript
+* const fastify = Fastify({
+*   loggerInstance: getLogTapeFastifyLogger({
+*     category: ["myapp", "http"],
+*   }),
+* });
+* ```
+*
+* @param options Configuration options for the logger.
+* @returns A Pino-compatible logger wrapping LogTape.
+* @since 1.3.0
+*/
+function getLogTapeFastifyLogger(options = {}) {
+	const category = normalizeCategory(options.category ?? ["fastify"]);
+	const logger = (0, __logtape_logtape.getLogger)(category);
+	const initialLevel = options.level ?? "info";
+	return createPinoLikeLogger(logger, initialLevel);
+}
+/**
+* Normalize category to array format.
+*/
+function normalizeCategory(category) {
+	return typeof category === "string" ? [category] : category;
+}
+/**
+* Format message with printf-style interpolation.
+* Supports: %s (string), %d (number), %j (JSON), %o/%O (object), %% (escaped %)
+*/
+function formatMessage(template, ...args) {
+	let argIndex = 0;
+	return template.replace(/%[sdjoO%]/g, (match) => {
+		if (match === "%%") return "%";
+		if (argIndex >= args.length) return match;
+		const arg = args[argIndex++];
+		switch (match) {
+			case "%s": return String(arg);
+			case "%d": return Number(arg).toString();
+			case "%j":
+			case "%o":
+			case "%O": return JSON.stringify(arg);
+			default: return match;
+		}
+	});
+}
+/**
+* Creates a Pino-like logger wrapper around a LogTape logger.
+*/
+function createPinoLikeLogger(logger, initialLevel, bindings = {}) {
+	let _level = initialLevel;
+	const contextLogger = Object.keys(bindings).length > 0 ? logger.with(bindings) : logger;
+	/**
+	* Create a log method for a specific level.
+	*/
+	function createLogMethod(logFn) {
+		return function pinoLogMethod(objOrMsg, ...restArgs) {
+			if (typeof objOrMsg === "string") {
+				const message = formatMessage(objOrMsg, ...restArgs);
+				logFn(message);
+			} else if (typeof objOrMsg === "object" && objOrMsg !== null) {
+				const properties = { ...objOrMsg };
+				const [msgOrArg, ...args] = restArgs;
+				if (typeof msgOrArg === "string") {
+					const message = formatMessage(msgOrArg, ...args);
+					logFn(message, properties);
+				} else if ("msg" in properties && typeof properties.msg === "string") {
+					const message = properties.msg;
+					delete properties.msg;
+					logFn(message, properties);
+				} else logFn("{*}", properties);
+			}
+		};
+	}
+	const pinoLogger = {
+		trace: createLogMethod((msg, props) => contextLogger.trace(msg, props)),
+		debug: createLogMethod((msg, props) => contextLogger.debug(msg, props)),
+		info: createLogMethod((msg, props) => contextLogger.info(msg, props)),
+		warn: createLogMethod((msg, props) => contextLogger.warn(msg, props)),
+		error: createLogMethod((msg, props) => contextLogger.error(msg, props)),
+		fatal: createLogMethod((msg, props) => contextLogger.fatal(msg, props)),
+		silent: () => {},
+		child: (childBindings) => {
+			const mergedBindings = {
+				...bindings,
+				...childBindings
+			};
+			return createPinoLikeLogger(logger, _level, mergedBindings);
+		},
+		get level() {
+			return _level;
+		},
+		set level(newLevel) {
+			_level = newLevel;
+		}
+	};
+	return pinoLogger;
+}
+
+//#endregion
+exports.getLogTapeFastifyLogger = getLogTapeFastifyLogger;

package/dist/mod.d.cts

@@ -0,0 +1,115 @@
+//#region src/mod.d.ts
+/**
+ * Pino log levels as strings.
+ * @since 1.3.0
+ */
+type PinoLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "silent";
+/**
+ * Options for configuring the Fastify LogTape logger.
+ * @since 1.3.0
+ */
+interface FastifyLogTapeOptions {
+  /**
+   * The LogTape category to use for logging.
+   * @default ["fastify"]
+   */
+  readonly category?: string | readonly string[];
+  /**
+   * The initial log level. This is tracked internally to satisfy
+   * Pino's level property requirement.
+   * Note: Actual filtering is controlled by LogTape configuration.
+   * @default "info"
+   */
+  readonly level?: PinoLevel;
+}
+/**
+ * Pino-style log method supporting multiple signatures.
+ *
+ * Supports the following calling conventions:
+ * - `logger.info("message")` - Simple message
+ * - `logger.info("message %s", arg)` - Printf-style interpolation
+ * - `logger.info({ key: "value" }, "message")` - Object with message
+ * - `logger.info({ key: "value" })` - Object only
+ * - `logger.info({ msg: "message", key: "value" })` - Object with msg property
+ *
+ * @since 1.3.0
+ */
+interface PinoLogMethod {
+  /** Log with object and optional message */
+  (obj: Record<string, unknown>, msg?: string, ...args: unknown[]): void;
+  /** Log with just a message and optional interpolation args */
+  (msg: string, ...args: unknown[]): void;
+}
+/**
+ * A Pino-compatible logger interface that wraps LogTape.
+ * This interface satisfies Fastify's `loggerInstance` requirements.
+ *
+ * @example
+ * ```typescript
+ * import Fastify from "fastify";
+ * import { getLogTapeFastifyLogger } from "@logtape/fastify";
+ *
+ * const fastify = Fastify({
+ *   loggerInstance: getLogTapeFastifyLogger(),
+ * });
+ * ```
+ *
+ * @since 1.3.0
+ */
+interface PinoLikeLogger {
+  /** Log at trace level */
+  trace: PinoLogMethod;
+  /** Log at debug level */
+  debug: PinoLogMethod;
+  /** Log at info level */
+  info: PinoLogMethod;
+  /** Log at warn level */
+  warn: PinoLogMethod;
+  /** Log at error level */
+  error: PinoLogMethod;
+  /** Log at fatal level */
+  fatal: PinoLogMethod;
+  /** No-op silent method for Pino compatibility */
+  silent: () => void;
+  /** Create a child logger with additional bindings */
+  child: (bindings: Record<string, unknown>) => PinoLikeLogger;
+  /** Current log level (readable/writable for Pino compatibility) */
+  level: string;
+}
+/**
+ * Creates a Pino-compatible logger that wraps LogTape.
+ * This logger can be used as Fastify's `loggerInstance`.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import Fastify from "fastify";
+ * import { configure } from "@logtape/logtape";
+ * import { getLogTapeFastifyLogger } from "@logtape/fastify";
+ *
+ * await configure({
+ *   // ... LogTape configuration
+ * });
+ *
+ * const fastify = Fastify({
+ *   loggerInstance: getLogTapeFastifyLogger(),
+ * });
+ * ```
+ *
+ * @example With custom category
+ * ```typescript
+ * const fastify = Fastify({
+ *   loggerInstance: getLogTapeFastifyLogger({
+ *     category: ["myapp", "http"],
+ *   }),
+ * });
+ * ```
+ *
+ * @param options Configuration options for the logger.
+ * @returns A Pino-compatible logger wrapping LogTape.
+ * @since 1.3.0
+ */
+declare function getLogTapeFastifyLogger(options?: FastifyLogTapeOptions): PinoLikeLogger;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { FastifyLogTapeOptions, PinoLevel, PinoLikeLogger, PinoLogMethod, getLogTapeFastifyLogger };
+//# 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":";;AAMA;AAaA;AA4BA;AAuBiB,KAhEL,SAAA,GAgEmB,OAAA,GAAA,OAAA,GAAA,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,OAAA,GAAA,QAAA;;;;;AAQvB,UA3DS,qBAAA,CA2DT;EAAa;;;;EAQyC,SAAA,QAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA;EAqC9C;;;;AAEC;;mBA7FE;;;;;;;;;;;;;;UAeF,aAAA;;QAET;;;;;;;;;;;;;;;;;;;;UAqBS,cAAA;;SAER;;SAEA;;QAED;;QAEA;;SAEC;;SAEA;;;;oBAIW,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqChC,uBAAA,WACL,wBACR"}

package/dist/mod.d.ts

@@ -0,0 +1,115 @@
+//#region src/mod.d.ts
+/**
+ * Pino log levels as strings.
+ * @since 1.3.0
+ */
+type PinoLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "silent";
+/**
+ * Options for configuring the Fastify LogTape logger.
+ * @since 1.3.0
+ */
+interface FastifyLogTapeOptions {
+  /**
+   * The LogTape category to use for logging.
+   * @default ["fastify"]
+   */
+  readonly category?: string | readonly string[];
+  /**
+   * The initial log level. This is tracked internally to satisfy
+   * Pino's level property requirement.
+   * Note: Actual filtering is controlled by LogTape configuration.
+   * @default "info"
+   */
+  readonly level?: PinoLevel;
+}
+/**
+ * Pino-style log method supporting multiple signatures.
+ *
+ * Supports the following calling conventions:
+ * - `logger.info("message")` - Simple message
+ * - `logger.info("message %s", arg)` - Printf-style interpolation
+ * - `logger.info({ key: "value" }, "message")` - Object with message
+ * - `logger.info({ key: "value" })` - Object only
+ * - `logger.info({ msg: "message", key: "value" })` - Object with msg property
+ *
+ * @since 1.3.0
+ */
+interface PinoLogMethod {
+  /** Log with object and optional message */
+  (obj: Record<string, unknown>, msg?: string, ...args: unknown[]): void;
+  /** Log with just a message and optional interpolation args */
+  (msg: string, ...args: unknown[]): void;
+}
+/**
+ * A Pino-compatible logger interface that wraps LogTape.
+ * This interface satisfies Fastify's `loggerInstance` requirements.
+ *
+ * @example
+ * ```typescript
+ * import Fastify from "fastify";
+ * import { getLogTapeFastifyLogger } from "@logtape/fastify";
+ *
+ * const fastify = Fastify({
+ *   loggerInstance: getLogTapeFastifyLogger(),
+ * });
+ * ```
+ *
+ * @since 1.3.0
+ */
+interface PinoLikeLogger {
+  /** Log at trace level */
+  trace: PinoLogMethod;
+  /** Log at debug level */
+  debug: PinoLogMethod;
+  /** Log at info level */
+  info: PinoLogMethod;
+  /** Log at warn level */
+  warn: PinoLogMethod;
+  /** Log at error level */
+  error: PinoLogMethod;
+  /** Log at fatal level */
+  fatal: PinoLogMethod;
+  /** No-op silent method for Pino compatibility */
+  silent: () => void;
+  /** Create a child logger with additional bindings */
+  child: (bindings: Record<string, unknown>) => PinoLikeLogger;
+  /** Current log level (readable/writable for Pino compatibility) */
+  level: string;
+}
+/**
+ * Creates a Pino-compatible logger that wraps LogTape.
+ * This logger can be used as Fastify's `loggerInstance`.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import Fastify from "fastify";
+ * import { configure } from "@logtape/logtape";
+ * import { getLogTapeFastifyLogger } from "@logtape/fastify";
+ *
+ * await configure({
+ *   // ... LogTape configuration
+ * });
+ *
+ * const fastify = Fastify({
+ *   loggerInstance: getLogTapeFastifyLogger(),
+ * });
+ * ```
+ *
+ * @example With custom category
+ * ```typescript
+ * const fastify = Fastify({
+ *   loggerInstance: getLogTapeFastifyLogger({
+ *     category: ["myapp", "http"],
+ *   }),
+ * });
+ * ```
+ *
+ * @param options Configuration options for the logger.
+ * @returns A Pino-compatible logger wrapping LogTape.
+ * @since 1.3.0
+ */
+declare function getLogTapeFastifyLogger(options?: FastifyLogTapeOptions): PinoLikeLogger;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { FastifyLogTapeOptions, PinoLevel, PinoLikeLogger, PinoLogMethod, getLogTapeFastifyLogger };
+//# 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":";;AAMA;AAaA;AA4BA;AAuBiB,KAhEL,SAAA,GAgEmB,OAAA,GAAA,OAAA,GAAA,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,OAAA,GAAA,QAAA;;;;;AAQvB,UA3DS,qBAAA,CA2DT;EAAa;;;;EAQyC,SAAA,QAAA,CAAA,EAAA,MAAA,GAAA,SAAA,MAAA,EAAA;EAqC9C;;;;AAEC;;mBA7FE;;;;;;;;;;;;;;UAeF,aAAA;;QAET;;;;;;;;;;;;;;;;;;;;UAqBS,cAAA;;SAER;;SAEA;;QAED;;QAEA;;SAEC;;SAEA;;;;oBAIW,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqChC,uBAAA,WACL,wBACR"}

package/dist/mod.js

@@ -0,0 +1,123 @@
+import { getLogger } from "@logtape/logtape";
+
+//#region src/mod.ts
+/**
+* Creates a Pino-compatible logger that wraps LogTape.
+* This logger can be used as Fastify's `loggerInstance`.
+*
+* @example Basic usage
+* ```typescript
+* import Fastify from "fastify";
+* import { configure } from "@logtape/logtape";
+* import { getLogTapeFastifyLogger } from "@logtape/fastify";
+*
+* await configure({
+*   // ... LogTape configuration
+* });
+*
+* const fastify = Fastify({
+*   loggerInstance: getLogTapeFastifyLogger(),
+* });
+* ```
+*
+* @example With custom category
+* ```typescript
+* const fastify = Fastify({
+*   loggerInstance: getLogTapeFastifyLogger({
+*     category: ["myapp", "http"],
+*   }),
+* });
+* ```
+*
+* @param options Configuration options for the logger.
+* @returns A Pino-compatible logger wrapping LogTape.
+* @since 1.3.0
+*/
+function getLogTapeFastifyLogger(options = {}) {
+	const category = normalizeCategory(options.category ?? ["fastify"]);
+	const logger = getLogger(category);
+	const initialLevel = options.level ?? "info";
+	return createPinoLikeLogger(logger, initialLevel);
+}
+/**
+* Normalize category to array format.
+*/
+function normalizeCategory(category) {
+	return typeof category === "string" ? [category] : category;
+}
+/**
+* Format message with printf-style interpolation.
+* Supports: %s (string), %d (number), %j (JSON), %o/%O (object), %% (escaped %)
+*/
+function formatMessage(template, ...args) {
+	let argIndex = 0;
+	return template.replace(/%[sdjoO%]/g, (match) => {
+		if (match === "%%") return "%";
+		if (argIndex >= args.length) return match;
+		const arg = args[argIndex++];
+		switch (match) {
+			case "%s": return String(arg);
+			case "%d": return Number(arg).toString();
+			case "%j":
+			case "%o":
+			case "%O": return JSON.stringify(arg);
+			default: return match;
+		}
+	});
+}
+/**
+* Creates a Pino-like logger wrapper around a LogTape logger.
+*/
+function createPinoLikeLogger(logger, initialLevel, bindings = {}) {
+	let _level = initialLevel;
+	const contextLogger = Object.keys(bindings).length > 0 ? logger.with(bindings) : logger;
+	/**
+	* Create a log method for a specific level.
+	*/
+	function createLogMethod(logFn) {
+		return function pinoLogMethod(objOrMsg, ...restArgs) {
+			if (typeof objOrMsg === "string") {
+				const message = formatMessage(objOrMsg, ...restArgs);
+				logFn(message);
+			} else if (typeof objOrMsg === "object" && objOrMsg !== null) {
+				const properties = { ...objOrMsg };
+				const [msgOrArg, ...args] = restArgs;
+				if (typeof msgOrArg === "string") {
+					const message = formatMessage(msgOrArg, ...args);
+					logFn(message, properties);
+				} else if ("msg" in properties && typeof properties.msg === "string") {
+					const message = properties.msg;
+					delete properties.msg;
+					logFn(message, properties);
+				} else logFn("{*}", properties);
+			}
+		};
+	}
+	const pinoLogger = {
+		trace: createLogMethod((msg, props) => contextLogger.trace(msg, props)),
+		debug: createLogMethod((msg, props) => contextLogger.debug(msg, props)),
+		info: createLogMethod((msg, props) => contextLogger.info(msg, props)),
+		warn: createLogMethod((msg, props) => contextLogger.warn(msg, props)),
+		error: createLogMethod((msg, props) => contextLogger.error(msg, props)),
+		fatal: createLogMethod((msg, props) => contextLogger.fatal(msg, props)),
+		silent: () => {},
+		child: (childBindings) => {
+			const mergedBindings = {
+				...bindings,
+				...childBindings
+			};
+			return createPinoLikeLogger(logger, _level, mergedBindings);
+		},
+		get level() {
+			return _level;
+		},
+		set level(newLevel) {
+			_level = newLevel;
+		}
+	};
+	return pinoLogger;
+}
+
+//#endregion
+export { getLogTapeFastifyLogger };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["options: FastifyLogTapeOptions","category: string | readonly string[]","template: string","logger: Logger","initialLevel: PinoLevel","bindings: Record<string, unknown>","_level: string","logFn: (msg: string, props?: Record<string, unknown>) => void","objOrMsg: Record<string, unknown> | string","pinoLogger: PinoLikeLogger","childBindings: Record<string, unknown>","newLevel: string"],"sources":["../src/mod.ts"],"sourcesContent":["import { getLogger, type Logger } from \"@logtape/logtape\";\n\n/**\n * Pino log levels as strings.\n * @since 1.3.0\n */\nexport type PinoLevel =\n  | \"trace\"\n  | \"debug\"\n  | \"info\"\n  | \"warn\"\n  | \"error\"\n  | \"fatal\"\n  | \"silent\";\n\n/**\n * Options for configuring the Fastify LogTape logger.\n * @since 1.3.0\n */\nexport interface FastifyLogTapeOptions {\n  /**\n   * The LogTape category to use for logging.\n   * @default [\"fastify\"]\n   */\n  readonly category?: string | readonly string[];\n\n  /**\n   * The initial log level. This is tracked internally to satisfy\n   * Pino's level property requirement.\n   * Note: Actual filtering is controlled by LogTape configuration.\n   * @default \"info\"\n   */\n  readonly level?: PinoLevel;\n}\n\n/**\n * Pino-style log method supporting multiple signatures.\n *\n * Supports the following calling conventions:\n * - `logger.info(\"message\")` - Simple message\n * - `logger.info(\"message %s\", arg)` - Printf-style interpolation\n * - `logger.info({ key: \"value\" }, \"message\")` - Object with message\n * - `logger.info({ key: \"value\" })` - Object only\n * - `logger.info({ msg: \"message\", key: \"value\" })` - Object with msg property\n *\n * @since 1.3.0\n */\nexport interface PinoLogMethod {\n  /** Log with object and optional message */\n  (obj: Record<string, unknown>, msg?: string, ...args: unknown[]): void;\n  /** Log with just a message and optional interpolation args */\n  (msg: string, ...args: unknown[]): void;\n}\n\n/**\n * A Pino-compatible logger interface that wraps LogTape.\n * This interface satisfies Fastify's `loggerInstance` requirements.\n *\n * @example\n * ```typescript\n * import Fastify from \"fastify\";\n * import { getLogTapeFastifyLogger } from \"@logtape/fastify\";\n *\n * const fastify = Fastify({\n *   loggerInstance: getLogTapeFastifyLogger(),\n * });\n * ```\n *\n * @since 1.3.0\n */\nexport interface PinoLikeLogger {\n  /** Log at trace level */\n  trace: PinoLogMethod;\n  /** Log at debug level */\n  debug: PinoLogMethod;\n  /** Log at info level */\n  info: PinoLogMethod;\n  /** Log at warn level */\n  warn: PinoLogMethod;\n  /** Log at error level */\n  error: PinoLogMethod;\n  /** Log at fatal level */\n  fatal: PinoLogMethod;\n  /** No-op silent method for Pino compatibility */\n  silent: () => void;\n  /** Create a child logger with additional bindings */\n  child: (bindings: Record<string, unknown>) => PinoLikeLogger;\n  /** Current log level (readable/writable for Pino compatibility) */\n  level: string;\n}\n\n/**\n * Creates a Pino-compatible logger that wraps LogTape.\n * This logger can be used as Fastify's `loggerInstance`.\n *\n * @example Basic usage\n * ```typescript\n * import Fastify from \"fastify\";\n * import { configure } from \"@logtape/logtape\";\n * import { getLogTapeFastifyLogger } from \"@logtape/fastify\";\n *\n * await configure({\n *   // ... LogTape configuration\n * });\n *\n * const fastify = Fastify({\n *   loggerInstance: getLogTapeFastifyLogger(),\n * });\n * ```\n *\n * @example With custom category\n * ```typescript\n * const fastify = Fastify({\n *   loggerInstance: getLogTapeFastifyLogger({\n *     category: [\"myapp\", \"http\"],\n *   }),\n * });\n * ```\n *\n * @param options Configuration options for the logger.\n * @returns A Pino-compatible logger wrapping LogTape.\n * @since 1.3.0\n */\nexport function getLogTapeFastifyLogger(\n  options: FastifyLogTapeOptions = {},\n): PinoLikeLogger {\n  const category = normalizeCategory(options.category ?? [\"fastify\"]);\n  const logger = getLogger(category);\n  const initialLevel = options.level ?? \"info\";\n\n  return createPinoLikeLogger(logger, initialLevel);\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 * Format message with printf-style interpolation.\n * Supports: %s (string), %d (number), %j (JSON), %o/%O (object), %% (escaped %)\n */\nfunction formatMessage(template: string, ...args: unknown[]): string {\n  let argIndex = 0;\n  return template.replace(/%[sdjoO%]/g, (match) => {\n    if (match === \"%%\") return \"%\";\n    if (argIndex >= args.length) return match;\n\n    const arg = args[argIndex++];\n    switch (match) {\n      case \"%s\":\n        return String(arg);\n      case \"%d\":\n        return Number(arg).toString();\n      case \"%j\":\n      case \"%o\":\n      case \"%O\":\n        return JSON.stringify(arg);\n      default:\n        return match;\n    }\n  });\n}\n\n/**\n * Creates a Pino-like logger wrapper around a LogTape logger.\n */\nfunction createPinoLikeLogger(\n  logger: Logger,\n  initialLevel: PinoLevel,\n  bindings: Record<string, unknown> = {},\n): PinoLikeLogger {\n  // Track level internally for Pino compatibility\n  let _level: string = initialLevel;\n\n  // If there are bindings, create a contextual logger\n  const contextLogger = Object.keys(bindings).length > 0\n    ? logger.with(bindings)\n    : logger;\n\n  /**\n   * Create a log method for a specific level.\n   */\n  function createLogMethod(\n    logFn: (msg: string, props?: Record<string, unknown>) => void,\n  ): PinoLogMethod {\n    return function pinoLogMethod(\n      objOrMsg: Record<string, unknown> | string,\n      ...restArgs: unknown[]\n    ): void {\n      // Detect calling convention\n      if (typeof objOrMsg === \"string\") {\n        // Called as: logger.info(\"message\") or logger.info(\"message %s\", arg)\n        const message = formatMessage(objOrMsg, ...restArgs);\n        logFn(message);\n      } else if (typeof objOrMsg === \"object\" && objOrMsg !== null) {\n        // Called as: logger.info({ key: value }, \"message\") or logger.info({ key: value })\n        const properties = { ...objOrMsg };\n        const [msgOrArg, ...args] = restArgs;\n\n        if (typeof msgOrArg === \"string\") {\n          // Has message string: logger.info({ foo: 1 }, \"message %s\", arg)\n          const message = formatMessage(msgOrArg, ...args);\n          logFn(message, properties);\n        } else if (\"msg\" in properties && typeof properties.msg === \"string\") {\n          // Extract message from object: logger.info({ msg: \"hello\", foo: 1 })\n          const message = properties.msg as string;\n          delete properties.msg;\n          logFn(message, properties);\n        } else {\n          // Object-only logging: logger.info({ foo: 1 })\n          logFn(\"{*}\", properties);\n        }\n      }\n    } as PinoLogMethod;\n  }\n\n  const pinoLogger: PinoLikeLogger = {\n    trace: createLogMethod((msg, props) => contextLogger.trace(msg, props)),\n    debug: createLogMethod((msg, props) => contextLogger.debug(msg, props)),\n    info: createLogMethod((msg, props) => contextLogger.info(msg, props)),\n    warn: createLogMethod((msg, props) => contextLogger.warn(msg, props)),\n    error: createLogMethod((msg, props) => contextLogger.error(msg, props)),\n    fatal: createLogMethod((msg, props) => contextLogger.fatal(msg, props)),\n\n    silent: () => {\n      // No-op for silent level\n    },\n\n    child: (childBindings: Record<string, unknown>) => {\n      // Merge parent bindings with child bindings\n      const mergedBindings = { ...bindings, ...childBindings };\n      return createPinoLikeLogger(logger, _level as PinoLevel, mergedBindings);\n    },\n\n    get level() {\n      return _level;\n    },\n\n    set level(newLevel: string) {\n      // Store level for Pino compatibility\n      // Note: Actual filtering is handled by LogTape configuration\n      _level = newLevel;\n    },\n  };\n\n  return pinoLogger;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2HA,SAAgB,wBACdA,UAAiC,CAAE,GACnB;CAChB,MAAM,WAAW,kBAAkB,QAAQ,YAAY,CAAC,SAAU,EAAC;CACnE,MAAM,SAAS,UAAU,SAAS;CAClC,MAAM,eAAe,QAAQ,SAAS;AAEtC,QAAO,qBAAqB,QAAQ,aAAa;AAClD;;;;AAKD,SAAS,kBACPC,UACmB;AACnB,eAAc,aAAa,WAAW,CAAC,QAAS,IAAG;AACpD;;;;;AAMD,SAAS,cAAcC,UAAkB,GAAG,MAAyB;CACnE,IAAI,WAAW;AACf,QAAO,SAAS,QAAQ,cAAc,CAAC,UAAU;AAC/C,MAAI,UAAU,KAAM,QAAO;AAC3B,MAAI,YAAY,KAAK,OAAQ,QAAO;EAEpC,MAAM,MAAM,KAAK;AACjB,UAAQ,OAAR;GACE,KAAK,KACH,QAAO,OAAO,IAAI;GACpB,KAAK,KACH,QAAO,OAAO,IAAI,CAAC,UAAU;GAC/B,KAAK;GACL,KAAK;GACL,KAAK,KACH,QAAO,KAAK,UAAU,IAAI;GAC5B,QACE,QAAO;EACV;CACF,EAAC;AACH;;;;AAKD,SAAS,qBACPC,QACAC,cACAC,WAAoC,CAAE,GACtB;CAEhB,IAAIC,SAAiB;CAGrB,MAAM,gBAAgB,OAAO,KAAK,SAAS,CAAC,SAAS,IACjD,OAAO,KAAK,SAAS,GACrB;;;;CAKJ,SAAS,gBACPC,OACe;AACf,SAAO,SAAS,cACdC,UACA,GAAG,UACG;AAEN,cAAW,aAAa,UAAU;IAEhC,MAAM,UAAU,cAAc,UAAU,GAAG,SAAS;AACpD,UAAM,QAAQ;GACf,kBAAiB,aAAa,YAAY,aAAa,MAAM;IAE5D,MAAM,aAAa,EAAE,GAAG,SAAU;IAClC,MAAM,CAAC,UAAU,GAAG,KAAK,GAAG;AAE5B,eAAW,aAAa,UAAU;KAEhC,MAAM,UAAU,cAAc,UAAU,GAAG,KAAK;AAChD,WAAM,SAAS,WAAW;IAC3B,WAAU,SAAS,qBAAqB,WAAW,QAAQ,UAAU;KAEpE,MAAM,UAAU,WAAW;AAC3B,YAAO,WAAW;AAClB,WAAM,SAAS,WAAW;IAC3B,MAEC,OAAM,OAAO,WAAW;GAE3B;EACF;CACF;CAED,MAAMC,aAA6B;EACjC,OAAO,gBAAgB,CAAC,KAAK,UAAU,cAAc,MAAM,KAAK,MAAM,CAAC;EACvE,OAAO,gBAAgB,CAAC,KAAK,UAAU,cAAc,MAAM,KAAK,MAAM,CAAC;EACvE,MAAM,gBAAgB,CAAC,KAAK,UAAU,cAAc,KAAK,KAAK,MAAM,CAAC;EACrE,MAAM,gBAAgB,CAAC,KAAK,UAAU,cAAc,KAAK,KAAK,MAAM,CAAC;EACrE,OAAO,gBAAgB,CAAC,KAAK,UAAU,cAAc,MAAM,KAAK,MAAM,CAAC;EACvE,OAAO,gBAAgB,CAAC,KAAK,UAAU,cAAc,MAAM,KAAK,MAAM,CAAC;EAEvE,QAAQ,MAAM,CAEb;EAED,OAAO,CAACC,kBAA2C;GAEjD,MAAM,iBAAiB;IAAE,GAAG;IAAU,GAAG;GAAe;AACxD,UAAO,qBAAqB,QAAQ,QAAqB,eAAe;EACzE;EAED,IAAI,QAAQ;AACV,UAAO;EACR;EAED,IAAI,MAAMC,UAAkB;AAG1B,YAAS;EACV;CACF;AAED,QAAO;AACR"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@logtape/fastify",
+  "version": "1.3.0-dev.1",
+  "description": "Fastify adapter for LogTape logging library",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "fastify",
+    "pino",
+    "adapter",
+    "logtape"
+  ],
+  "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/fastify/"
+  },
+  "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,
+  "peerDependencies": {
+    "@logtape/logtape": "^1.3.0"
+  },
+  "devDependencies": {
+    "@alinea/suite": "^0.6.3",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "fastify": "^5.0.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"
+  }
+}