logixlysia 3.6.0 → 3.6.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [3.6.2](https://github.com/PunGrumpy/logixlysia/compare/v3.6.1...v3.6.2) (2024-09-18)
+
+
+### Bug Fixes
+
+* **logtofile:** store error to log file ([1bb2d07](https://github.com/PunGrumpy/logixlysia/commit/1bb2d07ae0c815742a9eb7c930ac8487ac287b2c)), closes [#63](https://github.com/PunGrumpy/logixlysia/issues/63)
+
+## [3.6.1](https://github.com/PunGrumpy/logixlysia/compare/v3.6.0...v3.6.1) (2024-08-21)
+
+
+### Performance Improvements
+
+* **logger:** improve performance and fix TypeScript errors ([d3ed751](https://github.com/PunGrumpy/logixlysia/commit/d3ed751041443b9bd2ce53350994e1443df40971))
+
 ## [3.6.0](https://github.com/PunGrumpy/logixlysia/compare/v3.5.0...v3.6.0) (2024-07-24)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "3.6.0",
+  "version": "3.6.2",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -15,10 +15,10 @@
   },
   "license": "MIT",
   "scripts": {
-    "lint": "eslint ..",
-    "lint:fix": "eslint .. --fix",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "test": "bun test --timeout 5000 --coverage",
-    "test:ci": "bun test --timeout 5000 --coverage",
+    "test:ci": "bun test --timeout 5000 --coverage --coverage-reporter=lcov",
     "publish": "npm publish",
     "dev": "bun run --watch example/basic.ts",
     "prepare": "husky",
@@ -75,19 +75,20 @@
   },
   "devDependencies": {
     "@elysiajs/eden": "^1.1.1",
-    "@eslint/js": "^9.7.0",
+    "@eslint/js": "^9.8.0",
     "@trunkio/launcher": "^1.3.1",
-    "@typescript-eslint/eslint-plugin": "^7.17.0",
-    "@typescript-eslint/parser": "^7.17.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.1",
+    "@typescript-eslint/parser": "^8.0.1",
     "bun-types": "^1.1.20",
     "commitizen": "^4.3.0",
     "cz-conventional-changelog": "^3.3.0",
-    "eslint": "^9.7.0",
+    "eslint": "9.x",
     "eslint-plugin-simple-import-sort": "^12.1.1",
+    "globals": "^15.9.0",
     "husky": "^9.1.1",
     "lint-staged": "^15.2.7",
     "prettier": "^3.3.3",
-    "typescript-eslint": "^7.17.0"
+    "typescript-eslint": "^8.0.1"
   },
   "peerDependencies": {
     "typescript": "^5.2.2"

package/src/core/buildLogMessage.ts

@@ -0,0 +1,64 @@
+import chalk from 'chalk'
+
+import {
+  LogComponents,
+  LogData,
+  LogLevel,
+  Options,
+  RequestInfo,
+  StoreData
+} from '../types'
+import {
+  durationString,
+  logString,
+  methodString,
+  pathString,
+  statusString
+} from '../utils'
+
+const defaultLogFormat =
+  '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}'
+
+function shouldUseColors(useColors: boolean, options?: Options): boolean {
+  if (options?.config?.useColors !== undefined) {
+    return options.config.useColors && process.env.NO_COLOR === undefined
+  }
+  return useColors && process.env.NO_COLOR === undefined
+}
+
+export function buildLogMessage(
+  level: LogLevel,
+  request: RequestInfo,
+  data: LogData,
+  store: StoreData,
+  options?: Options,
+  useColors: boolean = true
+): string {
+  const actuallyUseColors = shouldUseColors(useColors, options)
+  const now = new Date()
+  const components: LogComponents = {
+    now: actuallyUseColors
+      ? chalk.bgYellow(chalk.black(now.toLocaleString()))
+      : now.toLocaleString(),
+    epoch: Math.floor(now.getTime() / 1000).toString(),
+    level: logString(level, actuallyUseColors),
+    duration: durationString(store.beforeTime, actuallyUseColors),
+    method: methodString(request.method, actuallyUseColors),
+    pathname: pathString(request),
+    status: statusString(data.status || 200, actuallyUseColors),
+    message: data.message || '',
+    ip:
+      options?.config?.ip && request.headers.get('x-forwarded-for')
+        ? `IP: ${request.headers.get('x-forwarded-for')}`
+        : ''
+  }
+
+  const logFormat = options?.config?.customLogFormat || defaultLogFormat
+
+  return logFormat.replace(/{(\w+)}/g, (_, key: string) => {
+    if (key in components) {
+      return components[key as keyof LogComponents] || ''
+    }
+    return ''
+  })
+}

package/src/core/createLogger.ts

@@ -0,0 +1,57 @@
+import { logToTransports } from '../transports'
+import { logToFile } from '../transports'
+import {
+  LogData,
+  Logger,
+  LogLevel,
+  Options,
+  RequestInfo,
+  StoreData
+} from '../types'
+import { buildLogMessage } from './buildLogMessage'
+import { filterLog } from './filter'
+import { handleHttpError } from './handleHttpError'
+
+async function log(
+  level: LogLevel,
+  request: RequestInfo,
+  data: LogData,
+  store: StoreData,
+  options?: Options
+): Promise<void> {
+  if (!filterLog(level, data.status || 200, request.method, options)) return
+
+  const logMessage = buildLogMessage(level, request, data, store, options, true)
+  console.log(logMessage)
+
+  const promises = []
+
+  if (options?.config?.logFilePath) {
+    promises.push(
+      logToFile(
+        options.config.logFilePath,
+        level,
+        request,
+        data,
+        store,
+        options
+      )
+    )
+  }
+
+  if (options?.config?.transports?.length) {
+    promises.push(logToTransports(level, request, data, store, options))
+  }
+
+  await Promise.all(promises)
+}
+
+export function createLogger(options?: Options): Logger {
+  return {
+    log: (level, request, data, store) =>
+      log(level, request, data, store, options),
+    handleHttpError: (request, error, store) =>
+      handleHttpError(request, error, store, options),
+    customLogFormat: options?.config?.customLogFormat
+  }
+}

package/src/core/filter.ts

@@ -0,0 +1,22 @@
+import { LogLevel, Options } from '../types'
+
+const checkFilter = (filterValue: any, value: any) =>
+  Array.isArray(filterValue)
+    ? filterValue.includes(value)
+    : filterValue === value
+
+export function filterLog(
+  logLevel: LogLevel,
+  status: number,
+  method: string,
+  options?: Options
+): boolean {
+  const filter = options?.config?.logFilter
+  if (!filter) return true
+
+  return (
+    (!filter.level || checkFilter(filter.level, logLevel)) &&
+    (!filter.status || checkFilter(filter.status, status)) &&
+    (!filter.method || checkFilter(filter.method, method))
+  )
+}

package/src/core/handleHttpError.ts

@@ -0,0 +1,30 @@
+import { logToFile } from '../transports'
+import { HttpError, Options, RequestInfo, StoreData } from '../types'
+import { buildLogMessage } from './buildLogMessage'
+
+export function handleHttpError(
+  request: RequestInfo,
+  error: HttpError,
+  store: StoreData,
+  options?: Options
+): void {
+  const statusCode = error.status || 500
+  console.error(
+    buildLogMessage('ERROR', request, { status: statusCode }, store, options)
+  )
+
+  const promises = []
+
+  if (options?.config?.logFilePath) {
+    promises.push(
+      logToFile(
+        options.config.logFilePath,
+        'ERROR',
+        request,
+        { status: statusCode },
+        store,
+        options
+      )
+    )
+  }
+}

package/src/index.ts

@@ -1,24 +1,9 @@
-import { Server } from 'bun'
-import Elysia from 'elysia'
+import { Elysia } from 'elysia'
 
-import { createLogger, handleHttpError } from './logger'
-import { HttpError, Options } from './types'
-import startServer from './utils/start'
+import { createLogger } from './core'
+import { startServer } from './plugins'
+import { HttpError, Options, Server } from './types'
 
-/**
- * Creates a logger plugin for ElysiaJS.
- *
- * @export
- * @module logger
- * @category Logger
- * @subcategory Functions
- *
- * @name Logixlysia
- * @description Logixlysia is a logger plugin for ElysiaJS.
- * @param {Options} [options] Configuration options for the logger.
- *
- * @returns {Elysia} The logger plugin for ElysiaJS.
- */
 export default function logixlysia(options?: Options): Elysia {
   const log = createLogger(options)
 
@@ -33,11 +18,14 @@ export default function logixlysia(options?: Options): Elysia {
       log.log('INFO', request, { status: 200 }, store as { beforeTime: bigint })
     })
     .onError({ as: 'global' }, ({ request, error, store }) => {
-      handleHttpError(
+      log.handleHttpError(
         request,
         error as HttpError,
-        store as { beforeTime: bigint },
-        options
+        store as { beforeTime: bigint }
       )
     })
 }
+
+export { createLogger } from './core'
+export { handleHttpError } from './core'
+export { logToTransports } from './transports'

package/src/plugins/index.ts

@@ -0,0 +1 @@
+export { default as startServer } from './startServer'

package/src/{utils/start.ts → plugins/startServer.ts}

@@ -1,25 +1,12 @@
-import { Options, Server } from '~/types'
+import { Options, Server } from '../types'
 
-/**
- * Creates a box text.
- *
- * @param {string} text The text.
- * @param {number} width The box width.
- * @returns {string} The box text.
- */
-function createBoxText(text: string, width: number): string {
+const createBoxText = (text: string, width: number): string => {
   const paddingLength = Math.max(0, (width - text.length) / 2)
   const padding = ' '.repeat(paddingLength)
   return `${padding}${text}${padding}`.padEnd(width)
 }
 
-/**
- * Starts the server string.
- *
- * @param {Server} config The server configuration.
- * @returns {void} The server string.
- */
-function startServer(config: Server, options?: Options): void {
+export default function startServer(config: Server, options?: Options): void {
   const { hostname, port, protocol } = config
   const showBanner = options?.config?.showBanner ?? true
 
@@ -29,19 +16,18 @@ function startServer(config: Server, options?: Options): void {
     const message = `🦊 Elysia is running at ${protocol}://${hostname}:${port}`
     const boxWidth = Math.max(title.length, message.length) + 4
     const border = '─'.repeat(boxWidth)
+    const emptyLine = createBoxText('', boxWidth)
 
     console.log(`
       ┌${border}┐
-      │${createBoxText('', boxWidth)}│
+      │${emptyLine}│
       │${createBoxText(title, boxWidth)}│
-      │${createBoxText('', boxWidth)}│
+      │${emptyLine}│
       │${createBoxText(message, boxWidth)}│
-      │${createBoxText('', boxWidth)}│
+      │${emptyLine}│
       └${border}┘
     `)
   } else {
     console.log(`🦊 Elysia is running at ${protocol}://${hostname}:${port}`)
   }
 }
-
-export default startServer

package/src/transports/console.ts

@@ -0,0 +1,22 @@
+import { buildLogMessage } from '../core/buildLogMessage'
+import { LogData, LogLevel, Options, RequestInfo, StoreData } from '../types'
+
+export async function logToTransports(
+  level: LogLevel,
+  request: RequestInfo,
+  data: LogData,
+  store: StoreData,
+  options?: Options
+): Promise<void> {
+  if (!options?.config?.transports || options.config.transports.length === 0) {
+    return
+  }
+
+  const message = buildLogMessage(level, request, data, store, options, false)
+
+  const promises = options.config.transports.map(transport =>
+    transport.log(level, message, { request, data, store })
+  )
+
+  await Promise.all(promises)
+}

package/src/transports/file.ts

@@ -0,0 +1,29 @@
+import { promises as fs } from 'fs'
+import { dirname } from 'path'
+
+import { buildLogMessage } from '../core/buildLogMessage'
+import { LogData, LogLevel, Options, RequestInfo, StoreData } from '../types'
+
+const dirCache = new Set<string>()
+
+async function ensureDirectoryExists(filePath: string): Promise<void> {
+  const dir = dirname(filePath)
+  if (!dirCache.has(dir)) {
+    await fs.mkdir(dir, { recursive: true })
+    dirCache.add(dir)
+  }
+}
+
+export async function logToFile(
+  filePath: string,
+  level: LogLevel,
+  request: RequestInfo,
+  data: LogData,
+  store: StoreData,
+  options?: Options
+): Promise<void> {
+  await ensureDirectoryExists(filePath)
+  const logMessage =
+    buildLogMessage(level, request, data, store, options, false) + '\n'
+  await fs.appendFile(filePath, logMessage, { flag: 'a' })
+}

package/src/transports/index.ts

@@ -1,22 +1,2 @@
-import { buildLogMessage } from '~/logger/buildLogMessage'
-import { LogData, LogLevel, Options, RequestInfo, StoreData } from '~/types'
-
-export async function logToTransports(
-  level: LogLevel,
-  request: RequestInfo,
-  data: LogData,
-  store: StoreData,
-  options?: Options
-): Promise<void> {
-  if (!options?.config?.transports || options.config.transports.length === 0) {
-    return
-  }
-
-  const message = buildLogMessage(level, request, data, store, options, false)
-
-  const promises = options.config.transports.map(transport =>
-    transport.log(level, message, { request, data, store })
-  )
-
-  await Promise.all(promises)
-}
+export { logToTransports } from './console'
+export { logToFile } from './file'

package/src/{types.ts → types/index.ts}

@@ -1,41 +1,58 @@
-interface RequestInfo {
+export interface RequestInfo {
   headers: { get: (key: string) => string | null }
   method: string
   url: string
 }
 
-interface Server {
+export interface Server {
   hostname?: string
   port?: number
   protocol?: string
 }
 
-interface ColorMap {
+export interface ColorMap {
   [key: string]: (str: string) => string
 }
 
-type LogLevel = 'INFO' | 'WARNING' | 'ERROR' | string
+export type LogLevel = 'INFO' | 'WARNING' | 'ERROR' | string
 
-interface LogData {
+export interface LogData {
   status?: number
   message?: string
 }
 
-interface Logger {
+export interface Logger {
   log(
     level: LogLevel,
     request: RequestInfo,
     data: LogData,
     store: StoreData
   ): void
+  handleHttpError(
+    request: RequestInfo,
+    error: HttpError,
+    store: StoreData
+  ): void
   customLogFormat?: string
 }
 
-interface StoreData {
+export interface LogComponents {
+  now: string
+  epoch: string
+  level: string
+  duration: string
+  method: string
+  pathname: string | undefined
+  status: string
+  message: string
+  ip: string
+}
+
+export interface StoreData {
   beforeTime: bigint
 }
 
-class HttpError extends Error {
+export class HttpError extends Error {
   status: number
 
   constructor(status: number, message: string) {
@@ -44,7 +61,7 @@ class HttpError extends Error {
   }
 }
 
-interface TransportFunction {
+export interface TransportFunction {
   (
     level: LogLevel,
     message: string,
@@ -56,11 +73,11 @@ interface TransportFunction {
   ): Promise<void> | void
 }
 
-interface Transport {
+export interface Transport {
   log: TransportFunction
 }
 
-interface Options {
+export interface Options {
   config?: {
     customLogFormat?: string
     logFilePath?: string
@@ -70,21 +87,8 @@ interface Options {
       status?: number | number[]
     } | null
     ip?: boolean
+    useColors?: boolean
     showBanner?: boolean
     transports?: Transport[]
   }
 }
-
-export {
-  ColorMap,
-  HttpError,
-  LogData,
-  Logger,
-  LogLevel,
-  Options,
-  RequestInfo,
-  Server,
-  StoreData,
-  Transport,
-  TransportFunction
-}

package/src/utils/colorMapping.ts

@@ -1,24 +1,14 @@
 import chalk from 'chalk'
 
-import { ColorMap } from '~/types'
+import { ColorMap } from '../types'
 
-/**
- * The color map for the log levels.
- *
- * @type {ColorMap}
- */
-const LogLevelColorMap: ColorMap = {
+export const LogLevelColorMap: ColorMap = {
   INFO: chalk.bgGreen.black,
   WARNING: chalk.bgYellow.black,
   ERROR: chalk.bgRed.black
 }
 
-/**
- * The color map for the HTTP methods.
- *
- * @type {ColorMap}
- */
-const HttpMethodColorMap: ColorMap = {
+export const HttpMethodColorMap: ColorMap = {
   GET: chalk.green,
   POST: chalk.yellow,
   PUT: chalk.blue,
@@ -27,5 +17,3 @@ const HttpMethodColorMap: ColorMap = {
   HEAD: chalk.cyan,
   OPTIONS: chalk.magenta
 }
-
-export { HttpMethodColorMap, LogLevelColorMap }

package/src/utils/duration.ts

@@ -1,45 +1,27 @@
 import chalk from 'chalk'
 
-/**
- * Converts a time difference into a formatted string with the most appropriate time unit.
- *
- * @param {bigint} beforeTime - The timestamp taken before the request.
- * @param {boolean} useColors - Whether to apply colors to the output.
- * @returns {string} A formatted duration string including the time unit.
- */
-function durationString(beforeTime: bigint, useColors: boolean): string {
-  const currentTime = process.hrtime.bigint()
-  const nanoseconds = Number(currentTime - beforeTime)
+const timeUnits = [
+  { unit: 's', threshold: 1e9, decimalPlaces: 2 },
+  { unit: 'ms', threshold: 1e6, decimalPlaces: 0 },
+  { unit: 'µs', threshold: 1e3, decimalPlaces: 0 },
+  { unit: 'ns', threshold: 1, decimalPlaces: 0 }
+]
 
-  const timeUnits = [
-    { unit: 's', threshold: 1e9, decimalPlaces: 2 },
-    { unit: 'ms', threshold: 1e6, decimalPlaces: 0 },
-    { unit: 'µs', threshold: 1e3, decimalPlaces: 0 }
-  ]
+export default function durationString(
+  beforeTime: bigint,
+  useColors: boolean
+): string {
+  const nanoseconds = Number(process.hrtime.bigint() - beforeTime)
 
   for (const { unit, threshold, decimalPlaces } of timeUnits) {
     if (nanoseconds >= threshold) {
       const value = (nanoseconds / threshold).toFixed(decimalPlaces)
-      return formatTime(value, unit, useColors)
+      const timeStr = `${value}${unit}`.padStart(8).padEnd(16)
+      return useColors ? chalk.gray(timeStr) : timeStr
     }
   }
 
-  return formatTime(nanoseconds.toString(), 'ns', useColors)
-}
-
-/**
- * Formats the time value with the given unit and applies chalk styling.
- *
- * @param {string} value - The time value.
- * @param {string} unit - The time unit.
- * @param {boolean} useColors - Whether to apply colors to the output.
- * @returns {string} Styled time string.
- */
-function formatTime(value: string, unit: string, useColors: boolean): string {
-  const timeStr = `${value}${unit}`
   return useColors
-    ? chalk.gray(timeStr).padStart(8).padEnd(16)
-    : timeStr.padStart(8).padEnd(16)
+    ? chalk.gray('0ns'.padStart(8).padEnd(16))
+    : '0ns'.padStart(8).padEnd(16)
 }
-
-export default durationString

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export { HttpMethodColorMap, LogLevelColorMap } from './colorMapping'
+export { default as durationString } from './duration'
+export { default as logString } from './log'
+export { default as methodString } from './method'
+export { default as pathString } from './path'
+export { default as statusString } from './status'

package/src/utils/log.ts

@@ -1,19 +1,9 @@
-import { LogLevel } from '~/types'
-
+import { LogLevel } from '../types'
 import { LogLevelColorMap } from './colorMapping'
 
-/**
- * Converts the log level to a string.
- *
- * @param {LogLevel} level The log level.
- * @param {boolean} useColors - Whether to apply colors to the output.
- * @returns {string} The log level as a string.
- */
-function logString(level: LogLevel, useColors: boolean): string {
+export default function logString(level: LogLevel, useColors: boolean): string {
   const levelStr = level.toUpperCase()
   return useColors
     ? LogLevelColorMap[levelStr]?.(levelStr.padEnd(7)) || levelStr
     : levelStr.padEnd(7)
 }
-
-export default logString

package/src/utils/method.ts

@@ -1,17 +1,11 @@
 import { HttpMethodColorMap } from './colorMapping'
 
-/**
- * Converts an HTTP request method to a colored string representation.
- *
- * @param {string} method The HTTP request method (e.g., 'GET', 'POST').
- * @param {boolean} useColors - Whether to apply colors to the output.
- * @returns {string} A string representing the method.
- */
-function methodString(method: string, useColors: boolean): string {
+export default function methodString(
+  method: string,
+  useColors: boolean
+): string {
   const colorFunction = HttpMethodColorMap[method]
   return useColors && colorFunction
     ? colorFunction(method.padEnd(7))
     : method.padEnd(7)
 }
-
-export default methodString

package/src/utils/path.ts

@@ -1,17 +1,11 @@
-import { RequestInfo } from '~/types'
+import { RequestInfo } from '../types'
 
-/**
- * Returns the path string.
- *
- * @param {RequestInfo} requestInfo The request info.
- * @returns {string | undefined} The path string.
- */
-function pathString(requestInfo: RequestInfo): string | undefined {
+export default function pathString(
+  requestInfo: RequestInfo
+): string | undefined {
   try {
     return new URL(requestInfo.url).pathname
   } catch {
     return undefined
   }
 }
-
-export default pathString

package/src/utils/status.ts

@@ -1,13 +1,9 @@
 import chalk from 'chalk'
 
-/**
- * Converts the status code to a string.
- *
- * @param {number} status The status code.
- * @param {boolean} useColors - Whether to apply colors to the output.
- * @returns {string} The status code as a string.
- */
-function statusString(status: number, useColors: boolean): string {
+export default function statusString(
+  status: number,
+  useColors: boolean
+): string {
   const color =
     status >= 500
       ? 'red'
@@ -20,5 +16,3 @@ function statusString(status: number, useColors: boolean): string {
             : 'white'
   return useColors ? chalk[color](status.toString()) : status.toString()
 }
-
-export default statusString

package/tests/__mocks__/fs.ts

@@ -0,0 +1,9 @@
+import { mock } from 'bun:test'
+
+export const mockAppend = mock(() => Promise.resolve())
+export const mockMkdir = mock(() => Promise.resolve())
+
+export const promises = {
+  appendFile: mockAppend,
+  mkdir: mockMkdir
+}

package/tests/core/buildLogMessage.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from 'bun:test'
+
+import { buildLogMessage } from '../../src/core/buildLogMessage'
+import { LogData, LogLevel, Options, StoreData } from '../../src/types'
+import { createMockRequest } from '../helpers'
+
+test('buildLogMessage', () => {
+  const level: LogLevel = 'INFO'
+  const request = createMockRequest()
+  const data: LogData = { status: 200, message: 'Test message' }
+  const store: StoreData = { beforeTime: BigInt(0) }
+  const options: Options = {
+    config: {
+      ip: true,
+      customLogFormat: '{level} {message} {ip}'
+    }
+  }
+
+  const message = buildLogMessage(level, request, data, store, options, false)
+  expect(message).toContain('INFO')
+  expect(message).toContain('Test message')
+  expect(message).toContain('127.0.0.1')
+
+  const colorMessage = buildLogMessage(
+    level,
+    request,
+    data,
+    store,
+    options,
+    true
+  )
+
+  expect(colorMessage).toContain('INFO')
+  expect(colorMessage).toContain('Test message')
+  expect(colorMessage).toContain('127.0.0.1')
+
+  const hasAnsiCodes = /\\x1B\[[0-9;]*m/.test(colorMessage)
+  if (hasAnsiCodes) {
+    expect(colorMessage).not.toBe(message)
+  } else {
+    console.warn(
+      'No ANSI color codes detected. Colors might be disabled in this environment.'
+    )
+  }
+})

package/tests/core/filter.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from 'bun:test'
+
+import { filterLog } from '../../src/core/filter'
+import { Options } from '../../src/types'
+
+test('filterLog', () => {
+  const options: Options = {
+    config: {
+      logFilter: {
+        level: 'ERROR',
+        method: 'POST',
+        status: 500
+      }
+    }
+  }
+
+  expect(filterLog('ERROR', 500, 'POST', options)).toBe(true)
+  expect(filterLog('INFO', 200, 'GET', options)).toBe(false)
+  expect(filterLog('WARNING', 400, 'PUT', options)).toBe(false)
+
+  // Test with array filters
+  const arrayOptions: Options = {
+    config: {
+      logFilter: {
+        level: ['ERROR', 'WARNING'],
+        method: ['POST', 'PUT'],
+        status: [500, 400]
+      }
+    }
+  }
+
+  expect(filterLog('ERROR', 500, 'POST', arrayOptions)).toBe(true)
+  expect(filterLog('WARNING', 400, 'PUT', arrayOptions)).toBe(true)
+  expect(filterLog('INFO', 200, 'GET', arrayOptions)).toBe(false)
+})

package/tests/helpers.ts

@@ -0,0 +1,19 @@
+import { mock } from 'bun:test'
+
+import { RequestInfo } from '../src/types'
+
+export function createMockRequest(
+  method: string = 'GET',
+  url: string = 'http://localhost:3000/'
+): RequestInfo {
+  return {
+    headers: {
+      get: (key: string) => (key === 'x-forwarded-for' ? '127.0.0.1' : null)
+    },
+    method,
+    url
+  }
+}
+
+export const mockConsoleLog = mock(() => {})
+export const mockConsoleError = mock(() => {})

package/tests/logixlysia.test.ts

@@ -0,0 +1,8 @@
+import { expect, test } from 'bun:test'
+
+import logixlysia from '../src/index'
+
+test('logixlysia', () => {
+  const elysia = logixlysia()
+  expect(elysia).toBeDefined()
+})

package/tests/transports/logToTransports.test.ts

@@ -0,0 +1,29 @@
+import { expect, mock, test } from 'bun:test'
+
+import { logToTransports } from '../../src/transports'
+import { LogData, LogLevel, Options, StoreData } from '../../src/types'
+import { createMockRequest } from '../helpers'
+
+test('logToTransports', async () => {
+  const level: LogLevel = 'INFO'
+  const request = createMockRequest()
+  const data: LogData = { status: 200, message: 'Test message' }
+  const store: StoreData = { beforeTime: BigInt(0) }
+
+  const mockTransport = {
+    log: mock(() => Promise.resolve())
+  }
+
+  const options: Options = {
+    config: {
+      transports: [mockTransport]
+    }
+  }
+
+  await logToTransports(level, request, data, store, options)
+  expect(mockTransport.log).toHaveBeenCalled()
+
+  // Test with no transports
+  await logToTransports(level, request, data, store, {})
+  expect(mockTransport.log).toHaveBeenCalledTimes(1) // Should not be called again
+})

package/tsconfig.json

@@ -6,9 +6,6 @@
     "allowImportingTsExtensions": true,
     "module": "ESNext",
     "moduleResolution": "Bundler",
-    "paths": {
-      "~/*": ["./src/*"]
-    },
     "resolveJsonModule": true,
     "types": ["bun-types"],
     "downlevelIteration": true,

package/src/logger/buildLogMessage.ts

@@ -1,59 +0,0 @@
-import chalk from 'chalk'
-
-import { LogData, LogLevel, Options, RequestInfo, StoreData } from '~/types'
-import durationString from '~/utils/duration'
-import logString from '~/utils/log'
-import methodString from '~/utils/method'
-import pathString from '~/utils/path'
-import statusString from '~/utils/status'
-
-/**
- * Builds a log message.
- *
- * @param {LogLevel} level The log level.
- * @param {RequestInfo} request The request information.
- * @param {LogData} data The log data.
- * @param {StoreData} store The store data.
- * @param {Options} options The logger options.
- * @param {boolean} useColors Whether to apply colors to the log message.
- * @returns {string} The formatted log message.
- */
-export function buildLogMessage(
-  level: LogLevel,
-  request: RequestInfo,
-  data: LogData,
-  store: StoreData,
-  options?: Options,
-  useColors: boolean = true
-): string {
-  const now = new Date()
-  const nowStr = useColors
-    ? chalk.bgYellow(chalk.black(now.toLocaleString()))
-    : now.toLocaleString()
-  const epochStr = Math.floor(now.getTime() / 1000).toString()
-  const levelStr = logString(level, useColors)
-  const durationStr = durationString(store.beforeTime, useColors)
-  const methodStr = methodString(request.method, useColors)
-  const pathnameStr = pathString(request)
-  const statusStr = statusString(data.status || 200, useColors)
-  const messageStr = data.message || ''
-  const ipStr =
-    options?.config?.ip && request.headers.get('x-forwarded-for')
-      ? `IP: ${request.headers.get('x-forwarded-for')}`
-      : ''
-
-  const logFormat =
-    options?.config?.customLogFormat ||
-    '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}'
-
-  return logFormat
-    .replace('{now}', nowStr)
-    .replace('{epoch}', epochStr)
-    .replace('{level}', levelStr)
-    .replace('{duration}', durationStr)
-    .replace('{method}', methodStr)
-    .replace('{pathname}', pathnameStr || '')
-    .replace('{status}', statusStr)
-    .replace('{message}', messageStr)
-    .replace('{ip}', ipStr || '')
-}

package/src/logger/createLogger.ts

@@ -1,62 +0,0 @@
-import { logToTransports } from '~/transports'
-import {
-  LogData,
-  Logger,
-  LogLevel,
-  Options,
-  RequestInfo,
-  StoreData
-} from '~/types'
-
-import { buildLogMessage } from './buildLogMessage'
-import { filterLog } from './filter'
-import { logToFile } from './logToFile'
-
-/**
- * Logs a message to the console and optionally to a file.
- *
- * @param {LogLevel} level The log level.
- * @param {RequestInfo} request The request information.
- * @param {LogData} data The log data.
- * @param {StoreData} store The store data.
- * @param {Options} options The logger options.
- */
-async function log(
-  level: LogLevel,
-  request: RequestInfo,
-  data: LogData,
-  store: StoreData,
-  options?: Options
-): Promise<void> {
-  if (!filterLog(level, data.status || 200, request.method, options)) return
-
-  const logMessage = buildLogMessage(level, request, data, store, options, true)
-  console.log(logMessage)
-
-  if (options?.config?.logFilePath) {
-    await logToFile(
-      options.config.logFilePath,
-      level,
-      request,
-      data,
-      store,
-      options
-    )
-  }
-
-  await logToTransports(level, request, data, store, options)
-}
-
-/**
- * Creates a logger instance.
- *
- * @param {Options} options The logger options.
- * @returns {Logger} The logger instance.
- */
-export function createLogger(options?: Options): Logger {
-  return {
-    log: async (level, request, data, store) =>
-      log(level, request, data, store, options),
-    customLogFormat: options?.config?.customLogFormat
-  }
-}

package/src/logger/filter.ts

@@ -1,31 +0,0 @@
-import { LogLevel, Options } from '~/types'
-
-/**
- * Filters log messages.
- *
- * @param {LogLevel} logLevel The log level.
- * @param {number} status The status code.
- * @param {string} method The method.
- * @param {Options} options The options.
- * @returns {boolean} `true` if the log message should be logged, otherwise `false`.
- */
-export function filterLog(
-  logLevel: LogLevel,
-  status: number,
-  method: string,
-  options?: Options
-): boolean {
-  const filter = options?.config?.logFilter
-  if (!filter) return true
-
-  const checkFilter = (filterValue: any, value: any) =>
-    Array.isArray(filterValue)
-      ? filterValue.includes(value)
-      : filterValue === value
-
-  return (
-    (!filter.level || checkFilter(filter.level, logLevel)) &&
-    (!filter.status || checkFilter(filter.status, status)) &&
-    (!filter.method || checkFilter(filter.method, method))
-  )
-}

package/src/logger/handleHttpError.ts

@@ -1,28 +0,0 @@
-import { HttpError, Options, RequestInfo, StoreData } from '~/types'
-
-import { buildLogMessage } from './buildLogMessage'
-
-/**
- * Handles an HTTP error and logs it.
- *
- * @param {RequestInfo} request The request information.
- * @param {HttpError} error The HTTP error.
- * @param {StoreData} store The store data.
- * @param {Options} options The logger options.
- */
-export async function handleHttpError(
-  request: RequestInfo,
-  error: HttpError,
-  store: StoreData,
-  options?: Options
-): Promise<void> {
-  const statusCode = error.status || 500
-  const logMessage = buildLogMessage(
-    'ERROR',
-    request,
-    { status: statusCode },
-    store,
-    options
-  )
-  console.error(logMessage)
-}

package/src/logger/logToFile.ts

@@ -1,40 +0,0 @@
-import { promises as fs } from 'fs'
-import { dirname } from 'path'
-
-import { LogData, LogLevel, Options, RequestInfo, StoreData } from '~/types'
-
-import { buildLogMessage } from './buildLogMessage'
-
-/**
- * Ensures that the directory exists. If not, it creates the directory.
- *
- * @param {string} filePath The path to the log file.
- */
-async function ensureDirectoryExists(filePath: string): Promise<void> {
-  const dir = dirname(filePath)
-  await fs.mkdir(dir, { recursive: true })
-}
-
-/**
- * Logs a message to a file.
- *
- * @param {string} filePath The path to the log file.
- * @param {LogLevel} level The log level.
- * @param {RequestInfo} request The request information.
- * @param {LogData} data The log data.
- * @param {StoreData} store The store data.
- * @param {Options} options The logger options.
- */
-export async function logToFile(
-  filePath: string,
-  level: LogLevel,
-  request: RequestInfo,
-  data: LogData,
-  store: StoreData,
-  options?: Options
-): Promise<void> {
-  await ensureDirectoryExists(filePath)
-  const logMessage =
-    buildLogMessage(level, request, data, store, options, false) + '\n'
-  await fs.appendFile(filePath, logMessage)
-}