@logtape/adaptor-pino 1.2.2 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/adaptor-pino",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Pino adapter for LogTape logging library",
   "keywords": [
     "logging",
@@ -45,9 +45,12 @@
     "./package.json": "./package.json"
   },
   "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
   "peerDependencies": {
     "pino": "^9.7.0",
-    "@logtape/logtape": "^1.2.2"
+    "@logtape/logtape": "^1.2.3"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",

package/deno.json

@@ -1,37 +0,0 @@
-{
-  "name": "@logtape/adaptor-pino",
-  "version": "1.2.2",
-  "license": "MIT",
-  "exports": "./src/mod.ts",
-  "imports": {
-    "pino-abstract-transport": "npm:pino-abstract-transport@^2.0.0"
-  },
-  "exclude": [
-    "coverage/",
-    "npm/",
-    ".dnt-import-map.json"
-  ],
-  "tasks": {
-    "build": "pnpm build",
-    "test": "deno test --allow-env --allow-sys",
-    "test:node": {
-      "dependencies": [
-        "build"
-      ],
-      "command": "node --experimental-transform-types --test"
-    },
-    "test:bun": {
-      "dependencies": [
-        "build"
-      ],
-      "command": "bun test"
-    },
-    "test-all": {
-      "dependencies": [
-        "test",
-        "test:node",
-        "test:bun"
-      ]
-    }
-  }
-}

package/src/mod.test.ts

@@ -1,405 +0,0 @@
-import { suite } from "@alinea/suite";
-import { assertEquals } from "@std/assert/equals";
-import { assertGreaterOrEqual } from "@std/assert/greater-or-equal";
-import { assertLessOrEqual } from "@std/assert/less-or-equal";
-import { delay } from "@std/async/delay";
-import os from "node:os";
-import process from "node:process";
-import { pino } from "pino";
-import build from "pino-abstract-transport";
-import { getPinoSink } from "./mod.ts";
-
-const test = suite(import.meta);
-
-interface PinoLog {
-  level: number;
-  time: number;
-  pid: number;
-  hostname: string;
-  value: Record<string, unknown>;
-  msg: string;
-  [key: string]: unknown; // Allow additional properties from LogTape properties
-}
-
-test("getPinoSink(): basic scenario", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-  const sink = getPinoSink(logger);
-  const before = Date.now();
-  sink({
-    category: ["test", "category"],
-    level: "info",
-    message: ["Test log: ", { foo: 123 }, ""],
-    properties: { value: { foo: 123 } },
-    rawMessage: "Test log: {value}",
-    timestamp: Date.now(),
-  });
-  const after = Date.now();
-  logger.flush();
-  await delay(500);
-  assertEquals(buffer, [
-    {
-      level: 30,
-      time: buffer[0]?.time,
-      pid: process.pid,
-      hostname: os.hostname(),
-      value: { foo: 123 },
-      msg: 'Test log: [{"foo":123}]',
-    },
-  ]);
-  assertGreaterOrEqual(buffer[0].time, before);
-  assertLessOrEqual(buffer[0].time, after);
-});
-
-test("getPinoSink(): log level mappings", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-  const sink = getPinoSink(logger);
-
-  const logLevels = [
-    { logTapeLevel: "info", expectedPinoLevel: 30 },
-    { logTapeLevel: "warning", expectedPinoLevel: 40 },
-    { logTapeLevel: "error", expectedPinoLevel: 50 },
-    { logTapeLevel: "fatal", expectedPinoLevel: 60 },
-  ] as const;
-
-  for (const { logTapeLevel } of logLevels) {
-    sink({
-      category: ["test"],
-      level: logTapeLevel,
-      message: [`${logTapeLevel} message`],
-      properties: {},
-      rawMessage: `${logTapeLevel} message`,
-      timestamp: Date.now(),
-    });
-  }
-
-  logger.flush();
-  await delay(100);
-
-  assertEquals(buffer.length, 4);
-  for (let i = 0; i < logLevels.length; i++) {
-    assertEquals(
-      buffer[i].level,
-      logLevels[i].expectedPinoLevel,
-      `Level mapping failed for ${logLevels[i].logTapeLevel}`,
-    );
-  }
-});
-
-test("getPinoSink(): category option - false/undefined", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-
-  // Test with category: false
-  const sinkFalse = getPinoSink(logger, { category: false });
-  sinkFalse({
-    category: ["test", "category"],
-    level: "info",
-    message: ["Test message"],
-    properties: {},
-    rawMessage: "Test message",
-    timestamp: Date.now(),
-  });
-
-  // Test with no options (undefined)
-  const sinkUndefined = getPinoSink(logger);
-  sinkUndefined({
-    category: ["test", "category"],
-    level: "info",
-    message: ["Test message 2"],
-    properties: {},
-    rawMessage: "Test message 2",
-    timestamp: Date.now(),
-  });
-
-  logger.flush();
-  await delay(100);
-
-  assertEquals(buffer.length, 2);
-  assertEquals(buffer[0].msg, "Test message");
-  assertEquals(buffer[1].msg, "Test message 2");
-  // Both should NOT include category in the message
-});
-
-test("getPinoSink(): category option - true (default formatting)", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-
-  const sink = getPinoSink(logger, { category: true });
-  sink({
-    category: ["test", "category"],
-    level: "info",
-    message: ["Test message"],
-    properties: {},
-    rawMessage: "Test message",
-    timestamp: Date.now(),
-  });
-
-  logger.flush();
-  await delay(100);
-
-  assertEquals(buffer.length, 1);
-  assertEquals(buffer[0].msg, "test·category: Test message");
-});
-
-test("getPinoSink(): category decorators", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-
-  const decorators = [
-    { decorator: "[]", expected: "[test] Message" },
-    { decorator: "()", expected: "(test) Message" },
-    { decorator: "<>", expected: "<test> Message" },
-    { decorator: "{}", expected: "{test} Message" },
-    { decorator: ":", expected: "test: Message" },
-    { decorator: "-", expected: "test - Message" },
-    { decorator: "|", expected: "test | Message" },
-    { decorator: "/", expected: "test / Message" },
-    { decorator: "", expected: "test Message" },
-  ] as const;
-
-  for (const { decorator } of decorators) {
-    const sink = getPinoSink(logger, {
-      category: { decorator, position: "start" },
-    });
-    sink({
-      category: ["test"],
-      level: "info",
-      message: ["Message"],
-      properties: {},
-      rawMessage: "Message",
-      timestamp: Date.now(),
-    });
-  }
-
-  logger.flush();
-  await delay(100);
-
-  assertEquals(buffer.length, decorators.length);
-  for (let i = 0; i < decorators.length; i++) {
-    assertEquals(
-      buffer[i].msg,
-      decorators[i].expected,
-      `Decorator '${decorators[i].decorator}' failed`,
-    );
-  }
-});
-
-test("getPinoSink(): category position (start vs end)", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-
-  // Test position: "start"
-  const sinkStart = getPinoSink(logger, {
-    category: { position: "start", decorator: "[]" },
-  });
-  sinkStart({
-    category: ["test"],
-    level: "info",
-    message: ["Message"],
-    properties: {},
-    rawMessage: "Message",
-    timestamp: Date.now(),
-  });
-
-  // Test position: "end"
-  const sinkEnd = getPinoSink(logger, {
-    category: { position: "end", decorator: "[]" },
-  });
-  sinkEnd({
-    category: ["test"],
-    level: "info",
-    message: ["Message"],
-    properties: {},
-    rawMessage: "Message",
-    timestamp: Date.now(),
-  });
-
-  logger.flush();
-  await delay(100);
-
-  assertEquals(buffer.length, 2);
-  assertEquals(buffer[0].msg, "[test] Message");
-  assertEquals(buffer[1].msg, "Message [test]");
-});
-
-test("getPinoSink(): category separator", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-
-  const separators = [
-    { separator: ".", expected: "[app.service.logger] Message" },
-    { separator: "/", expected: "[app/service/logger] Message" },
-    { separator: "::", expected: "[app::service::logger] Message" },
-    { separator: " > ", expected: "[app > service > logger] Message" },
-  ];
-
-  for (const { separator } of separators) {
-    const sink = getPinoSink(logger, {
-      category: { separator, decorator: "[]", position: "start" },
-    });
-    sink({
-      category: ["app", "service", "logger"],
-      level: "info",
-      message: ["Message"],
-      properties: {},
-      rawMessage: "Message",
-      timestamp: Date.now(),
-    });
-  }
-
-  logger.flush();
-  await delay(100);
-
-  assertEquals(buffer.length, separators.length);
-  for (let i = 0; i < separators.length; i++) {
-    assertEquals(
-      buffer[i].msg,
-      separators[i].expected,
-      `Separator '${separators[i].separator}' failed`,
-    );
-  }
-});
-
-test("getPinoSink(): empty category handling", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-
-  const sink = getPinoSink(logger, {
-    category: { decorator: "[]", position: "start" },
-  });
-
-  // Test with empty category array
-  sink({
-    category: [],
-    level: "info",
-    message: ["Message with empty category"],
-    properties: {},
-    rawMessage: "Message with empty category",
-    timestamp: Date.now(),
-  });
-
-  // Test with single empty string category
-  sink({
-    category: [""],
-    level: "info",
-    message: ["Message with empty string category"],
-    properties: {},
-    rawMessage: "Message with empty string category",
-    timestamp: Date.now(),
-  });
-
-  logger.flush();
-  await delay(100);
-
-  assertEquals(buffer.length, 2);
-  // Empty category array should not include category in message
-  assertEquals(buffer[0].msg, "Message with empty category");
-  // Single empty string should still show the decorator
-  assertEquals(buffer[1].msg, "[] Message with empty string category");
-});
-
-test("getPinoSink(): message interpolation", async () => {
-  const buffer: PinoLog[] = [];
-  const dest = build(async (source) => {
-    for await (const obj of source) {
-      buffer.push(obj);
-    }
-  }, {});
-  const logger = pino({
-    useOnlyCustomLevels: false,
-  }, dest);
-
-  const sink = getPinoSink(logger, {
-    category: { decorator: ":", position: "start" },
-  });
-
-  // Test message with interpolated values
-  sink({
-    category: ["app", "auth"],
-    level: "info",
-    message: [
-      "User ",
-      { userId: 123, username: "johndoe" },
-      " logged in",
-    ],
-    properties: { sessionId: "sess_abc123", source: "web" },
-    rawMessage: "User {user} logged in",
-    timestamp: Date.now(),
-  });
-
-  logger.flush();
-  await delay(100);
-
-  assertEquals(buffer.length, 1);
-
-  // Check that the message contains expected parts
-  const actualMsg = buffer[0].msg;
-  assertEquals(actualMsg.includes("app·auth"), true, "Should contain category");
-  assertEquals(actualMsg.includes("User"), true, "Should contain 'User'");
-  assertEquals(
-    actualMsg.includes("logged in"),
-    true,
-    "Should contain 'logged in'",
-  );
-
-  assertEquals(buffer[0].sessionId, "sess_abc123");
-  assertEquals(buffer[0].source, "web");
-});

package/src/mod.ts

@@ -1,250 +0,0 @@
-import type { Logger } from "pino";
-import { configureSync, type LogRecord, type Sink } from "@logtape/logtape";
-
-/**
- * Options for configuring the Pino sink adapter.
- * @since 1.0.0
- */
-export interface PinoSinkOptions {
-  /**
-   * Configuration for how LogTape categories are handled in Pino logs.
-   * - `false` or `undefined`: Categories are not included in the log message
-   * - `true`: Categories are included with default formatting
-   * - `CategoryOptions`: Custom category formatting configuration
-   */
-  readonly category?: boolean | CategoryOptions;
-}
-
-/**
- * Configuration options for formatting LogTape categories in Pino log messages.
- * @since 1.0.0
- */
-export interface CategoryOptions {
-  /**
-   * The separator used to join category parts when multiple categories exist.
-   * @default "·"
-   */
-  readonly separator?: string;
-
-  /**
-   * Where to position the category in the log message.
-   * - `"start"`: Category appears at the beginning of the message
-   * - `"end"`: Category appears at the end of the message
-   * @default "start"
-   */
-  readonly position?: "start" | "end";
-
-  /**
-   * The decorator used to format the category in the log message.
-   * - `"[]"`: [category] format
-   * - `"()"`: (category) format
-   * - `"<>"`: <category> format
-   * - `"{}"`: {category} format
-   * - `":"`: category: format
-   * - `"-"`: category - format
-   * - `"|"`: category | format
-   * - `"/"`: category / format
-   * - `""`: category format (no decoration)
-   * @default ":"
-   */
-  readonly decorator?: "[]" | "()" | "<>" | "{}" | ":" | "-" | "|" | "/" | "";
-}
-
-/**
- * Creates a LogTape sink that forwards log records to a Pino logger.
- *
- * This adapter allows LogTape-enabled libraries to integrate seamlessly with
- * applications that use Pino for logging.
- *
- * @example
- * ```typescript
- * import { configure } from "@logtape/logtape";
- * import { getPinoSink } from "@logtape/adaptor-pino";
- * import pino from "pino";
- *
- * const pinoLogger = pino();
- *
- * await configure({
- *   sinks: {
- *     pino: getPinoSink(pinoLogger, {
- *       category: {
- *         position: "start",
- *         decorator: "[]",
- *         separator: "."
- *       }
- *     })
- *   },
- *   loggers: [
- *     { category: "my-library", sinks: ["pino"] }
- *   ]
- * });
- * ```
- *
- * @template CustomLevels The custom log levels supported by the Pino logger.
- * @template UseOnlyCustomLevels Whether to use only custom levels defined
- *                                in the Pino logger.
- * @param logger The Pino logger instance to forward logs to.
- * @param options Configuration options for the sink adapter.
- * @returns A LogTape sink function that can be used in LogTape configuration.
- * @since 1.0.0
- */
-export function getPinoSink<
-  CustomLevels extends string,
-  UseOnlyCustomLevels extends boolean,
->(
-  logger: Logger<CustomLevels, UseOnlyCustomLevels>,
-  options: PinoSinkOptions = {},
-): Sink {
-  const categoryOptions = !options.category
-    ? undefined
-    : typeof options.category === "object"
-    ? options.category
-    : {};
-  const category: Required<CategoryOptions> | undefined =
-    categoryOptions == null ? undefined : {
-      separator: categoryOptions.separator ?? "·",
-      position: categoryOptions.position ?? "start",
-      decorator: categoryOptions.decorator ?? ":",
-    };
-  return (record: LogRecord) => {
-    let message = "";
-    const interpolationValues: unknown[] = [];
-    if (category?.position === "start" && record.category.length > 0) {
-      message += category.decorator === "[]"
-        ? "[%s] "
-        : category.decorator === "()"
-        ? "(%s) "
-        : category.decorator === "<>"
-        ? "<%s> "
-        : category.decorator === "{}"
-        ? "{%s} "
-        : category.decorator === ":"
-        ? "%s: "
-        : category.decorator === "-"
-        ? "%s - "
-        : category.decorator === "|"
-        ? "%s | "
-        : category.decorator === "/"
-        ? "%s / "
-        : "%s ";
-      interpolationValues.push(
-        record.category.join(category.separator),
-      );
-    }
-    for (let i = 0; i < record.message.length; i += 2) {
-      message += record.message[i];
-      if (i + 1 < record.message.length) {
-        message += "%o";
-        interpolationValues.push(record.message[i + 1]);
-      }
-    }
-    if (category?.position === "end" && record.category.length > 0) {
-      message += category.decorator === "[]"
-        ? " [%s]"
-        : category.decorator === "()"
-        ? " (%s)"
-        : category.decorator === "<>"
-        ? " <%s>"
-        : category.decorator === "{}"
-        ? " {%s}"
-        : category.decorator === ":"
-        ? ": %s"
-        : category.decorator === "-"
-        ? " - %s"
-        : category.decorator === "|"
-        ? " | %s"
-        : category.decorator === "/"
-        ? " / %s"
-        : " %s";
-      interpolationValues.push(
-        record.category.join(category.separator),
-      );
-    }
-    switch (record.level) {
-      case "trace":
-        return logger.trace(record.properties, message, interpolationValues);
-      case "debug":
-        return logger.debug(record.properties, message, interpolationValues);
-      case "info":
-        return logger.info(record.properties, message, interpolationValues);
-      case "warning":
-        return logger.warn(record.properties, message, interpolationValues);
-      case "error":
-        return logger.error(record.properties, message, interpolationValues);
-      case "fatal":
-        return logger.fatal(record.properties, message, interpolationValues);
-    }
-  };
-}
-
-/**
- * Automatically configures LogTape to route all logs to a Pino logger.
- *
- * This is a convenience function that automatically sets up LogTape to forward
- * all log records to a Pino logger instance.
- *
- * @example Basic auto-configuration
- * ```typescript
- * import pino from "pino";
- * import { install } from "@logtape/adaptor-pino";
- *
- * const pinoLogger = pino();
- *
- * // Automatically route all LogTape logs to the Pino logger
- * install(pinoLogger);
- *
- * // Now any LogTape-enabled library will log through Pino
- * import { getLogger } from "@logtape/logtape";
- * const logger = getLogger("my-app");
- * logger.info("This will be logged through Pino");
- * ```
- *
- * @example Auto-configuration with custom options
- * ```typescript
- * import pino from "pino";
- * import { install } from "@logtape/adaptor-pino";
- *
- * const pinoLogger = pino({
- *   level: "info",
- *   transport: {
- *     target: "pino-pretty"
- *   }
- * });
- *
- * install(pinoLogger, {
- *   category: {
- *     position: "start",
- *     decorator: "[]",
- *     separator: "."
- *   }
- * });
- * ```
- *
- * @template CustomLevels The custom log levels supported by the Pino logger.
- * @template UseOnlyCustomLevels Whether to use only custom levels defined
- *                                in the Pino logger.
- * @param logger The Pino logger instance to forward logs to.
- * @param options Configuration options for the sink adapter.
- * @since 1.0.0
- */
-export function install<
-  CustomLevels extends string,
-  UseOnlyCustomLevels extends boolean,
->(
-  logger: Logger<CustomLevels, UseOnlyCustomLevels>,
-  options: PinoSinkOptions = {},
-): void {
-  configureSync({
-    sinks: {
-      pino: getPinoSink(logger, options),
-    },
-    loggers: [
-      {
-        category: ["logtape", "meta"],
-        sinks: ["pino"],
-        lowestLevel: "warning",
-      },
-      { category: [], sinks: ["pino"] },
-    ],
-  });
-}

package/tsdown.config.ts

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