@pori15/logixlysia 6.0.12 → 6.0.13

package/dist/index.d.ts

@@ -0,0 +1,225 @@
+import { Elysia, SingletonBase } from "elysia";
+import { Logger as PinoLogger, LoggerOptions as PinoLoggerOptions } from "pino";
+interface ProblemDocument {
+	detail?: string;
+	instance?: string;
+	status?: number;
+	title: string;
+	type: string;
+	[key: string]: unknown;
+}
+/**
+* RFC 9457 Problem Details Error
+*
+* Core members:
+* - type: URI reference identifying the problem type (default "about:blank")
+* - title: Short human-readable summary
+* - status: HTTP status code
+* - detail: Human-readable explanation for this occurrence
+* - instance: URI reference identifying this specific occurrence
+* - extensions: Additional properties serialized as-is
+*/
+declare class ProblemError extends Error {
+	readonly status: number;
+	readonly title: string;
+	readonly type: string;
+	readonly detail?: string;
+	readonly instance?: string;
+	readonly extensions?: Record<string, unknown>;
+	constructor(type: string | undefined, title: string, status: number, detail?: string, instance?: string, extensions?: Record<string, unknown>);
+	toJSON(): ProblemDocument;
+}
+interface ProblemConfig {
+	detail?: string;
+	extensions?: Record<string, unknown>;
+	instance?: string;
+	title?: string;
+	type?: string;
+}
+/**
+* 工厂函数：根据 HTTP 状态码快速创建 ProblemError
+*
+* @example
+* throw createProblem(400, { detail: 'Invalid email' })
+* throw createProblem(409, { title: 'Duplicate', detail: 'Email already exists' })
+*/
+declare const createProblem: (status: number, overrides?: ProblemConfig) => ProblemError;
+type HttpErrorFactory = (detail?: string, extensions?: Record<string, unknown>) => ProblemError;
+interface HttpErrorConstructor {
+	BadGateway: HttpErrorFactory;
+	BadRequest: HttpErrorFactory;
+	Conflict: HttpErrorFactory;
+	Forbidden: HttpErrorFactory;
+	GatewayTimeout: HttpErrorFactory;
+	InternalServerError: HttpErrorFactory;
+	MethodNotAllowed: HttpErrorFactory;
+	NotAcceptable: HttpErrorFactory;
+	NotFound: HttpErrorFactory;
+	NotImplemented: HttpErrorFactory;
+	PaymentRequired: HttpErrorFactory;
+	ServiceUnavailable: HttpErrorFactory;
+	Unauthorized: HttpErrorFactory;
+}
+declare const HttpError: HttpErrorConstructor;
+type Code = number | "PROBLEM_ERROR" | "UNKNOWN" | "VALIDATION" | "NOT_FOUND" | "PARSE" | "INTERNAL_SERVER_ERROR" | "INVALID_COOKIE_SIGNATURE" | "INVALID_FILE_TYPE";
+/** Pino Logger 实例类型 */
+type Pino = PinoLogger<never, boolean>;
+/** 日志级别 */
+type LogLevel = "DEBUG" | "INFO" | "WARNING" | "ERROR";
+/** 单次请求携带的计时和路径数据 */
+interface StoreData {
+	/** 请求开始的纳秒时间戳（hrtime） */
+	beforeTime: bigint;
+	/** 缓存的 URL pathname，避免重复解析 */
+	pathname: string;
+}
+/** Elysia store 中挂载的 logixlysia 状态 */
+interface LogixlysiaStore {
+	beforeTime?: bigint;
+	logger: Logger;
+	pathname?: string;
+	pino: Pino;
+	[key: string]: unknown;
+}
+/** 自定义日志传输接口（如 Elasticsearch、Slack 等） */
+interface Transport {
+	/**
+	* 接收一条日志并输出到外部系统
+	*
+	* @param level - 日志级别
+	* @param message - 日志消息
+	* @param meta - 附加元数据（请求信息、耗时等）
+	*/
+	log: (level: LogLevel, message: string, meta?: Record<string, unknown>) => void | Promise<void>;
+}
+/** 日志文件轮转配置 */
+interface LogRotationConfig {
+	/** 轮转后是否压缩旧文件 */
+	compress?: boolean;
+	/** 压缩算法 */
+	compression?: "gzip";
+	/** 固定间隔轮转，如 `'1d'`、`'12h'` */
+	interval?: string;
+	/** 保留的最大文件数量或时长，如 `10` 或 `'7d'` */
+	maxFiles?: number | string;
+	/** 单个日志文件最大体积，如 `'10m'`、`'5k'`，或字节数 */
+	maxSize?: string | number;
+}
+/** 错误码到 HTTP 响应的映射条目 */
+interface ErrorMapping {
+	/** 错误详情描述 */
+	detail?: string;
+	/** HTTP 状态码 */
+	status: number;
+	/** 错误标题 */
+	title: string;
+}
+/**
+* 自定义错误解析回调
+*
+* 返回 `ProblemError` 表示已处理，返回 `void` 交给下一层处理
+*/
+type ErrorResolver = (error: unknown, context: {
+	code: Code;
+	path: string;
+	request: Request;
+}) => ProblemError | void;
+/** 启动消息配置 */
+interface StartupConfig {
+	/** 启动消息格式，默认 `"banner"` */
+	format?: "simple" | "banner";
+	/** 是否显示启动消息，默认 `true` */
+	show?: boolean;
+}
+/** 日志格式配置 */
+interface FormatConfig {
+	/** 是否启用彩色输出，默认 `true`（仅 TTY） */
+	colors?: boolean;
+	/** 是否在日志中显示请求 IP，默认 `false` */
+	showIp?: boolean;
+	/** 自定义日志模板，如 `'🦊 {now} {level} {method} {pathname} {status}'` */
+	template?: string;
+	/** 时间戳格式，如 `'yyyy-mm-dd HH:MM:ss.SSS'` */
+	timestamp?: string;
+}
+/** 文件日志配置 */
+interface FileConfig {
+	/** 日志文件路径（必填） */
+	path: string;
+	/** 日志轮转配置 */
+	rotation?: LogRotationConfig;
+}
+/** 自定义传输配置 */
+interface TransportsConfig {
+	/** 设为 `true` 时只使用 transports，禁用控制台和文件输出 */
+	only?: boolean;
+	/** 传输目标列表 */
+	targets: Transport[];
+}
+/** 错误处理配置 */
+interface ErrorConfig {
+	/** 错误码映射表（Postgres / MySQL / 自定义错误码） */
+	errorMap?: Record<string, ErrorMapping>;
+	/** 自定义错误解析回调 */
+	resolve?: ErrorResolver;
+	/** 自定义错误类型的 Base URL（RFC 9457） */
+	typeBaseUrl?: string;
+	/** 是否在控制台显示完整错误详情（detail、extensions），默认 `false` */
+	verbose?: boolean;
+}
+/** Logixlysia 插件配置 */
+interface Options {
+	/** 错误处理配置 */
+	error?: ErrorConfig;
+	/** 文件日志配置，设为 `false` 禁用文件日志 */
+	file?: false | FileConfig;
+	/** 日志格式配置 */
+	format?: FormatConfig;
+	/** 日志级别过滤，接受单个级别或级别数组 */
+	logLevel?: LogLevel | LogLevel[];
+	/** Pino Logger 原生配置透传 */
+	pino?: PinoLoggerOptions;
+	/** 启动消息配置 */
+	startup?: StartupConfig;
+	/** 自定义传输（数组或带 `only` 选项的对象） */
+	transports?: Transport[] | TransportsConfig;
+}
+/** Logger 实例，可通过 `store.logger` 访问 */
+interface Logger {
+	/** 记录 DEBUG 级别日志 */
+	debug: (request: Request, message: string, context?: Record<string, unknown>) => void;
+	/** 记录 ERROR 级别日志 */
+	error: (request: Request, message: string, context?: Record<string, unknown>) => void;
+	/** 处理 HTTP 错误并输出日志 */
+	handleHttpError: (request: Request, error: ProblemError, store: StoreData, options: Options) => void;
+	/** 记录 INFO 级别日志 */
+	info: (request: Request, message: string, context?: Record<string, unknown>) => void;
+	/** 记录指定级别的日志 */
+	log: (level: LogLevel, request: Request, data: Record<string, unknown>, store: StoreData) => void;
+	/** 底层 Pino Logger 实例 */
+	pino: Pino;
+	/** 记录 WARNING 级别日志 */
+	warn: (request: Request, message: string, context?: Record<string, unknown>) => void;
+}
+/** Logixlysia 请求上下文 */
+interface LogixlysiaContext {
+	request: Request;
+	store: LogixlysiaStore;
+}
+/**
+* 递归提取错误码
+* 沿 cause/error 链递归查找，支持被包装的底层错误（Postgres、MySQL、第三方库等）
+*/
+declare const getErrorCode: (error: unknown) => string | undefined;
+interface NormalizeOptions {
+	errorMap?: Record<string, ErrorMapping>;
+	request?: Request;
+	resolve?: ErrorResolver;
+	typeBaseUrl?: string;
+}
+declare const normalizeToProblem: (error: unknown, code: Code, path: string, options?: NormalizeOptions) => ProblemError;
+type Logixlysia = Elysia<"Logixlysia", SingletonBase & {
+	store: LogixlysiaStore;
+}>;
+declare const logixlysia: (options?: Options) => Logixlysia;
+export { normalizeToProblem, logixlysia, getErrorCode, logixlysia as default, createProblem, TransportsConfig, Transport, StoreData, StartupConfig, ProblemError, ProblemDocument, ProblemConfig, Pino, Options, LogixlysiaStore, LogixlysiaContext, Logixlysia, Logger, LogLevel, HttpErrorConstructor, HttpError, FormatConfig, FileConfig, ErrorResolver, ErrorMapping, ErrorConfig, Code };

package/dist/index.js

@@ -0,0 +1,832 @@
+// src/index.ts
+import { Elysia } from "elysia";
+
+// src/extensions/banner.ts
+import elysiaPkg from "elysia/package.json";
+var centerText = (text, width) => {
+  if (text.length >= width) {
+    return text.slice(0, width);
+  }
+  const left = Math.floor((width - text.length) / 2);
+  const right = width - text.length - left;
+  return `${" ".repeat(left)}${text}${" ".repeat(right)}`;
+};
+var renderBanner = (message) => {
+  const versionLine = `Elysia v${elysiaPkg.version}`;
+  const contentWidth = Math.max(message.length, versionLine.length);
+  const innerWidth = contentWidth + 4;
+  const top = `┌${"─".repeat(innerWidth)}┐`;
+  const bot = `└${"─".repeat(innerWidth)}┘`;
+  const empty = `│${" ".repeat(innerWidth)}│`;
+  const versionRow = `│${centerText(versionLine, innerWidth)}│`;
+  const messageRow = `│  ${message}${" ".repeat(Math.max(0, innerWidth - message.length - 4))}  │`;
+  return [top, empty, versionRow, empty, messageRow, empty, bot].join(`
+`);
+};
+
+// src/extensions/index.ts
+var startServer = (server, options) => {
+  const showStartupMessage = options.startup?.show ?? true;
+  if (!showStartupMessage) {
+    return;
+  }
+  const { port, hostname, protocol } = server;
+  if (port === undefined || !hostname || !protocol) {
+    return;
+  }
+  const url = `${protocol}://${hostname}:${port}`;
+  const message = `\uD83E\uDD8A Elysia is running at ${url}`;
+  const format = options.startup?.format ?? "banner";
+  if (format === "simple") {
+    console.log(message);
+    return;
+  }
+  console.log(renderBanner(message));
+};
+
+// src/logger/index.ts
+import pino from "pino";
+
+// src/logger/create-logger.ts
+import chalk from "chalk";
+
+// src/helpers/status.ts
+import { StatusMap } from "elysia";
+var DIGITS_ONLY = /^\d+$/;
+var DELIMITERS = /[_-]+/g;
+var CAMEL_BOUNDARY_1 = /([a-z0-9])([A-Z])/g;
+var CAMEL_BOUNDARY_2 = /([A-Z])([A-Z][a-z])/g;
+var APOSTROPHES = /['’]/g;
+var NON_ALPHANUMERIC = /[^a-z0-9\s]+/g;
+var WHITESPACE = /\s+/g;
+var normalizeStatusName = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.replace(DELIMITERS, " ").replace(CAMEL_BOUNDARY_1, "$1 $2").replace(CAMEL_BOUNDARY_2, "$1 $2").replace(APOSTROPHES, "").toLowerCase().replace(NON_ALPHANUMERIC, " ").replace(WHITESPACE, " ").trim();
+};
+var STATUS_BY_NORMALIZED_NAME = (() => {
+  const map = new Map;
+  for (const [name, code] of Object.entries(StatusMap)) {
+    map.set(normalizeStatusName(name), code);
+  }
+  return map;
+})();
+var getStatusCode = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (DIGITS_ONLY.test(trimmed)) {
+      return Number(trimmed);
+    }
+    const known = STATUS_BY_NORMALIZED_NAME.get(normalizeStatusName(trimmed));
+    return known ?? 500;
+  }
+  return 500;
+};
+
+// src/utils/format.ts
+var pad2 = (value) => String(value).padStart(2, "0");
+var pad3 = (value) => String(value).padStart(3, "0");
+
+// src/logger/create-logger.ts
+var shouldUseColors = (options) => {
+  const enabledByConfig = options.format?.colors ?? true;
+  const isTty = typeof process !== "undefined" && process.stdout?.isTTY === true;
+  return enabledByConfig && isTty;
+};
+var formatTimestamp = (date, pattern) => {
+  if (!pattern) {
+    return date.toISOString();
+  }
+  const yyyy = String(date.getFullYear());
+  const mm = pad2(date.getMonth() + 1);
+  const dd = pad2(date.getDate());
+  const HH = pad2(date.getHours());
+  const MM = pad2(date.getMinutes());
+  const ss = pad2(date.getSeconds());
+  const SSS = pad3(date.getMilliseconds());
+  return pattern.replaceAll("yyyy", yyyy).replaceAll("mm", mm).replaceAll("dd", dd).replaceAll("HH", HH).replaceAll("MM", MM).replaceAll("ss", ss).replaceAll("SSS", SSS);
+};
+var getIp = (request) => {
+  const forwarded = request.headers.get("x-forwarded-for");
+  if (forwarded) {
+    return forwarded.split(",")[0]?.trim() ?? "";
+  }
+  return request.headers.get("x-real-ip") ?? "";
+};
+var getColoredLevel = (level, useColors) => {
+  if (!useColors) {
+    return level;
+  }
+  if (level === "ERROR") {
+    return chalk.bgRed.black(level);
+  }
+  if (level === "WARNING") {
+    return chalk.bgYellow.black(level);
+  }
+  if (level === "DEBUG") {
+    return chalk.bgBlue.black(level);
+  }
+  return chalk.bgGreen.black(level);
+};
+var getColoredMethod = (method, useColors) => {
+  if (!useColors) {
+    return method;
+  }
+  const upper = method.toUpperCase();
+  if (upper === "GET") {
+    return chalk.green.bold(upper);
+  }
+  if (upper === "POST") {
+    return chalk.blue.bold(upper);
+  }
+  if (upper === "PUT") {
+    return chalk.yellow.bold(upper);
+  }
+  if (upper === "PATCH") {
+    return chalk.yellowBright.bold(upper);
+  }
+  if (upper === "DELETE") {
+    return chalk.red.bold(upper);
+  }
+  if (upper === "OPTIONS") {
+    return chalk.cyan.bold(upper);
+  }
+  if (upper === "HEAD") {
+    return chalk.greenBright.bold(upper);
+  }
+  if (upper === "TRACE") {
+    return chalk.magenta.bold(upper);
+  }
+  if (upper === "CONNECT") {
+    return chalk.cyanBright.bold(upper);
+  }
+  return chalk.white.bold(upper);
+};
+var getColoredStatus = (status, useColors) => {
+  if (!useColors) {
+    return status;
+  }
+  const numeric = Number.parseInt(status, 10);
+  if (!Number.isFinite(numeric)) {
+    return status;
+  }
+  if (numeric >= 500) {
+    return chalk.red(status);
+  }
+  if (numeric >= 400) {
+    return chalk.yellow(status);
+  }
+  if (numeric >= 300) {
+    return chalk.cyan(status);
+  }
+  if (numeric >= 200) {
+    return chalk.green(status);
+  }
+  return chalk.gray(status);
+};
+var getColoredDuration = (duration, useColors) => {
+  if (!useColors) {
+    return duration;
+  }
+  return chalk.gray(duration);
+};
+var getColoredTimestamp = (timestamp, useColors) => {
+  if (!useColors) {
+    return timestamp;
+  }
+  return chalk.bgHex("#FFA500").black(timestamp);
+};
+var getColoredPathname = (pathname, useColors) => {
+  if (!useColors) {
+    return pathname;
+  }
+  return chalk.whiteBright(pathname);
+};
+var getContextString = (value) => {
+  if (typeof value === "object" && value !== null) {
+    return JSON.stringify(value);
+  }
+  return "";
+};
+var formatLine = ({
+  level,
+  request,
+  data,
+  store,
+  options
+}) => {
+  const fmt = options.format;
+  const useColors = shouldUseColors(options);
+  const format = fmt?.template ?? "\uD83E\uDD8A {now} {level} {duration} {method} {pathname} {status} {message} {ip} {context}";
+  const now = new Date;
+  const epoch = String(now.getTime());
+  const rawTimestamp = formatTimestamp(now, fmt?.timestamp);
+  const timestamp = getColoredTimestamp(rawTimestamp, useColors);
+  const message = typeof data.message === "string" ? data.message : "";
+  const durationMs = store.beforeTime === BigInt(0) ? 0 : Number(process.hrtime.bigint() - store.beforeTime) / 1e6;
+  const pathname = store.pathname || new URL(request.url).pathname;
+  const statusValue = data.status;
+  const statusCode = statusValue === null || statusValue === undefined ? 200 : getStatusCode(statusValue);
+  const status = String(statusCode);
+  const ip = fmt?.showIp === true ? getIp(request) : "";
+  const ctxString = getContextString(data.context);
+  const coloredLevel = getColoredLevel(level, useColors);
+  const coloredMethod = getColoredMethod(request.method, useColors);
+  const coloredPathname = getColoredPathname(pathname, useColors);
+  const coloredStatus = getColoredStatus(status, useColors);
+  const coloredDuration = getColoredDuration(`${durationMs.toFixed(2)}ms`, useColors);
+  return format.replaceAll("{now}", timestamp).replaceAll("{epoch}", epoch).replaceAll("{level}", coloredLevel).replaceAll("{duration}", coloredDuration).replaceAll("{method}", coloredMethod).replaceAll("{pathname}", coloredPathname).replaceAll("{path}", coloredPathname).replaceAll("{status}", coloredStatus).replaceAll("{message}", message).replaceAll("{ip}", ip).replaceAll("{context}", ctxString);
+};
+
+// src/output/index.ts
+var logToTransports = (input) => {
+  const { level, request, data, store, transports } = input;
+  if (transports.length === 0) {
+    return;
+  }
+  const message = typeof data.message === "string" ? data.message : "";
+  const meta = {
+    request: {
+      method: request.method,
+      url: request.url
+    },
+    ...data,
+    beforeTime: store.beforeTime
+  };
+  for (const transport of transports) {
+    try {
+      const result = transport.log(level, message, meta);
+      if (result && typeof result.catch === "function") {
+        result.catch(() => {});
+      }
+    } catch {}
+  }
+};
+
+// src/output/file.ts
+import { appendFile } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+
+// src/output/fs.ts
+import { promises as fs } from "node:fs";
+var ensureDir = async (dirPath) => {
+  await fs.mkdir(dirPath, { recursive: true });
+};
+
+// src/output/rotation-manager.ts
+import { promises as fs3 } from "node:fs";
+import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+
+// src/utils/rotation.ts
+import { promises as fs2 } from "node:fs";
+import { basename, dirname } from "node:path";
+var SIZE_REGEX = /^(\d+(?:\.\d+)?)(k|kb|m|mb|g|gb)$/i;
+var INTERVAL_REGEX = /^(\d+)(h|d|w)$/i;
+var ROTATED_REGEX = /\.(\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2})(?:\.gz)?$/;
+var parseSize = (value) => {
+  if (typeof value === "number") {
+    return value;
+  }
+  const trimmed = value.trim();
+  const asNumber = Number(trimmed);
+  if (Number.isFinite(asNumber)) {
+    return asNumber;
+  }
+  const match = trimmed.match(SIZE_REGEX);
+  if (!match) {
+    throw new Error(`Invalid size format: ${value}`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  let base = 1024;
+  if (unit.startsWith("m")) {
+    base = 1024 * 1024;
+  } else if (unit.startsWith("g")) {
+    base = 1024 * 1024 * 1024;
+  }
+  return Math.floor(amount * base);
+};
+var parseInterval = (value) => {
+  const match = value.trim().match(INTERVAL_REGEX);
+  if (!match) {
+    throw new Error(`Invalid interval format: ${value}`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  let ms = 60 * 60 * 1000;
+  if (unit === "d") {
+    ms = 24 * 60 * 60 * 1000;
+  } else if (unit === "w") {
+    ms = 7 * 24 * 60 * 60 * 1000;
+  }
+  return amount * ms;
+};
+var parseRetention = (value) => {
+  if (typeof value === "number") {
+    return { type: "count", value };
+  }
+  return { type: "time", value: parseInterval(value) };
+};
+var shouldRotateBySize = async (filePath, maxSizeBytes) => {
+  try {
+    const stat = await fs2.stat(filePath);
+    return stat.size > maxSizeBytes;
+  } catch {
+    return false;
+  }
+};
+var getRotatedFiles = async (filePath) => {
+  const dir = dirname(filePath);
+  const base = basename(filePath);
+  let entries;
+  try {
+    entries = await fs2.readdir(dir);
+  } catch {
+    return [];
+  }
+  return entries.filter((name) => name.startsWith(`${base}.`) && ROTATED_REGEX.test(name)).map((name) => `${dir}/${name}`);
+};
+
+// src/output/rotation-manager.ts
+var gzipAsync = promisify(gzip);
+var getRotatedFileName = (filePath, date) => {
+  const yyyy = date.getFullYear();
+  const mm = pad2(date.getMonth() + 1);
+  const dd = pad2(date.getDate());
+  const HH = pad2(date.getHours());
+  const MM = pad2(date.getMinutes());
+  const ss = pad2(date.getSeconds());
+  return `${filePath}.${yyyy}-${mm}-${dd}-${HH}-${MM}-${ss}`;
+};
+var rotateFile = async (filePath) => {
+  try {
+    const stat = await fs3.stat(filePath);
+    if (stat.size === 0) {
+      return "";
+    }
+  } catch {
+    return "";
+  }
+  const rotated = getRotatedFileName(filePath, new Date);
+  await fs3.rename(filePath, rotated);
+  return rotated;
+};
+var compressFile = async (filePath) => {
+  const content = await fs3.readFile(filePath);
+  const compressed = await gzipAsync(content);
+  await fs3.writeFile(`${filePath}.gz`, compressed);
+  await fs3.rm(filePath, { force: true });
+};
+var shouldRotate = async (filePath, config) => {
+  if (config.maxSize === undefined) {
+    return false;
+  }
+  const maxSize = parseSize(config.maxSize);
+  return await shouldRotateBySize(filePath, maxSize);
+};
+var cleanupByCount = async (filePath, maxFiles) => {
+  const rotated = await getRotatedFiles(filePath);
+  if (rotated.length <= maxFiles) {
+    return;
+  }
+  const stats = await Promise.all(rotated.map(async (p) => ({ path: p, stat: await fs3.stat(p) })));
+  stats.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+  const toDelete = stats.slice(maxFiles);
+  await Promise.all(toDelete.map(({ path }) => fs3.rm(path, { force: true })));
+};
+var cleanupByTime = async (filePath, maxAgeMs) => {
+  const rotated = await getRotatedFiles(filePath);
+  if (rotated.length === 0) {
+    return;
+  }
+  const now = Date.now();
+  const stats = await Promise.all(rotated.map(async (p) => ({ path: p, stat: await fs3.stat(p) })));
+  const toDelete = stats.filter(({ stat }) => now - stat.mtimeMs > maxAgeMs);
+  await Promise.all(toDelete.map(({ path }) => fs3.rm(path, { force: true })));
+};
+var performRotation = async (filePath, config) => {
+  const rotated = await rotateFile(filePath);
+  if (!rotated) {
+    return;
+  }
+  const shouldCompress = config.compress === true;
+  if (shouldCompress) {
+    const algo = config.compression ?? "gzip";
+    if (algo === "gzip") {
+      await compressFile(rotated);
+    }
+  }
+  if (config.maxFiles !== undefined) {
+    const retention = parseRetention(config.maxFiles);
+    if (retention.type === "count") {
+      await cleanupByCount(filePath, retention.value);
+    } else {
+      await cleanupByTime(filePath, retention.value);
+    }
+  }
+};
+
+// src/output/file.ts
+var logToFile = async (input) => {
+  const { filePath, level, request, data, store, options } = input;
+  const message = typeof data.message === "string" ? data.message : "";
+  const durationMs = store.beforeTime === BigInt(0) ? 0 : Number(process.hrtime.bigint() - store.beforeTime) / 1e6;
+  const pathname = store.pathname || new URL(request.url).pathname;
+  const line = `${level} ${durationMs.toFixed(2)}ms ${request.method} ${pathname} ${message}
+`;
+  await ensureDir(dirname2(filePath));
+  await appendFile(filePath, line, { encoding: "utf-8" });
+  const rotation = options.file && options.file !== false ? options.file.rotation : undefined;
+  if (!rotation) {
+    return;
+  }
+  const should = await shouldRotate(filePath, rotation);
+  if (should) {
+    await performRotation(filePath, rotation);
+  }
+};
+
+// src/logger/handle-http-error.ts
+var normalizeTransports = (transports) => {
+  if (!transports)
+    return { targets: [], only: false };
+  if (Array.isArray(transports))
+    return { targets: transports, only: false };
+  return { targets: transports.targets, only: transports.only === true };
+};
+var outputPipeline = (level, request, data, store, options, consoleMessage) => {
+  const { targets, only: transportsOnly } = normalizeTransports(options.transports);
+  logToTransports({ level, request, data, store, transports: targets });
+  const fileConfig = options.file;
+  const hasFile = fileConfig !== false && fileConfig !== undefined;
+  if (!transportsOnly && hasFile) {
+    logToFile({
+      filePath: fileConfig.path,
+      level,
+      request,
+      data,
+      store,
+      options
+    }).catch((e) => {
+      console.error(e);
+    });
+  }
+  if (transportsOnly)
+    return;
+  if (consoleMessage) {
+    switch (level) {
+      case "DEBUG":
+        console.debug(consoleMessage);
+        break;
+      case "INFO":
+        console.info(consoleMessage);
+        break;
+      case "WARNING":
+        console.warn(consoleMessage);
+        break;
+      case "ERROR":
+        console.error(consoleMessage);
+        break;
+      default:
+        console.log(consoleMessage);
+    }
+  }
+};
+var handleHttpError = (request, problem, store, options) => {
+  const level = problem.status >= 500 ? "ERROR" : "WARNING";
+  const rfcData = problem.toJSON();
+  const data = {
+    status: problem.status,
+    message: problem.detail || problem.title,
+    ...rfcData
+  };
+  const { only: transportsOnly } = normalizeTransports(options.transports);
+  let consoleMessage = "";
+  if (!transportsOnly) {
+    let timestamp = "";
+    if (options.format?.timestamp) {
+      timestamp = `[${new Date().toISOString()}] `;
+    }
+    const pathname = store.pathname || new URL(request.url).pathname;
+    consoleMessage = `${timestamp}${level} ${request.method} ${pathname} ${problem.status} - ${problem.title}`;
+    if (options.error?.verbose) {
+      const parts = [consoleMessage];
+      if (rfcData.detail)
+        parts.push(`  Detail: ${rfcData.detail}`);
+      if (rfcData.instance)
+        parts.push(`  Instance: ${rfcData.instance}`);
+      if (rfcData.type && rfcData.type !== "about:blank")
+        parts.push(`  Type: ${rfcData.type}`);
+      const extensions = Object.entries(rfcData).filter(([key]) => !["type", "title", "status", "detail", "instance"].includes(key));
+      if (extensions.length > 0) {
+        parts.push("  Extensions:");
+        for (const [key, value] of extensions) {
+          parts.push(`    ${key}: ${JSON.stringify(value)}`);
+        }
+      }
+      consoleMessage = parts.join(`
+`);
+    }
+  }
+  outputPipeline(level, request, data, store, options, consoleMessage || undefined);
+};
+
+// src/logger/index.ts
+var shouldLog = (level, logLevel) => {
+  if (logLevel === undefined)
+    return true;
+  const levels = Array.isArray(logLevel) ? logLevel : [logLevel];
+  if (levels.length === 0)
+    return true;
+  return levels.includes(level);
+};
+var createLogger = (options = {}) => {
+  const pinoOptions = options.pino ?? {};
+  const isPrettyPrint = pinoOptions.transport === undefined;
+  const pinoLogger = isPrettyPrint ? pino({
+    ...pinoOptions,
+    level: pinoOptions.level ?? "info",
+    messageKey: pinoOptions.messageKey,
+    errorKey: pinoOptions.errorKey,
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: process.stdout?.isTTY === true,
+        translateTime: options.format?.timestamp,
+        messageKey: pinoOptions.messageKey,
+        errorKey: pinoOptions.errorKey
+      }
+    }
+  }) : pino({
+    ...pinoOptions,
+    level: pinoOptions.level ?? "info",
+    messageKey: pinoOptions.messageKey,
+    errorKey: pinoOptions.errorKey
+  });
+  const log = (level, request, data, store) => {
+    if (!shouldLog(level, options.logLevel)) {
+      return;
+    }
+    const consoleMessage = formatLine({ level, request, data, store, options });
+    outputPipeline(level, request, data, store, options, consoleMessage);
+  };
+  const logWithContext = (level, request, message, context) => {
+    const store = {
+      beforeTime: process.hrtime.bigint(),
+      pathname: new URL(request.url).pathname
+    };
+    log(level, request, { message, context }, store);
+  };
+  return {
+    pino: pinoLogger,
+    log,
+    handleHttpError: (request, error, store) => {
+      handleHttpError(request, error, store, options);
+    },
+    debug: (request, message, context) => {
+      logWithContext("DEBUG", request, message, context);
+    },
+    info: (request, message, context) => {
+      logWithContext("INFO", request, message, context);
+    },
+    warn: (request, message, context) => {
+      logWithContext("WARNING", request, message, context);
+    },
+    error: (request, message, context) => {
+      logWithContext("ERROR", request, message, context);
+    }
+  };
+};
+
+// src/error/errors.ts
+class ProblemError extends Error {
+  status;
+  title;
+  type;
+  detail;
+  instance;
+  extensions;
+  constructor(type = "about:blank", title, status, detail, instance, extensions) {
+    super(detail || title);
+    Object.setPrototypeOf(this, ProblemError.prototype);
+    this.status = status;
+    this.title = title;
+    this.type = type;
+    this.detail = detail;
+    this.instance = instance;
+    this.extensions = extensions;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      title: this.title,
+      status: this.status,
+      ...this.detail ? { detail: this.detail } : {},
+      ...this.instance ? { instance: this.instance } : {},
+      ...this.extensions
+    };
+  }
+}
+var DEFAULT_TITLES = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  409: "Conflict",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+var createProblem = (status, overrides) => {
+  const title = overrides?.title ?? DEFAULT_TITLES[status] ?? "Unknown Error";
+  return new ProblemError(overrides?.type ?? `https://httpstatuses.com/${status}`, title, status, overrides?.detail, overrides?.instance, overrides?.extensions);
+};
+var factory = (status) => (detail, extensions) => createProblem(status, { detail, extensions });
+var HttpError = {
+  BadRequest: factory(400),
+  Unauthorized: factory(401),
+  PaymentRequired: factory(402),
+  Forbidden: factory(403),
+  NotFound: factory(404),
+  MethodNotAllowed: factory(405),
+  NotAcceptable: factory(406),
+  Conflict: factory(409),
+  InternalServerError: factory(500),
+  NotImplemented: factory(501),
+  BadGateway: factory(502),
+  ServiceUnavailable: factory(503),
+  GatewayTimeout: factory(504)
+};
+
+// src/utils/get-error-code.ts
+var getErrorCode = (error) => {
+  if (typeof error !== "object" || error === null)
+    return;
+  const obj = error;
+  if ("code" in obj && typeof obj.code === "string") {
+    return obj.code;
+  }
+  if ("cause" in obj) {
+    return getErrorCode(obj.cause);
+  }
+  if ("error" in obj) {
+    return getErrorCode(obj.error);
+  }
+  return;
+};
+
+// src/utils/handle-error.ts
+var CODE_MAP = {
+  VALIDATION: { status: 400, title: "Validation Failed" },
+  NOT_FOUND: { status: 404, title: "Resource Not Found" },
+  PARSE: {
+    status: 400,
+    title: "Invalid Payload",
+    detail: "The request body could not be parsed as valid JSON."
+  },
+  INVALID_COOKIE_SIGNATURE: { status: 401, title: "Invalid Credentials" },
+  INTERNAL_SERVER_ERROR: { status: 500, title: "Internal Server Error" }
+};
+var normalizeToProblem = (error, code, path, options = {}) => {
+  const { typeBaseUrl = "about:blank", errorMap, resolve, request } = options;
+  const buildType = (suffix) => typeBaseUrl === "about:blank" ? typeBaseUrl : `${typeBaseUrl}/${suffix}`;
+  if (error instanceof ProblemError) {
+    if (error.instance)
+      return error;
+    return new ProblemError(error.type, error.title, error.status, error.detail, path, error.extensions);
+  }
+  if (resolve && request) {
+    const resolved = resolve(error, { code, path, request });
+    if (resolved instanceof ProblemError)
+      return resolved;
+  }
+  if (code === "VALIDATION") {
+    const validationError = error;
+    return createProblem(400, {
+      title: "Validation Failed",
+      detail: "One or more fields failed validation",
+      type: buildType("validation"),
+      instance: path,
+      extensions: {
+        errors: validationError.all?.map((err) => ({
+          field: err.path.replace(/^\//, ""),
+          message: err.summary || err.message
+        })) ?? []
+      }
+    });
+  }
+  if (errorMap) {
+    const errorCode = getErrorCode(error);
+    if (errorCode && errorCode in errorMap) {
+      const mapping = errorMap[errorCode];
+      return createProblem(mapping.status, {
+        title: mapping.title,
+        detail: mapping.detail,
+        type: buildType(errorCode),
+        instance: path
+      });
+    }
+  }
+  const builtIn = CODE_MAP[code];
+  if (builtIn) {
+    const detail2 = builtIn.detail ?? (error instanceof Error ? error.message : String(error));
+    return createProblem(builtIn.status, {
+      title: builtIn.title,
+      detail: detail2,
+      type: buildType(String(code)),
+      instance: path
+    });
+  }
+  const detail = error instanceof Error ? error.message : String(error);
+  const fallbackStatus = typeof error?.status === "number" ? error.status : 500;
+  const fallbackConfig = {
+    detail,
+    type: buildType("unknown"),
+    instance: path
+  };
+  if (fallbackStatus !== 500) {
+    fallbackConfig.title = undefined;
+  }
+  return createProblem(fallbackStatus, fallbackConfig);
+};
+
+// src/index.ts
+var logixlysia = (options = {}) => {
+  const didCustomLog = new WeakSet;
+  const baseLogger = createLogger(options);
+  const logger = {
+    ...baseLogger,
+    debug: (request, message, context) => {
+      didCustomLog.add(request);
+      baseLogger.debug(request, message, context);
+    },
+    info: (request, message, context) => {
+      didCustomLog.add(request);
+      baseLogger.info(request, message, context);
+    },
+    warn: (request, message, context) => {
+      didCustomLog.add(request);
+      baseLogger.warn(request, message, context);
+    },
+    error: (request, message, context) => {
+      didCustomLog.add(request);
+      baseLogger.error(request, message, context);
+    }
+  };
+  const app = new Elysia({
+    name: "Logixlysia"
+  });
+  const errorConfig = options.error;
+  return app.state("logger", logger).state("pino", logger.pino).state("beforeTime", BigInt(0)).state("pathname", "").onStart(({ server }) => {
+    if (server) {
+      startServer(server, options);
+    }
+  }).onRequest(({ request, store }) => {
+    store.beforeTime = process.hrtime.bigint();
+    store.pathname = new URL(request.url).pathname;
+  }).onAfterHandle(({ request, set, store }) => {
+    if (didCustomLog.has(request)) {
+      return;
+    }
+    const status = typeof set.status === "number" ? set.status : 200;
+    let level = "INFO";
+    if (status >= 500) {
+      level = "ERROR";
+    } else if (status >= 400) {
+      level = "WARNING";
+    }
+    logger.log(level, request, { status }, store);
+  }).onError(({ request, error, code, path, store, set }) => {
+    const problem = normalizeToProblem(error, code, path, {
+      typeBaseUrl: errorConfig?.typeBaseUrl,
+      errorMap: errorConfig?.errorMap,
+      resolve: errorConfig?.resolve,
+      request
+    });
+    logger.handleHttpError(request, problem, store, options);
+    set.status = problem.status;
+    set.headers["content-type"] = "application/problem+json";
+    return problem.toJSON();
+  }).as("scoped");
+};
+var src_default = logixlysia;
+export {
+  normalizeToProblem,
+  logixlysia,
+  getErrorCode,
+  src_default as default,
+  createProblem,
+  ProblemError,
+  HttpError
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pori15/logixlysia",
-  "version": "6.0.12",
+  "version": "6.0.13",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "main": "dist/index.js",