logixlysia 3.6.1 → 3.7.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [3.7.0](https://github.com/PunGrumpy/logixlysia/compare/v3.6.2...v3.7.0) (2024-09-26)
+
+
+### Features
+
+* **optional:** add startup message config ([c7a76db](https://github.com/PunGrumpy/logixlysia/commit/c7a76dbc0f30f4c9c607b52dedc49979e26b67ec))
+
+## [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)
 
 

package/README.md

@@ -21,7 +21,8 @@ const app = new Elysia({
 }).use(
   logixlysia({
     config: {
-      showBanner: true,
+      showStartupMessage: true,
+      startupMessageFormat: 'simple',
       ip: true,
       logFilePath: './logs/example.log',
       customLogFormat:
@@ -45,13 +46,14 @@ app.listen(3000)
 
 ### Options
 
-| Option             | Type      | Description                                                           | Default                                                                   |
-| ------------------ | --------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------- |
-| `showBanner`       | `boolean` | Display the banner on the console                                     | `true`                                                                    |
-| `ip`               | `boolean` | Display the incoming IP address based on the `X-Forwarded-For` header | `false`                                                                   |
-| `customLogMessage` | `string`  | Custom log message to display                                         | `🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}` |
-| `logFilter`        | `object`  | Filter the logs based on the level, method, and status                | `null`                                                                    |
-| `logFilePath`      | `string`  | Path to the log file                                                  | `./logs/elysia.log`                                                       |
+| Option                 | Type                     | Description                                                           | Default                                                                   |
+| ---------------------- | ------------------------ | --------------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| `showStartupMessage`   | `boolean`                | Display the startup message                                           | `true`                                                                    |
+| `startupMessageFormat` | `"banner"` \| `"simple"` | Choose the startup message format                                     | `"banner"`                                                                |
+| `ip`                   | `boolean`                | Display the incoming IP address based on the `X-Forwarded-For` header | `false`                                                                   |
+| `customLogMessage`     | `string`                 | Custom log message to display                                         | `🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}` |
+| `logFilter`            | `object`                 | Filter the logs based on the level, method, and status                | `null`                                                                    |
+| `logFilePath`          | `string`                 | Path to the log file                                                  | `./logs/elysia.log`                                                       |
 
 ### Custom Log Message
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "3.6.1",
+  "version": "3.7.0",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -71,24 +71,21 @@
   ],
   "dependencies": {
     "chalk": "^5.3.0",
-    "elysia": "^1.1.4"
+    "elysia": "^1.1.16"
   },
   "devDependencies": {
-    "@elysiajs/eden": "^1.1.1",
-    "@eslint/js": "^9.8.0",
-    "@trunkio/launcher": "^1.3.1",
-    "@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.x",
+    "@elysiajs/eden": "^1.1.3",
+    "@eslint/js": "^9.11.1",
+    "@trunkio/launcher": "^1.3.2",
+    "@typescript-eslint/eslint-plugin": "^8.7.0",
+    "@typescript-eslint/parser": "^8.7.0",
+    "bun-types": "^1.1.29",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "globals": "^15.9.0",
-    "husky": "^9.1.1",
-    "lint-staged": "^15.2.7",
+    "husky": "^9.1.6",
+    "lint-staged": "^15.2.10",
     "prettier": "^3.3.3",
-    "typescript-eslint": "^8.0.1"
+    "typescript-eslint": "^8.7.0"
   },
   "peerDependencies": {
     "typescript": "^5.2.2"

package/src/{logger → core}/buildLogMessage.ts

@@ -7,27 +7,25 @@ import {
   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'
+} from '../types'
+import {
+  durationString,
+  logString,
+  methodString,
+  pathString,
+  statusString
+} from '../utils'
 
 const defaultLogFormat =
   '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}'
 
-/**
- * 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.
- */
+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,
@@ -36,17 +34,18 @@ export function buildLogMessage(
   options?: Options,
   useColors: boolean = true
 ): string {
+  const actuallyUseColors = shouldUseColors(useColors, options)
   const now = new Date()
   const components: LogComponents = {
-    now: useColors
+    now: actuallyUseColors
       ? chalk.bgYellow(chalk.black(now.toLocaleString()))
       : now.toLocaleString(),
     epoch: Math.floor(now.getTime() / 1000).toString(),
-    level: logString(level, useColors),
-    duration: durationString(store.beforeTime, useColors),
-    method: methodString(request.method, useColors),
+    level: logString(level, actuallyUseColors),
+    duration: durationString(store.beforeTime, actuallyUseColors),
+    method: methodString(request.method, actuallyUseColors),
     pathname: pathString(request),
-    status: statusString(data.status || 200, useColors),
+    status: statusString(data.status || 200, actuallyUseColors),
     message: data.message || '',
     ip:
       options?.config?.ip && request.headers.get('x-forwarded-for')

package/src/{logger → core}/createLogger.ts

@@ -1,7 +1,5 @@
-import { buildLogMessage } from '~/logger/buildLogMessage'
-import { filterLog } from '~/logger/filter'
-import { logToFile } from '~/logger/logToFile'
-import { logToTransports } from '~/transports'
+import { logToTransports } from '../transports'
+import { logToFile } from '../transports'
 import {
   LogData,
   Logger,
@@ -9,17 +7,11 @@ import {
   Options,
   RequestInfo,
   StoreData
-} from '~/types'
+} from '../types'
+import { buildLogMessage } from './buildLogMessage'
+import { filterLog } from './filter'
+import { handleHttpError } from './handleHttpError'
 
-/**
- * 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,
@@ -54,16 +46,12 @@ async function log(
   await Promise.all(promises)
 }
 
-/**
- * Creates a logger instance.
- *
- * @param {Options} options The logger options.
- * @returns {Logger} The logger instance.
- */
 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/{logger → core}/filter.ts

@@ -1,19 +1,10 @@
-import { LogLevel, Options } from '~/types'
+import { LogLevel, Options } from '../types'
 
 const checkFilter = (filterValue: any, value: any) =>
   Array.isArray(filterValue)
     ? filterValue.includes(value)
     : filterValue === value
 
-/**
- * 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,

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/core/index.ts

@@ -0,0 +1,2 @@
+export { createLogger } from './createLogger'
+export { handleHttpError } from './handleHttpError'

package/src/index.ts

@@ -1,31 +1,19 @@
-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)
 
   return new Elysia({
     name: 'Logixlysia'
   })
-    .onStart(ctx => startServer(ctx.server as Server, options))
+    .onStart(ctx => {
+        const showStartupMessage = options?.config?.showStartupMessage ?? true
+        if (showStartupMessage) startServer(ctx.server as Server, options)}
+    )
     .onRequest(ctx => {
       ctx.store = { beforeTime: process.hrtime.bigint() }
     })
@@ -33,14 +21,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 '~/logger'
-export { handleHttpError } from '~/logger'
+export { createLogger, 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,27 +1,14 @@
-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.
- */
 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
+  const showBanner = options?.config?.startupMessageFormat !== 'simple'
 
   if (showBanner) {
     const ELYSIA_VERSION = import.meta.require('elysia/package.json').version
@@ -44,5 +31,3 @@ function startServer(config: Server, options?: Options): void {
     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/{logger/logToFile.ts → transports/file.ts}

@@ -1,16 +1,11 @@
 import { promises as fs } from 'fs'
 import { dirname } from 'path'
 
-import { buildLogMessage } from '~/logger/buildLogMessage'
-import { LogData, LogLevel, Options, RequestInfo, StoreData } from '~/types'
+import { buildLogMessage } from '../core/buildLogMessage'
+import { LogData, LogLevel, Options, RequestInfo, StoreData } from '../types'
 
 const dirCache = new Set<string>()
 
-/**
- * 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)
   if (!dirCache.has(dir)) {
@@ -19,16 +14,6 @@ async function ensureDirectoryExists(filePath: string): Promise<void> {
   }
 }
 
-/**
- * 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,

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,37 +1,42 @@
-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 LogComponents {
+export interface LogComponents {
   now: string
   epoch: string
   level: string
@@ -43,11 +48,11 @@ interface LogComponents {
   ip: string
 }
 
-interface StoreData {
+export interface StoreData {
   beforeTime: bigint
 }
 
-class HttpError extends Error {
+export class HttpError extends Error {
   status: number
 
   constructor(status: number, message: string) {
@@ -56,7 +61,7 @@ class HttpError extends Error {
   }
 }
 
-interface TransportFunction {
+export interface TransportFunction {
   (
     level: LogLevel,
     message: string,
@@ -68,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
@@ -82,22 +87,9 @@ interface Options {
       status?: number | number[]
     } | null
     ip?: boolean
-    showBanner?: boolean
+    useColors?: boolean
+    showStartupMessage?: boolean
+    startupMessageFormat?: 'banner' | 'simple'
     transports?: Transport[]
   }
 }
-
-export {
-  ColorMap,
-  HttpError,
-  LogComponents,
-  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

@@ -7,14 +7,10 @@ const timeUnits = [
   { unit: 'ns', threshold: 1, decimalPlaces: 0 }
 ]
 
-/**
- * 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 {
+export default function durationString(
+  beforeTime: bigint,
+  useColors: boolean
+): string {
   const nanoseconds = Number(process.hrtime.bigint() - beforeTime)
 
   for (const { unit, threshold, decimalPlaces } of timeUnits) {
@@ -29,5 +25,3 @@ function durationString(beforeTime: bigint, useColors: boolean): string {
     ? 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,18 +1,9 @@
-import { LogLevel } from '~/types'
-import { LogLevelColorMap } from '~/utils/colorMapping'
+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.
- */
-const 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 '~/utils/colorMapping'
+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.
- */
-const 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.
- */
-const statusString = (status: number, useColors: boolean): string => {
+export default function statusString(
+  status: number,
+  useColors: boolean
+): string {
   const color =
     status >= 500
       ? 'red'
@@ -20,5 +16,3 @@ const 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/handleHttpError.ts

@@ -1,22 +0,0 @@
-import { buildLogMessage } from '~/logger/buildLogMessage'
-import { HttpError, Options, RequestInfo, StoreData } from '~/types'
-
-/**
- * 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 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)
-  )
-}

package/src/logger/index.ts

@@ -1,2 +0,0 @@
-export { createLogger } from '~/logger/createLogger'
-export { handleHttpError } from '~/logger/handleHttpError'