@logtape/express 1.3.0-dev.1

package/dist/mod.d.ts

@@ -0,0 +1,192 @@
+import { LogLevel, LogLevel as LogLevel$1 } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * Minimal Express Request interface for compatibility.
+ * @since 1.3.0
+ */
+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
+ */
+interface ExpressResponse {
+  statusCode: number;
+  on(event: string, listener: () => void): void;
+  getHeader(name: string): string | number | string[] | undefined;
+}
+/**
+ * Express NextFunction type.
+ * @since 1.3.0
+ */
+type ExpressNextFunction = (err?: unknown) => void;
+/**
+ * Express middleware function type.
+ * @since 1.3.0
+ */
+type ExpressMiddleware = (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction) => void;
+/**
+ * Predefined log format names compatible with Morgan.
+ * @since 1.3.0
+ */
+type PredefinedFormat = "combined" | "common" | "dev" | "short" | "tiny";
+/**
+ * Custom format function for request logging.
+ *
+ * @param 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
+ */
+type FormatFunction = (req: ExpressRequest, res: ExpressResponse, responseTime: number) => string | Record<string, unknown>;
+/**
+ * Structured log properties for HTTP requests.
+ * @since 1.3.0
+ */
+interface RequestLogProperties {
+  /** HTTP request method */
+  method: string;
+  /** Request URL */
+  url: string;
+  /** 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
+ */
+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$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 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;
+}
+/**
+ * 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
+ */
+declare function expressLogger(options?: ExpressLogTapeOptions): ExpressMiddleware;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { ExpressLogTapeOptions, ExpressMiddleware, ExpressNextFunction, ExpressRequest, ExpressResponse, FormatFunction, LogLevel, PredefinedFormat, RequestLogProperties, expressLogger };
+//# 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":";;;;;AAWA;AAeA;AAUA;AAMY,UA/BK,cAAA,CA+BY;EAAA,MAAA,EAAA,MAAA;EAAA,GACtB,EAAA,MAAA;EAAc,WACd,CAAA,EAAA,MAAA;EAAe,IACd,CAAA,EAAA,MAAA;EAAmB,WAAA,EAAA,MAAA;EAOf,EAAA,CAAA,EAAA,MAAA;EAWA,MAAA,CAAA,EAAA;IAAc,aAAA,CAAA,EAAA,MAAA;EAAA,CAAA;EACL,GACd,CAAA,MAAA,EAAA,MAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;AAEa;AAMpB;AAyBA;;AAWmB,UAnFF,eAAA,CAmFE;EAAQ,UAeP,EAAA,MAAA;EAAgB,EAAA,CAAG,KAAA,EAAA,MAAA,EAAA,QAAA,EAAA,GAAA,GAAA,IAAA,CAAA,EAAA,IAAA;EAAc,SAe7B,CAAA,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA,EAAA,GAAA,SAAA;;AAAoC;AAsN5D;;;AAEG,KA/TS,mBAAA,GA+TT,CAAA,GAAA,CAAA,EAAA,OAAA,EAAA,GAAA,IAAA;AAAiB;;;;KAzTR,iBAAA,SACL,qBACA,uBACC;;;;;KAOI,gBAAA;;;;;;;;;;KAWA,cAAA,SACL,qBACA,mDAEO;;;;;UAMG,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;UAyBA,qBAAA;;;;;;;;;;mBAWE;;;;;;;;;;;;;;oBAeC,mBAAmB;;;;;;;;;;;;;;wBAef,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsN7B,aAAA,WACL,wBACR"}

package/dist/mod.js

@@ -0,0 +1,192 @@
+import { getLogger } from "@logtape/logtape";
+
+//#region src/mod.ts
+/**
+* Get remote address from request.
+*/
+function getRemoteAddr(req) {
+	return req.ip || req.socket?.remoteAddress;
+}
+/**
+* Get content length from response headers.
+*/
+function getContentLength(res) {
+	const contentLength = res.getHeader("content-length");
+	if (contentLength === void 0 || contentLength === null) return void 0;
+	return String(contentLength);
+}
+/**
+* Get referrer from request headers.
+*/
+function getReferrer(req) {
+	return req.get("referrer") || req.get("referer");
+}
+/**
+* Get user agent from request headers.
+*/
+function getUserAgent(req) {
+	return req.get("user-agent");
+}
+/**
+* Build structured log properties from request/response.
+*/
+function buildProperties(req, res, responseTime) {
+	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, res, responseTime) {
+	return { ...buildProperties(req, res, responseTime) };
+}
+/**
+* Common format (Apache Common Log Format).
+* Like combined but without referrer and userAgent.
+*/
+function formatCommon(req, res, responseTime) {
+	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, res, responseTime) {
+	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, res, responseTime) {
+	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, res, responseTime) {
+	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 = {
+	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 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
+*/
+function expressLogger(options = {}) {
+	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;
+	const formatFn = typeof formatOption === "string" ? predefinedFormats[formatOption] : formatOption;
+	const logMethod = logger[level].bind(logger);
+	return (req, res, next) => {
+		const startTime = Date.now();
+		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;
+		}
+		const logRequest = () => {
+			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);
+		};
+		res.on("finish", logRequest);
+		next();
+	};
+}
+
+//#endregion
+export { expressLogger };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

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

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@logtape/express",
+  "version": "1.3.0-dev.1",
+  "description": "Express adapter for LogTape logging library",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "express",
+    "middleware",
+    "morgan",
+    "http",
+    "request",
+    "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/express/"
+  },
+  "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": {
+    "express": "^4.0.0 || ^5.0.0",
+    "@logtape/logtape": "^1.3.0"
+  },
+  "devDependencies": {
+    "@alinea/suite": "^0.6.3",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "@types/express": "^5.0.6",
+    "express": "^5.2.1",
+    "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"
+  }
+}