@logtape/express 1.4.0-dev.409 → 1.4.0-dev.413

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/express",
-  "version": "1.4.0-dev.409+63c2cd45",
+  "version": "1.4.0-dev.413+1097da33",
   "description": "Express adapter for LogTape logging library",
   "keywords": [
     "logging",
@@ -48,9 +48,12 @@
     "./package.json": "./package.json"
   },
   "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
   "peerDependencies": {
     "express": "^4.0.0 || ^5.0.0",
-    "@logtape/logtape": "^1.4.0-dev.409+63c2cd45"
+    "@logtape/logtape": "^1.4.0-dev.413+1097da33"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",

package/deno.json

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

package/src/mod.test.ts

@@ -1,875 +0,0 @@
-import { suite } from "@alinea/suite";
-import { assert, assertEquals, assertExists } from "@std/assert";
-import { configure, type LogRecord, reset } from "@logtape/logtape";
-import {
-  expressLogger,
-  type ExpressNextFunction,
-  type ExpressRequest,
-  type ExpressResponse,
-} from "./mod.ts";
-import { EventEmitter } from "node:events";
-
-const test = suite(import.meta);
-
-// Test fixture: Collect log records, filtering out internal LogTape meta logs
-function createTestSink(): {
-  sink: (record: LogRecord) => void;
-  logs: LogRecord[];
-} {
-  const logs: LogRecord[] = [];
-  return {
-    sink: (record: LogRecord) => {
-      if (record.category[0] !== "logtape") {
-        logs.push(record);
-      }
-    },
-    logs,
-  };
-}
-
-// Setup helper
-async function setupLogtape(): Promise<{
-  logs: LogRecord[];
-  cleanup: () => Promise<void>;
-}> {
-  const { sink, logs } = createTestSink();
-  await configure({
-    sinks: { test: sink },
-    loggers: [{ category: [], sinks: ["test"] }],
-  });
-  return { logs, cleanup: () => reset() };
-}
-
-// Mock Express request
-function createMockRequest(
-  overrides: Partial<ExpressRequest> = {},
-): ExpressRequest {
-  return {
-    method: "GET",
-    url: "/test",
-    originalUrl: "/test",
-    httpVersion: "1.1",
-    ip: "127.0.0.1",
-    socket: { remoteAddress: "127.0.0.1" },
-    get: (header: string) => {
-      const headers: Record<string, string> = {
-        "user-agent": "test-agent/1.0",
-        "referrer": "http://example.com",
-        "referer": "http://example.com",
-      };
-      return headers[header.toLowerCase()];
-    },
-    ...overrides,
-  };
-}
-
-// Mock Express response with EventEmitter
-function createMockResponse(
-  overrides: Partial<
-    ExpressResponse & {
-      setHeader: (name: string, value: string | number) => void;
-    }
-  > = {},
-): ExpressResponse & {
-  setHeader: (name: string, value: string | number) => void;
-} {
-  const emitter = new EventEmitter();
-  const headers: Record<string, string | number> = {};
-
-  return {
-    statusCode: 200,
-    on: emitter.on.bind(emitter) as ExpressResponse["on"],
-    getHeader: (name: string) => headers[name.toLowerCase()],
-    setHeader: (name: string, value: string | number) => {
-      headers[name.toLowerCase()] = value;
-    },
-    _emitter: emitter,
-    ...overrides,
-  } as ExpressResponse & {
-    setHeader: (name: string, value: string | number) => void;
-    _emitter?: EventEmitter;
-  };
-}
-
-// Helper to simulate response finish
-function finishResponse(res: ExpressResponse): void {
-  // @ts-ignore - accessing internal emitter for testing
-  const emitter = (res as { _emitter?: EventEmitter })._emitter;
-  if (emitter) {
-    emitter.emit("finish");
-  }
-}
-
-// ============================================
-// Basic Middleware Creation Tests
-// ============================================
-
-test("expressLogger(): creates a middleware function", async () => {
-  const { cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-
-    assertEquals(typeof middleware, "function");
-    assertEquals(middleware.length, 3); // req, res, next
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): calls next() to continue middleware chain", async () => {
-  const { cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest();
-    const res = createMockResponse();
-    let nextCalled = false;
-    const next: ExpressNextFunction = () => {
-      nextCalled = true;
-    };
-
-    middleware(req, res, next);
-
-    assert(nextCalled);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Category Configuration Tests
-// ============================================
-
-test("expressLogger(): uses default category ['express']", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["express"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): uses custom category array", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ category: ["myapp", "http"] });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["myapp", "http"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): accepts string category", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ category: "myapp" });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].category, ["myapp"]);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Log Level Tests
-// ============================================
-
-test("expressLogger(): uses default log level 'info'", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "info");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): uses custom log level 'debug'", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ level: "debug" });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "debug");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): uses custom log level 'warning'", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ level: "warning" });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "warning");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): uses custom log level 'error'", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ level: "error" });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].level, "error");
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Combined (default)
-// ============================================
-
-test("expressLogger(): combined format logs structured properties", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ format: "combined" });
-    const req = createMockRequest();
-    const res = createMockResponse({ statusCode: 200 });
-    res.setHeader(
-      "content-length",
-      "123",
-    );
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    const props = logs[0].properties;
-    assertEquals(props.method, "GET");
-    assertEquals(props.url, "/test");
-    assertEquals(props.status, 200);
-    assertExists(props.responseTime);
-    assertEquals(props.contentLength, "123");
-    assertEquals(props.remoteAddr, "127.0.0.1");
-    assertEquals(props.userAgent, "test-agent/1.0");
-    assertEquals(props.referrer, "http://example.com");
-    assertEquals(props.httpVersion, "1.1");
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Common
-// ============================================
-
-test("expressLogger(): common format excludes referrer and userAgent", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ format: "common" });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    const props = logs[0].properties;
-    assertEquals(props.method, "GET");
-    assertEquals(props.url, "/test");
-    assertEquals(props.status, 200);
-    assertEquals(props.referrer, undefined);
-    assertEquals(props.userAgent, undefined);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Dev
-// ============================================
-
-test("expressLogger(): dev format returns string message", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ format: "dev" });
-    const req = createMockRequest({
-      method: "POST",
-      originalUrl: "/api/users",
-    });
-    const res = createMockResponse({ statusCode: 201 });
-    res.setHeader(
-      "content-length",
-      "456",
-    );
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    const msg = logs[0].rawMessage;
-    assert(msg.includes("POST"));
-    assert(msg.includes("/api/users"));
-    assert(msg.includes("201"));
-    assert(msg.includes("ms"));
-    assert(msg.includes("456"));
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Short
-// ============================================
-
-test("expressLogger(): short format includes remote addr", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ format: "short" });
-    const req = createMockRequest({ ip: "192.168.1.1" });
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    const msg = logs[0].rawMessage;
-    assert(msg.includes("192.168.1.1"));
-    assert(msg.includes("GET"));
-    assert(msg.includes("/test"));
-    assert(msg.includes("HTTP/1.1"));
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Format Tests - Tiny
-// ============================================
-
-test("expressLogger(): tiny format is minimal", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ format: "tiny" });
-    const req = createMockRequest();
-    const res = createMockResponse({ statusCode: 404 });
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    const msg = logs[0].rawMessage;
-    assert(msg.includes("GET"));
-    assert(msg.includes("/test"));
-    assert(msg.includes("404"));
-    assert(msg.includes("ms"));
-    // Should NOT include remote addr in tiny format
-    assert(!msg.includes("127.0.0.1"));
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Custom Format Function Tests
-// ============================================
-
-test("expressLogger(): custom format returning string", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({
-      format: (req, res, _responseTime) =>
-        `Custom: ${req.method} ${res.statusCode}`,
-    });
-    const req = createMockRequest({ method: "DELETE" });
-    const res = createMockResponse({ statusCode: 204 });
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].rawMessage, "Custom: DELETE 204");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): custom format returning object", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({
-      format: (req, res, responseTime) => ({
-        customMethod: req.method,
-        customStatus: res.statusCode,
-        customDuration: responseTime,
-      }),
-    });
-    const req = createMockRequest({ method: "PATCH" });
-    const res = createMockResponse({ statusCode: 202 });
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.customMethod, "PATCH");
-    assertEquals(logs[0].properties.customStatus, 202);
-    assertExists(logs[0].properties.customDuration);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Skip Function Tests
-// ============================================
-
-test("expressLogger(): skip function prevents logging when returns true", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({
-      skip: () => true,
-    });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 0);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): skip function allows logging when returns false", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({
-      skip: () => false,
-    });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): skip function receives req and res", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({
-      skip: (_req, res) => res.statusCode < 400,
-    });
-
-    // Request with 200 status - should skip
-    const req1 = createMockRequest();
-    const res1 = createMockResponse({ statusCode: 200 });
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req1, res1, next);
-    finishResponse(res1);
-
-    assertEquals(logs.length, 0); // Skipped
-
-    // Request with 500 status - should log
-    const req2 = createMockRequest();
-    const res2 = createMockResponse({ statusCode: 500 });
-
-    middleware(req2, res2, next);
-    finishResponse(res2);
-
-    assertEquals(logs.length, 1); // Logged
-    assertEquals(logs[0].properties.status, 500);
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Immediate Mode Tests
-// ============================================
-
-test("expressLogger(): immediate mode logs before response", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ immediate: true });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    // Note: Don't call finishResponse - it should already be logged
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.responseTime, 0); // Zero because it's immediate
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): non-immediate mode logs after response", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger({ immediate: false });
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-
-    assertEquals(logs.length, 0); // Not logged yet
-
-    finishResponse(res);
-
-    assertEquals(logs.length, 1); // Now logged
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Request Property Tests
-// ============================================
-
-test("expressLogger(): logs correct method", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-
-    const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
-    for (const method of methods) {
-      const req = createMockRequest({ method });
-      const res = createMockResponse();
-      const next: ExpressNextFunction = () => {};
-
-      middleware(req, res, next);
-      finishResponse(res);
-    }
-
-    assertEquals(logs.length, methods.length);
-    for (let i = 0; i < methods.length; i++) {
-      assertEquals(logs[i].properties.method, methods[i]);
-    }
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): logs originalUrl over url", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest({
-      url: "/internal",
-      originalUrl: "/api/v1/users",
-    });
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.url, "/api/v1/users");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): falls back to url when originalUrl is undefined", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest({
-      url: "/fallback",
-      originalUrl: undefined as unknown as string,
-    });
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.url, "/fallback");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): logs status code", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-
-    const statusCodes = [200, 201, 301, 400, 404, 500];
-    for (const statusCode of statusCodes) {
-      const req = createMockRequest();
-      const res = createMockResponse({ statusCode });
-      const next: ExpressNextFunction = () => {};
-
-      middleware(req, res, next);
-      finishResponse(res);
-    }
-
-    assertEquals(logs.length, statusCodes.length);
-    for (let i = 0; i < statusCodes.length; i++) {
-      assertEquals(logs[i].properties.status, statusCodes[i]);
-    }
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): logs response time as number", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-
-    // Add small delay to ensure non-zero response time
-    await new Promise((resolve) => setTimeout(resolve, 10));
-
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(typeof logs[0].properties.responseTime, "number");
-    assert((logs[0].properties.responseTime as number) >= 0);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): logs content-length when present", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest();
-    const res = createMockResponse();
-    res.setHeader(
-      "content-length",
-      "1024",
-    );
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.contentLength, "1024");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): logs undefined contentLength when not set", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest();
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.contentLength, undefined);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): logs remote address from req.ip", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest({ ip: "10.0.0.1" });
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.remoteAddr, "10.0.0.1");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): falls back to socket.remoteAddress", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest({
-      ip: undefined as unknown as string,
-      socket: { remoteAddress: "192.168.0.1" },
-    });
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.remoteAddr, "192.168.0.1");
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): logs HTTP version", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest({ httpVersion: "2.0" });
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.httpVersion, "2.0");
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Multiple Requests Tests
-// ============================================
-
-test("expressLogger(): handles multiple sequential requests", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-
-    for (let i = 0; i < 5; i++) {
-      const req = createMockRequest({ originalUrl: `/path/${i}` });
-      const res = createMockResponse({ statusCode: 200 + i });
-      const next: ExpressNextFunction = () => {};
-
-      middleware(req, res, next);
-      finishResponse(res);
-    }
-
-    assertEquals(logs.length, 5);
-    for (let i = 0; i < 5; i++) {
-      assertEquals(logs[i].properties.url, `/path/${i}`);
-      assertEquals(logs[i].properties.status, 200 + i);
-    }
-  } finally {
-    await cleanup();
-  }
-});
-
-// ============================================
-// Edge Cases
-// ============================================
-
-test("expressLogger(): handles missing user-agent", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest({
-      get: () => undefined,
-    });
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.userAgent, undefined);
-  } finally {
-    await cleanup();
-  }
-});
-
-test("expressLogger(): handles missing referrer", async () => {
-  const { logs, cleanup } = await setupLogtape();
-  try {
-    const middleware = expressLogger();
-    const req = createMockRequest({
-      get: (header: string) => {
-        if (header.toLowerCase() === "user-agent") return "test-agent";
-        return undefined;
-      },
-    });
-    const res = createMockResponse();
-    const next: ExpressNextFunction = () => {};
-
-    middleware(req, res, next);
-    finishResponse(res);
-
-    assertEquals(logs.length, 1);
-    assertEquals(logs[0].properties.referrer, undefined);
-  } finally {
-    await cleanup();
-  }
-});

package/src/mod.ts

@@ -1,411 +0,0 @@
-import { getLogger, type LogLevel } from "@logtape/logtape";
-
-export type { LogLevel } from "@logtape/logtape";
-
-// Use minimal type definitions for Express compatibility across Express 4.x and 5.x
-// These are compatible with both versions and avoid strict type checking issues
-
-/**
- * Minimal Express Request interface for compatibility.
- * @since 1.3.0
- */
-export interface ExpressRequest {
-  method: string;
-  url: string;
-  originalUrl?: string;
-  path?: string;
-  httpVersion: string;
-  ip?: string;
-  socket?: { remoteAddress?: string };
-  get(header: string): string | undefined;
-}
-
-/**
- * Minimal Express Response interface for compatibility.
- * @since 1.3.0
- */
-export interface ExpressResponse {
-  statusCode: number;
-  on(event: string, listener: () => void): void;
-  getHeader(name: string): string | number | string[] | undefined;
-}
-
-/**
- * Express NextFunction type.
- * @since 1.3.0
- */
-export type ExpressNextFunction = (err?: unknown) => void;
-
-/**
- * Express middleware function type.
- * @since 1.3.0
- */
-export type ExpressMiddleware = (
-  req: ExpressRequest,
-  res: ExpressResponse,
-  next: ExpressNextFunction,
-) => void;
-
-/**
- * Predefined log format names compatible with Morgan.
- * @since 1.3.0
- */
-export type PredefinedFormat = "combined" | "common" | "dev" | "short" | "tiny";
-
-/**
- * Custom format function for request logging.
- *
- * @param req The Express request object.
- * @param res The Express response object.
- * @param responseTime The response time in milliseconds.
- * @returns A string message or an object with structured properties.
- * @since 1.3.0
- */
-export type FormatFunction = (
-  req: ExpressRequest,
-  res: ExpressResponse,
-  responseTime: number,
-) => string | Record<string, unknown>;
-
-/**
- * Structured log properties for HTTP requests.
- * @since 1.3.0
- */
-export interface RequestLogProperties {
-  /** HTTP request method */
-  method: string;
-  /** Request URL */
-  url: string;
-  /** HTTP response status code */
-  status: number;
-  /** Response time in milliseconds */
-  responseTime: number;
-  /** Response content-length header value */
-  contentLength: string | undefined;
-  /** Remote client address */
-  remoteAddr: string | undefined;
-  /** User-Agent header value */
-  userAgent: string | undefined;
-  /** Referrer header value */
-  referrer: string | undefined;
-  /** HTTP version (e.g., "1.1") */
-  httpVersion: string;
-}
-
-/**
- * Options for configuring the Express LogTape middleware.
- * @since 1.3.0
- */
-export interface ExpressLogTapeOptions {
-  /**
-   * The LogTape category to use for logging.
-   * @default ["express"]
-   */
-  readonly category?: string | readonly string[];
-
-  /**
-   * The log level to use for request logging.
-   * @default "info"
-   */
-  readonly level?: LogLevel;
-
-  /**
-   * The format for log output.
-   * Can be a predefined format name or a custom format function.
-   *
-   * Predefined formats:
-   * - `"combined"` - Apache Combined Log Format (structured, default)
-   * - `"common"` - Apache Common Log Format (structured, no referrer/userAgent)
-   * - `"dev"` - Concise colored output for development (string)
-   * - `"short"` - Shorter than common (string)
-   * - `"tiny"` - Minimal output (string)
-   *
-   * @default "combined"
-   */
-  readonly format?: PredefinedFormat | FormatFunction;
-
-  /**
-   * Function to determine whether logging should be skipped.
-   * Return `true` to skip logging for a request.
-   *
-   * @example Skip logging for successful requests
-   * ```typescript
-   * app.use(expressLogger({
-   *   skip: (req, res) => res.statusCode < 400,
-   * }));
-   * ```
-   *
-   * @default () => false
-   */
-  readonly skip?: (req: ExpressRequest, res: ExpressResponse) => 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 `immediate` is `true`, response-related properties
-   * (status, responseTime, contentLength) will not be available.
-   *
-   * @default false
-   */
-  readonly immediate?: boolean;
-}
-
-/**
- * Get remote address from request.
- */
-function getRemoteAddr(req: ExpressRequest): string | undefined {
-  return req.ip || req.socket?.remoteAddress;
-}
-
-/**
- * Get content length from response headers.
- */
-function getContentLength(res: ExpressResponse): string | undefined {
-  const contentLength = res.getHeader("content-length");
-  if (contentLength === undefined || contentLength === null) return undefined;
-  return String(contentLength);
-}
-
-/**
- * Get referrer from request headers.
- */
-function getReferrer(req: ExpressRequest): string | undefined {
-  return req.get("referrer") || req.get("referer");
-}
-
-/**
- * Get user agent from request headers.
- */
-function getUserAgent(req: ExpressRequest): string | undefined {
-  return req.get("user-agent");
-}
-
-/**
- * Build structured log properties from request/response.
- */
-function buildProperties(
-  req: ExpressRequest,
-  res: ExpressResponse,
-  responseTime: number,
-): RequestLogProperties {
-  return {
-    method: req.method,
-    url: req.originalUrl || req.url,
-    status: res.statusCode,
-    responseTime,
-    contentLength: getContentLength(res),
-    remoteAddr: getRemoteAddr(req),
-    userAgent: getUserAgent(req),
-    referrer: getReferrer(req),
-    httpVersion: req.httpVersion,
-  };
-}
-
-/**
- * Combined format (Apache Combined Log Format).
- * Returns all structured properties.
- */
-function formatCombined(
-  req: ExpressRequest,
-  res: ExpressResponse,
-  responseTime: number,
-): Record<string, unknown> {
-  return { ...buildProperties(req, res, responseTime) };
-}
-
-/**
- * Common format (Apache Common Log Format).
- * Like combined but without referrer and userAgent.
- */
-function formatCommon(
-  req: ExpressRequest,
-  res: ExpressResponse,
-  responseTime: number,
-): Record<string, unknown> {
-  const props = buildProperties(req, res, responseTime);
-  const { referrer: _referrer, userAgent: _userAgent, ...rest } = props;
-  return rest;
-}
-
-/**
- * Dev format (colored output for development).
- * :method :url :status :response-time ms - :res[content-length]
- */
-function formatDev(
-  req: ExpressRequest,
-  res: ExpressResponse,
-  responseTime: number,
-): string {
-  const contentLength = getContentLength(res) ?? "-";
-  return `${req.method} ${req.originalUrl || req.url} ${res.statusCode} ${
-    responseTime.toFixed(3)
-  } ms - ${contentLength}`;
-}
-
-/**
- * Short format.
- * :remote-addr :method :url HTTP/:http-version :status :res[content-length] - :response-time ms
- */
-function formatShort(
-  req: ExpressRequest,
-  res: ExpressResponse,
-  responseTime: number,
-): string {
-  const remoteAddr = getRemoteAddr(req) ?? "-";
-  const contentLength = getContentLength(res) ?? "-";
-  return `${remoteAddr} ${req.method} ${
-    req.originalUrl || req.url
-  } HTTP/${req.httpVersion} ${res.statusCode} ${contentLength} - ${
-    responseTime.toFixed(3)
-  } ms`;
-}
-
-/**
- * Tiny format (minimal output).
- * :method :url :status :res[content-length] - :response-time ms
- */
-function formatTiny(
-  req: ExpressRequest,
-  res: ExpressResponse,
-  responseTime: number,
-): string {
-  const contentLength = getContentLength(res) ?? "-";
-  return `${req.method} ${
-    req.originalUrl || req.url
-  } ${res.statusCode} ${contentLength} - ${responseTime.toFixed(3)} ms`;
-}
-
-/**
- * Map of predefined format functions.
- */
-const predefinedFormats: Record<PredefinedFormat, FormatFunction> = {
-  combined: formatCombined,
-  common: formatCommon,
-  dev: formatDev,
-  short: formatShort,
-  tiny: formatTiny,
-};
-
-/**
- * Normalize category to array format.
- */
-function normalizeCategory(
-  category: string | readonly string[],
-): readonly string[] {
-  return typeof category === "string" ? [category] : category;
-}
-
-/**
- * Creates Express middleware for HTTP request logging using LogTape.
- *
- * This middleware provides Morgan-compatible request logging with LogTape
- * as the backend, supporting structured logging and customizable formats.
- *
- * @example Basic usage
- * ```typescript
- * import express from "express";
- * import { configure, getConsoleSink } from "@logtape/logtape";
- * import { expressLogger } from "@logtape/express";
- *
- * await configure({
- *   sinks: { console: getConsoleSink() },
- *   loggers: [
- *     { category: ["express"], sinks: ["console"], lowestLevel: "info" }
- *   ],
- * });
- *
- * const app = express();
- * app.use(expressLogger());
- *
- * app.get("/", (req, res) => {
- *   res.json({ hello: "world" });
- * });
- *
- * app.listen(3000);
- * ```
- *
- * @example With custom options
- * ```typescript
- * app.use(expressLogger({
- *   category: ["myapp", "http"],
- *   level: "debug",
- *   format: "dev",
- *   skip: (req, res) => res.statusCode < 400,
- * }));
- * ```
- *
- * @example With custom format function
- * ```typescript
- * app.use(expressLogger({
- *   format: (req, res, responseTime) => ({
- *     method: req.method,
- *     path: req.path,
- *     status: res.statusCode,
- *     duration: responseTime,
- *   }),
- * }));
- * ```
- *
- * @param options Configuration options for the middleware.
- * @returns Express middleware function.
- * @since 1.3.0
- */
-export function expressLogger(
-  options: ExpressLogTapeOptions = {},
-): ExpressMiddleware {
-  const category = normalizeCategory(options.category ?? ["express"]);
-  const logger = getLogger(category);
-  const level = options.level ?? "info";
-  const formatOption = options.format ?? "combined";
-  const skip = options.skip ?? (() => false);
-  const immediate = options.immediate ?? false;
-
-  // Resolve format function
-  const formatFn: FormatFunction = typeof formatOption === "string"
-    ? predefinedFormats[formatOption]
-    : formatOption;
-
-  const logMethod = logger[level].bind(logger);
-
-  return (
-    req: ExpressRequest,
-    res: ExpressResponse,
-    next: ExpressNextFunction,
-  ): void => {
-    const startTime = Date.now();
-
-    // For immediate logging, log when request arrives
-    if (immediate) {
-      if (!skip(req, res)) {
-        const result = formatFn(req, res, 0);
-        if (typeof result === "string") {
-          logMethod(result);
-        } else {
-          logMethod("{method} {url}", result);
-        }
-      }
-      next();
-      return;
-    }
-
-    // Log after response is sent
-    const logRequest = (): void => {
-      if (skip(req, res)) return;
-
-      const responseTime = Date.now() - startTime;
-      const result = formatFn(req, res, responseTime);
-
-      if (typeof result === "string") {
-        logMethod(result);
-      } else {
-        logMethod("{method} {url} {status} - {responseTime} ms", result);
-      }
-    };
-
-    // Listen for response finish event
-    res.on("finish", logRequest);
-
-    next();
-  };
-}

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,
-});