logixlysia 5.2.0 → 6.0.0

package/src/helpers/status.ts

@@ -0,0 +1,58 @@
+import { StatusMap } from 'elysia'
+
+const DIGITS_ONLY = /^\d+$/
+const DELIMITERS = /[_-]+/g
+const CAMEL_BOUNDARY_1 = /([a-z0-9])([A-Z])/g
+const CAMEL_BOUNDARY_2 = /([A-Z])([A-Z][a-z])/g
+const APOSTROPHES = /['’]/g
+const NON_ALPHANUMERIC = /[^a-z0-9\s]+/g
+const WHITESPACE = /\s+/g
+
+const normalizeStatusName = (value: string): string => {
+  // Handles common variants:
+  // - case differences: "not found" vs "Not Found"
+  // - spacing/punctuation: "Not-Found", "not_found"
+  // - camelCase/PascalCase: "InternalServerError"
+  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()
+}
+
+const STATUS_BY_NORMALIZED_NAME = (() => {
+  const map = new Map<string, number>()
+
+  for (const [name, code] of Object.entries(StatusMap)) {
+    map.set(normalizeStatusName(name), code)
+  }
+
+  return map
+})()
+
+export const getStatusCode = (value: unknown): number => {
+  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
+}

package/src/index.ts

@@ -0,0 +1,106 @@
+import { Elysia, type SingletonBase } from 'elysia'
+import { startServer } from './extensions'
+import type { LogixlysiaStore, Options } from './interfaces'
+import { createLogger } from './logger'
+
+export type Logixlysia = Elysia<
+  'Logixlysia',
+  SingletonBase & { store: LogixlysiaStore }
+>
+
+export const logixlysia = (options: Options = {}): Logixlysia => {
+  const didCustomLog = new WeakSet<Request>()
+  const baseLogger = createLogger(options)
+  const logger = {
+    ...baseLogger,
+    debug: (
+      request: Request,
+      message: string,
+      context?: Record<string, unknown>
+    ) => {
+      didCustomLog.add(request)
+      baseLogger.debug(request, message, context)
+    },
+    info: (
+      request: Request,
+      message: string,
+      context?: Record<string, unknown>
+    ) => {
+      didCustomLog.add(request)
+      baseLogger.info(request, message, context)
+    },
+    warn: (
+      request: Request,
+      message: string,
+      context?: Record<string, unknown>
+    ) => {
+      didCustomLog.add(request)
+      baseLogger.warn(request, message, context)
+    },
+    error: (
+      request: Request,
+      message: string,
+      context?: Record<string, unknown>
+    ) => {
+      didCustomLog.add(request)
+      baseLogger.error(request, message, context)
+    }
+  }
+
+  const app = new Elysia({
+    name: 'Logixlysia',
+    detail: {
+      description:
+        'Logixlysia is a plugin for Elysia that provides a logger and pino logger.',
+      tags: ['logging', 'pino']
+    }
+  })
+
+  return (
+    app
+      .state('logger', logger)
+      .state('pino', logger.pino)
+      .state('beforeTime', BigInt(0))
+      .onStart(({ server }) => {
+        if (server) {
+          startServer(server, options)
+        }
+      })
+      .onRequest(({ store }) => {
+        store.beforeTime = process.hrtime.bigint()
+      })
+      .onAfterHandle(({ request, set, store }) => {
+        if (didCustomLog.has(request)) {
+          return
+        }
+
+        const status = typeof set.status === 'number' ? set.status : 200
+        let level: 'INFO' | 'WARNING' | 'ERROR' = 'INFO'
+        if (status >= 500) {
+          level = 'ERROR'
+        } else if (status >= 400) {
+          level = 'WARNING'
+        }
+
+        logger.log(level, request, { status }, store)
+      })
+      .onError(({ request, error, store }) => {
+        logger.handleHttpError(request, error, store)
+      })
+      // Ensure plugin lifecycle hooks (onRequest/onAfterHandle/onError) apply to the parent app.
+      .as('scoped') as unknown as Logixlysia
+  )
+}
+
+export type {
+  Logger,
+  LogixlysiaContext,
+  LogixlysiaStore,
+  LogLevel,
+  Options,
+  Pino,
+  StoreData,
+  Transport
+} from './interfaces'
+
+export default logixlysia

package/src/interfaces.ts

@@ -0,0 +1,117 @@
+import type {
+  Logger as PinoLogger,
+  LoggerOptions as PinoLoggerOptions
+} from 'pino'
+
+export type Pino = PinoLogger<never, boolean>
+
+export type LogLevel = 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR'
+
+export type StoreData = {
+  beforeTime: bigint
+}
+
+export type LogixlysiaStore = {
+  logger: Logger
+  pino: Pino
+  beforeTime?: bigint
+  [key: string]: unknown
+}
+
+export type Transport = {
+  log: (
+    level: LogLevel,
+    message: string,
+    meta?: Record<string, unknown>
+  ) => void | Promise<void>
+}
+
+export type LogRotationConfig = {
+  /**
+   * Max log file size before rotation, e.g. '10m', '5k', or a byte count.
+   */
+  maxSize?: string | number
+  /**
+   * Keep at most N files or keep files for a duration like '7d'.
+   */
+  maxFiles?: number | string
+  /**
+   * Rotate at a fixed interval, e.g. '1d', '12h'.
+   */
+  interval?: string
+  compress?: boolean
+  compression?: 'gzip'
+}
+
+export type Options = {
+  config?: {
+    showStartupMessage?: boolean
+    startupMessageFormat?: 'simple' | 'banner'
+    useColors?: boolean
+    ip?: boolean
+    timestamp?: {
+      translateTime?: string
+    }
+    customLogFormat?: string
+
+    // Outputs
+    transports?: Transport[]
+    useTransportsOnly?: boolean
+    disableInternalLogger?: boolean
+    disableFileLogging?: boolean
+    logFilePath?: string
+    logRotation?: LogRotationConfig
+
+    // Pino
+    pino?: (PinoLoggerOptions & { prettyPrint?: boolean }) | undefined
+  }
+}
+
+export class HttpError extends Error {
+  readonly status: number
+
+  constructor(status: number, message: string) {
+    super(message)
+    this.status = status
+  }
+}
+
+export type Logger = {
+  pino: Pino
+  log: (
+    level: LogLevel,
+    request: RequestInfo,
+    data: Record<string, unknown>,
+    store: StoreData
+  ) => void
+  handleHttpError: (
+    request: RequestInfo,
+    error: unknown,
+    store: StoreData
+  ) => void
+  debug: (
+    request: RequestInfo,
+    message: string,
+    context?: Record<string, unknown>
+  ) => void
+  info: (
+    request: RequestInfo,
+    message: string,
+    context?: Record<string, unknown>
+  ) => void
+  warn: (
+    request: RequestInfo,
+    message: string,
+    context?: Record<string, unknown>
+  ) => void
+  error: (
+    request: RequestInfo,
+    message: string,
+    context?: Record<string, unknown>
+  ) => void
+}
+
+export type LogixlysiaContext = {
+  request: Request
+  store: LogixlysiaStore
+}

package/src/logger/create-logger.ts

@@ -0,0 +1,246 @@
+import chalk from 'chalk'
+import { getStatusCode } from '../helpers/status'
+import type {
+  LogLevel,
+  Options,
+  Pino,
+  RequestInfo,
+  StoreData
+} from '../interfaces'
+
+const pad2 = (value: number): string => String(value).padStart(2, '0')
+const pad3 = (value: number): string => String(value).padStart(3, '0')
+
+const shouldUseColors = (options: Options): boolean => {
+  const config = options.config
+  const enabledByConfig = config?.useColors ?? true
+
+  // Avoid ANSI sequences in non-interactive output (pipes, CI logs, files).
+  const isTty = typeof process !== 'undefined' && process.stdout?.isTTY === true
+  return enabledByConfig && isTty
+}
+
+const formatTimestamp = (date: Date, pattern?: string): string => {
+  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)
+}
+
+const getIp = (request: RequestInfo): string => {
+  const forwarded = request.headers.get('x-forwarded-for')
+  if (forwarded) {
+    return forwarded.split(',')[0]?.trim() ?? ''
+  }
+  return request.headers.get('x-real-ip') ?? ''
+}
+
+const getColoredLevel = (level: LogLevel, useColors: boolean): string => {
+  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)
+}
+
+const getColoredMethod = (method: string, useColors: boolean): string => {
+  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)
+}
+
+const getColoredStatus = (status: string, useColors: boolean): string => {
+  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)
+}
+
+const getColoredDuration = (duration: string, useColors: boolean): string => {
+  if (!useColors) {
+    return duration
+  }
+
+  return chalk.gray(duration)
+}
+
+const getColoredTimestamp = (timestamp: string, useColors: boolean): string => {
+  if (!useColors) {
+    return timestamp
+  }
+
+  return chalk.bgHex('#FFA500').black(timestamp)
+}
+
+const getColoredPathname = (pathname: string, useColors: boolean): string => {
+  if (!useColors) {
+    return pathname
+  }
+
+  return chalk.whiteBright(pathname)
+}
+
+const getContextString = (value: unknown): string => {
+  if (typeof value === 'object' && value !== null) {
+    return JSON.stringify(value)
+  }
+
+  return ''
+}
+
+export const formatLine = ({
+  level,
+  request,
+  data,
+  store,
+  options
+}: {
+  level: LogLevel
+  request: RequestInfo
+  data: Record<string, unknown>
+  store: StoreData
+  options: Options
+}): string => {
+  const config = options.config
+  const useColors = shouldUseColors(options)
+  const format =
+    config?.customLogFormat ??
+    '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip} {context}'
+
+  const now = new Date()
+  const epoch = String(now.getTime())
+  const rawTimestamp = formatTimestamp(now, config?.timestamp?.translateTime)
+  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) / 1_000_000
+
+  const 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 = config?.ip === 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)
+}
+
+export const logWithPino = (
+  logger: Pino,
+  level: LogLevel,
+  data: Record<string, unknown>
+): void => {
+  if (level === 'ERROR') {
+    logger.error(data)
+    return
+  }
+  if (level === 'WARNING') {
+    logger.warn(data)
+    return
+  }
+  if (level === 'DEBUG') {
+    logger.debug(data)
+    return
+  }
+  logger.info(data)
+}

package/src/logger/handle-http-error.ts

@@ -0,0 +1,51 @@
+import type { LogLevel, Options, RequestInfo, StoreData } from '../interfaces'
+import { logToTransports } from '../output'
+import { logToFile } from '../output/file'
+import { parseError } from '../utils/error'
+
+const isErrorWithStatus = (
+  value: unknown
+): value is { status: number; message?: string } =>
+  typeof value === 'object' &&
+  value !== null &&
+  'status' in value &&
+  typeof (value as { status?: unknown }).status === 'number'
+
+export const handleHttpError = (
+  request: RequestInfo,
+  error: unknown,
+  store: StoreData,
+  options: Options
+): void => {
+  const config = options.config
+  const useTransportsOnly = config?.useTransportsOnly === true
+  const disableInternalLogger = config?.disableInternalLogger === true
+  const disableFileLogging = config?.disableFileLogging === true
+
+  const status = isErrorWithStatus(error) ? error.status : 500
+  const message = parseError(error)
+
+  const level: LogLevel = 'ERROR'
+  const data: Record<string, unknown> = { status, message, error }
+
+  logToTransports({ level, request, data, store, options })
+
+  if (!(useTransportsOnly || disableFileLogging)) {
+    const filePath = config?.logFilePath
+    if (filePath) {
+      logToFile({ filePath, level, request, data, store, options }).catch(
+        () => {
+          // Ignore errors
+        }
+      )
+    }
+  }
+
+  if (useTransportsOnly || disableInternalLogger) {
+    return
+  }
+
+  console.error(
+    `${level} ${request.method} ${new URL(request.url).pathname} ${message}`
+  )
+}

package/src/logger/index.ts

@@ -0,0 +1,126 @@
+import pino from 'pino'
+import type {
+  Logger,
+  LogLevel,
+  Options,
+  Pino,
+  RequestInfo,
+  StoreData
+} from '../interfaces'
+import { logToTransports } from '../output'
+import { logToFile } from '../output/file'
+import { formatLine } from './create-logger'
+import { handleHttpError } from './handle-http-error'
+
+export const createLogger = (options: Options = {}): Logger => {
+  const config = options.config
+
+  const pinoConfig = config?.pino
+  const { prettyPrint, ...pinoOptions } = pinoConfig ?? {}
+
+  const shouldPrettyPrint =
+    prettyPrint === true && pinoOptions.transport === undefined
+
+  const transport = shouldPrettyPrint
+    ? pino.transport({
+        target: 'pino-pretty',
+        options: {
+          colorize: process.stdout?.isTTY === true,
+          translateTime: config?.timestamp?.translateTime,
+          messageKey: pinoOptions.messageKey,
+          errorKey: pinoOptions.errorKey
+        }
+      })
+    : pinoOptions.transport
+
+  const pinoLogger: Pino = pino({
+    ...pinoOptions,
+    level: pinoOptions.level ?? 'info',
+    messageKey: pinoOptions.messageKey,
+    errorKey: pinoOptions.errorKey,
+    transport
+  })
+
+  const log = (
+    level: LogLevel,
+    request: RequestInfo,
+    data: Record<string, unknown>,
+    store: StoreData
+  ): void => {
+    logToTransports({ level, request, data, store, options })
+
+    const useTransportsOnly = config?.useTransportsOnly === true
+    const disableInternalLogger = config?.disableInternalLogger === true
+    const disableFileLogging = config?.disableFileLogging === true
+
+    if (!(useTransportsOnly || disableFileLogging)) {
+      const filePath = config?.logFilePath
+      if (filePath) {
+        logToFile({ filePath, level, request, data, store, options }).catch(
+          () => {
+            // Ignore errors
+          }
+        )
+      }
+    }
+
+    if (useTransportsOnly || disableInternalLogger) {
+      return
+    }
+
+    const message = formatLine({ level, request, data, store, options })
+
+    switch (level) {
+      case 'DEBUG': {
+        console.debug(message)
+        break
+      }
+      case 'INFO': {
+        console.info(message)
+        break
+      }
+      case 'WARNING': {
+        console.warn(message)
+        break
+      }
+      case 'ERROR': {
+        console.error(message)
+        break
+      }
+      default: {
+        console.log(message)
+        break
+      }
+    }
+  }
+
+  const logWithContext = (
+    level: LogLevel,
+    request: RequestInfo,
+    message: string,
+    context?: Record<string, unknown>
+  ): void => {
+    const store: StoreData = { beforeTime: process.hrtime.bigint() }
+    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)
+    }
+  }
+}