logixlysia 3.3.0 → 3.3.1

package/.gitmodules

@@ -0,0 +1,3 @@
+[submodule ".trunk/configs"]
+	path = .trunk/configs
+	url = git@github.com:PunGrumpy/.trunk.git

package/.trunk/trunk.yaml

@@ -0,0 +1,26 @@
+---
+version: 0.1
+cli:
+  version: 1.22.1
+plugins:
+  sources:
+    - id: trunk
+      ref: v1.5.0
+      uri: https://github.com/trunk-io/plugins
+runtimes:
+  enabled:
+    - node@22.2.0
+lint:
+  enabled:
+    - oxipng@9.1.1
+    - shfmt@3.6.0
+    - eslint@9.3.0
+    - actionlint@1.7.0
+    - git-diff-check
+    - markdownlint@0.40.0
+    - prettier@3.2.5
+    - trufflehog@3.76.3
+    - yamllint@1.35.1
+actions:
+  enabled:
+    - npm-check

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [3.3.1](https://github.com/PunGrumpy/logixlysia/compare/v3.3.0...v3.3.1) (2024-06-01)
+
+
+### Bug Fixes
+
+* **deps:** move `ESLint` and related packages to dev dependencies ([98de50c](https://github.com/PunGrumpy/logixlysia/commit/98de50c6c3bffc5939963ebd04563204c7c70793)), closes [#46](https://github.com/PunGrumpy/logixlysia/issues/46)
+
 ## [3.3.0](https://github.com/PunGrumpy/logixlysia/compare/v3.2.0...v3.3.0) (2024-05-22)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -23,7 +23,9 @@
     "dev": "bun run --watch example/basic.ts",
     "prepare": "husky",
     "lint:staged": "lint-staged",
-    "prettier": "prettier --write ."
+    "prettier": "prettier --write --config .trunk/configs/.prettierrc.yaml .",
+    "trunk:check": "trunk check",
+    "trunk:fmt": "trunk fmt"
   },
   "os": [
     "darwin",
@@ -68,23 +70,24 @@
     "middleware"
   ],
   "dependencies": {
-    "@eslint/js": "^9.3.0",
-    "@typescript-eslint/eslint-plugin": "^7.10.0",
-    "@typescript-eslint/parser": "^7.10.0",
     "chalk": "^5.3.0",
-    "elysia": "^1.0.21",
-    "eslint": "9.x",
-    "eslint-plugin-simple-import-sort": "^12.1.0",
-    "typescript-eslint": "^7.10.0"
+    "elysia": "^1.0.21"
   },
   "devDependencies": {
     "@elysiajs/eden": "^1.0.13",
+    "@eslint/js": "^9.3.0",
+    "@trunkio/launcher": "^1.3.1",
+    "@typescript-eslint/eslint-plugin": "^7.10.0",
+    "@typescript-eslint/parser": "^7.10.0",
     "bun-types": "^1.1.9",
     "commitizen": "^4.3.0",
     "cz-conventional-changelog": "^3.3.0",
+    "eslint": "9.x",
+    "eslint-plugin-simple-import-sort": "^12.1.0",
     "husky": "^9.0.11",
     "lint-staged": "^15.2.4",
-    "prettier": "^3.2.5"
+    "prettier": "^3.2.5",
+    "typescript-eslint": "^7.10.0"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/index.ts

@@ -1,13 +1,13 @@
 import { Server } from 'bun'
 import Elysia from 'elysia'
 
-import { createLogger } from './logger'
-import { handleHttpError } from './logger/handle'
+import { createLogger } from './logger/createLogger'
+import { handleHttpError } from './logger/handleHttpError'
 import { HttpError, Options } from './types'
 import startServer from './utils/start'
 
 /**
- * Creates a logger.
+ * Creates a logger plugin for ElysiaJS.
  *
  * @export
  * @module logger
@@ -19,7 +19,9 @@ import startServer from './utils/start'
  * @author PunGrumpy
  * @license MIT
  *
- * @returns {Elysia} The logger.
+ * @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)

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

@@ -1,56 +1,23 @@
 import chalk from 'chalk'
 
-import {
-  LogData,
-  Logger,
-  LogLevel,
-  Options,
-  RequestInfo,
-  StoreData
-} from '~/types'
+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'
 
-import { filterLog } from './filter'
-
-/**
- * Logs a message.
- *
- * @param {LogLevel} level The log level.
- * @param {RequestInfo} request The request.
- * @param {LogData} data The log data.
- * @param {StoreData} store The store data.
- * @param {Options} options The options.
- */
-function log(
-  level: LogLevel,
-  request: RequestInfo,
-  data: LogData,
-  store: StoreData,
-  options?: Options
-): void {
-  if (!filterLog(level, data.status || 200, request.method, options)) {
-    return
-  }
-
-  const logMessage = buildLogMessage(level, request, data, store, options)
-  console.log(logMessage)
-}
-
 /**
  * Builds a log message.
  *
  * @param {LogLevel} level The log level.
- * @param {RequestInfo} request The request.
+ * @param {RequestInfo} request The request information.
  * @param {LogData} data The log data.
  * @param {StoreData} store The store data.
- * @param {Options} options The options.
- * @returns {string} The log message.
+ * @param {Options} options The logger options.
+ * @returns {string} The formatted log message.
  */
-function buildLogMessage(
+export function buildLogMessage(
   level: LogLevel,
   request: RequestInfo,
   data: LogData,
@@ -84,19 +51,3 @@ function buildLogMessage(
 
   return logMessage
 }
-
-/**
- * Creates a logger.
- *
- * @param {Options} options The options.
- * @returns {Logger} The logger.
- */
-function createLogger(options?: Options): Logger {
-  return {
-    log: (level, request, data, store) =>
-      log(level, request, data, store, options),
-    customLogFormat: options?.config?.customLogFormat
-  }
-}
-
-export { buildLogMessage, createLogger, log }

package/src/logger/createLogger.ts

@@ -0,0 +1,49 @@
+import {
+  LogData,
+  Logger,
+  LogLevel,
+  Options,
+  RequestInfo,
+  StoreData
+} from '~/types'
+
+import { buildLogMessage } from './buildLogMessage'
+import { filterLog } from './filter'
+
+/**
+ * Logs a message to the console.
+ *
+ * @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)
+  console.log(logMessage)
+}
+
+/**
+ * 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/{handle.ts → handleHttpError.ts}

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

package/src/utils/duration.ts

@@ -9,17 +9,18 @@ import chalk from 'chalk'
  * @returns {string} A formatted duration string including the time unit.
  */
 function durationString(beforeTime: bigint): string {
-  const nanoseconds = Number(process.hrtime.bigint() - beforeTime)
+  const currentTime = process.hrtime.bigint()
+  const nanoseconds = Number(currentTime - beforeTime)
 
   const timeUnits = [
-    { unit: 's', threshold: 1e9 },
-    { unit: 'ms', threshold: 1e6 },
-    { unit: 'µs', threshold: 1e3 }
+    { unit: 's', threshold: 1e9, decimalPlaces: 2 },
+    { unit: 'ms', threshold: 1e6, decimalPlaces: 0 },
+    { unit: 'µs', threshold: 1e3, decimalPlaces: 0 }
   ]
 
-  for (const { unit, threshold } of timeUnits) {
+  for (const { unit, threshold, decimalPlaces } of timeUnits) {
     if (nanoseconds >= threshold) {
-      const value = (nanoseconds / threshold).toFixed(threshold === 1e9 ? 2 : 0)
+      const value = (nanoseconds / threshold).toFixed(decimalPlaces)
       return formatTime(value, unit)
     }
   }

package/src/utils/path.ts

@@ -11,7 +11,7 @@ import { RequestInfo } from '~/types'
 function pathString(requestInfo: RequestInfo): string | undefined {
   try {
     return new URL(requestInfo.url).pathname
-  } catch (error) {
+  } catch {
     return undefined
   }
 }

package/src/utils/start.ts

@@ -9,9 +9,9 @@ import { Server } from '~/types'
  * @returns {string} The box text.
  */
 function createBoxText(text: string, width: number): string {
-  const paddingLength = Math.max(0, (width - text.length + 1) / 2)
+  const paddingLength = Math.max(0, (width - text.length) / 2)
   const padding = ' '.repeat(paddingLength)
-  return `${padding}${text}${padding}`.slice(0, width)
+  return `${padding}${text}${padding}`.padEnd(width)
 }
 
 /**
@@ -26,8 +26,7 @@ function startServer(config: Server): void {
   const ELYSIA_VERSION = import.meta.require('elysia/package.json').version
   const title = `Elysia v${ELYSIA_VERSION}`
   const message = `🦊 Elysia is running at ${protocol}://${hostname}:${port}`
-  const messageWidth = message.length
-  const boxWidth = Math.max(title.length, messageWidth) + 4
+  const boxWidth = Math.max(title.length, message.length) + 4
   const border = '─'.repeat(boxWidth)
 
   console.log(`

package/.gitguardian.yml

@@ -1,16 +0,0 @@
-# Required, otherwise ggshield considers the file to use the deprecated v1 format
-version: 2
-
-# Set to true if the desired exit code for the CLI is always 0, otherwise the
-# exit code will be 1 if incidents are found.
-exit-zero: false
-
-verbose: false
-
-instance: https://dashboard.gitguardian.com
-
-# Maximum commits to scan in a hook.
-max-commits-for-hook: 50
-
-# Accept self-signed certificates for the API.
-allow-self-signed: false

package/.prettierignore

@@ -1,2 +0,0 @@
-CHANGELOG.md
-node_modules/

package/.prettierrc

@@ -1,9 +0,0 @@
-{
-  "arrowParens": "avoid",
-  "singleQuote": true,
-  "bracketSpacing": true,
-  "endOfLine": "lf",
-  "semi": false,
-  "tabWidth": 2,
-  "trailingComma": "none"
-}

package/eslint.config.js

@@ -1,25 +0,0 @@
-import pluginJs from '@eslint/js'
-import eslintPlugin from '@typescript-eslint/eslint-plugin'
-import eslintPluginSimpleImportSort from 'eslint-plugin-simple-import-sort'
-import globals from 'globals'
-import tseslint from 'typescript-eslint'
-
-export default [
-  pluginJs.configs.recommended,
-  ...tseslint.configs.recommended,
-  {
-    languageOptions: {
-      globals: globals.browser
-    },
-    plugins: {
-      '@typescript-eslint': eslintPlugin,
-      'simple-import-sort': eslintPluginSimpleImportSort
-    },
-    rules: {
-      'no-undef': 'off',
-      '@typescript-eslint/no-explicit-any': 'off',
-      'simple-import-sort/imports': 'error',
-      'simple-import-sort/exports': 'error'
-    }
-  }
-]

package/test/logger/filter.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { filterLog } from '~/logger/filter'
-import { LogLevel, Options } from '~/types'
-
-describe('filterLog', () => {
-  const logLevel: LogLevel = 'info'
-  const status = 200
-  const method = 'GET'
-
-  it('should return true if no filter is provided', () => {
-    expect(filterLog(logLevel, status, method)).toBe(true)
-  })
-
-  it('should filter by log level (single value)', () => {
-    const options: Options = { config: { logFilter: { level: 'error' } } }
-    expect(filterLog(logLevel, status, method, options)).toBe(false)
-  })
-
-  it('should filter by log level (array)', () => {
-    const options: Options = {
-      config: { logFilter: { level: ['error', 'info'] } }
-    }
-    expect(filterLog(logLevel, status, method, options)).toBe(true)
-  })
-
-  it('should filter by status (single value)', () => {
-    const options: Options = { config: { logFilter: { status: 404 } } }
-    expect(filterLog(logLevel, status, method, options)).toBe(false)
-  })
-
-  it('should filter by status (array)', () => {
-    const options: Options = { config: { logFilter: { status: [200, 404] } } }
-    expect(filterLog(logLevel, status, method, options)).toBe(true)
-  })
-
-  it('should filter by method (single value)', () => {
-    const options: Options = { config: { logFilter: { method: 'POST' } } }
-    expect(filterLog(logLevel, status, method, options)).toBe(false)
-  })
-
-  it('should filter by method (array)', () => {
-    const options: Options = {
-      config: { logFilter: { method: ['GET', 'POST'] } }
-    }
-    expect(filterLog(logLevel, status, method, options)).toBe(true)
-  })
-
-  it('should return false if any filter condition is not met', () => {
-    const options: Options = {
-      config: { logFilter: { level: 'info', status: 404, method: 'POST' } }
-    }
-    expect(filterLog(logLevel, status, method, options)).toBe(false)
-  })
-
-  it('should return true if all filter conditions are met', () => {
-    const options: Options = {
-      config: { logFilter: { level: 'info', status: 200, method: 'GET' } }
-    }
-    expect(filterLog(logLevel, status, method, options)).toBe(true)
-  })
-})

package/test/logixlysia.test.ts

@@ -1,223 +0,0 @@
-import { edenTreaty } from '@elysiajs/eden'
-import { beforeAll, beforeEach, describe, expect, it } from 'bun:test'
-import { Elysia } from 'elysia'
-
-import logixlysia from '../src'
-
-describe('Logixlysia with IP logging enabled', () => {
-  let server: Elysia
-  let app: ReturnType<typeof edenTreaty> | any
-  let logs: string[] = []
-
-  beforeAll(() => {
-    server = new Elysia()
-      .use(
-        logixlysia({
-          config: {
-            ip: true,
-            customLogFormat:
-              '🦊 {now} {duration} {level} {method} {pathname} {status} {message} {ip}'
-          }
-        })
-      )
-      .get('/', () => {
-        return '🦊 Logixlysia Getting'
-      })
-      .post('logixlysia', () => '🦊 Logixlysia Posting')
-      .listen(3000)
-
-    app = edenTreaty<typeof server>('http://127.0.0.1:3000')
-  })
-
-  beforeEach(() => {
-    logs = []
-  })
-
-  it("Logs incoming IP address for GET '/' requests when X-Forwarded-For header is present", async () => {
-    const requestCount = 5
-
-    for (let i = 0; i < requestCount; i++) {
-      await app.get('/', {
-        headers: { 'X-Forwarded-For': '192.168.1.1' }
-      })
-    }
-
-    logs.forEach(log => {
-      expect(log).toMatch(
-        /^🦊 .+ INFO .+ .+ GET \/ .+ IP: \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/
-      )
-    })
-  })
-
-  it("Logs 'null' for GET '/' requests when X-Forwarded-For header is not present", async () => {
-    logs.forEach(log => {
-      expect(log).toMatch(/^🦊 .+ INFO .+ .+ GET \/ .+ IP: null$/)
-    })
-  })
-})
-
-describe('Logixlysia with IP logging disabled', () => {
-  let server: Elysia
-  let app: ReturnType<typeof edenTreaty> | any
-  let logs: string[] = []
-
-  beforeAll(() => {
-    server = new Elysia()
-      .use(
-        logixlysia({
-          config: {
-            ip: false,
-            customLogFormat:
-              '🦊 {now} {duration} {level} {method} {pathname} {status} {message} {ip}'
-          }
-        })
-      )
-      .get('/', () => '🦊 Logixlysia Getting')
-      .post('logixlysia', () => '🦊 Logixlysia Posting')
-      .listen(3000)
-
-    app = edenTreaty<typeof server>('http://127.0.0.1:3000')
-  })
-
-  beforeEach(() => {
-    logs = []
-  })
-
-  it("Responds correctly to GET '/' requests", async () => {
-    const requestCount = 5
-
-    for (let i = 0; i < requestCount; i++) {
-      logs.push((await app.get('/')).data)
-    }
-
-    logs.forEach(log => {
-      expect(log).toBe('🦊 Logixlysia Getting')
-    })
-  })
-
-  it("Responds correctly to POST '/logixlysia' requests", async () => {
-    const requestCount = 5
-
-    for (let i = 0; i < requestCount; i++) {
-      const postResponse = await app.logixlysia.post({})
-      logs.push(
-        postResponse.status === 200 ? postResponse.data : postResponse.error
-      )
-    }
-
-    logs.forEach(log => {
-      expect(log).toBe('🦊 Logixlysia Posting')
-    })
-  })
-
-  it('Throws an error when attempting to post to an undefined route', async () => {
-    const response = await app.undefinedRoute.post({})
-    const error = response.error
-
-    expect(response.status).toBe(404)
-    expect(error).toBeInstanceOf(Error)
-  })
-})
-
-describe('Logixlysia with log filtering enabled', () => {
-  let server: Elysia
-  let app: ReturnType<typeof edenTreaty> | any
-  let logs: string[] = []
-
-  beforeAll(() => {
-    server = new Elysia()
-      .use(
-        logixlysia({
-          config: {
-            logFilter: {
-              level: 'INFO',
-              status: [200, 404],
-              method: 'GET'
-            }
-          }
-        })
-      )
-      .get('/', () => '🦊 Logixlysia Getting')
-      .post('logixlysia', () => '🦊 Logixlysia Posting')
-      .listen(3000)
-
-    app = edenTreaty<typeof server>('http://127.0.0.1:3000')
-  })
-
-  beforeEach(() => {
-    logs = []
-  })
-
-  it("Logs 'GET' requests with status 200 or 404 when log filtering criteria are met", async () => {
-    const requestCount = 5
-
-    for (let i = 0; i < requestCount; i++) {
-      logs.push((await app.get('/')).data)
-    }
-
-    expect(logs.length).toBe(requestCount)
-    logs.forEach(log => {
-      expect(log).toMatch('🦊 Logixlysia Getting')
-    })
-  })
-
-  it("Doesn't log 'POST' requests when log filtering criteria are not met", async () => {
-    const requestCount = 5
-
-    for (let i = 0; i < requestCount; i++) {
-      await app.post('/logixlysia', {})
-    }
-
-    expect(logs.length).toBe(0)
-  })
-
-  const otherMethods = ['PUT', 'DELETE', 'PATCH', 'HEAD'] // OPTIONS is failed (IDK why)
-  otherMethods.forEach(async method => {
-    it(`Logs '${method}' requests with status 200 or 404 when log filtering criteria are met`, async () => {
-      const requestCount = 5
-
-      for (let i = 0; i < requestCount; i++) {
-        logs.push((await app[method.toLowerCase()]('/')).data)
-      }
-
-      expect(logs.length).toBe(requestCount)
-    })
-  })
-})
-
-describe('Logixlysia with log filtering disabled', () => {
-  let server: Elysia
-  let app: ReturnType<typeof edenTreaty> | any
-  let logs: string[] = []
-
-  beforeAll(() => {
-    server = new Elysia()
-      .use(
-        logixlysia({
-          config: {
-            logFilter: null
-          }
-        })
-      )
-      .get('/', () => '🦊 Logixlysia Getting')
-      .post('logixlysia', () => '🦊 Logixlysia Posting')
-      .listen(3000)
-
-    app = edenTreaty<typeof server>('http://127.0.0.1:3000')
-  })
-
-  beforeEach(() => {
-    logs = []
-  })
-
-  it('Logs all requests when log filtering is disabled', async () => {
-    const requestCount = 5
-
-    for (let i = 0; i < requestCount; i++) {
-      logs.push((await app.get('/')).data)
-      logs.push((await app.post('/logixlysia', {})).data)
-    }
-
-    expect(logs.length).toBe(requestCount * 2)
-  })
-})

package/test/types/ColorMap.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { ColorMap } from '~/types'
-
-describe('Color Mapping Interface', () => {
-  it('Defines an object with string keys mapping to functions', () => {
-    const colorMap: ColorMap = {
-      red: (str: string) => `Red: ${str}`,
-      green: (str: string) => `Green: ${str}`,
-      blue: (str: string) => `Blue: ${str}`
-    }
-
-    expect(colorMap).toEqual(
-      expect.objectContaining({
-        red: expect.any(Function),
-        green: expect.any(Function),
-        blue: expect.any(Function)
-      })
-    )
-
-    Object.keys(colorMap).forEach(key => {
-      expect(typeof colorMap[key]).toBe('function')
-    })
-  })
-})

package/test/types/HttpError.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { HttpError } from '~/types'
-
-describe('HttpError', () => {
-  it('Should create an instance with correct status and message', () => {
-    const status = 404
-    const message = 'Not Found'
-    const error = new HttpError(status, message)
-
-    expect(error).toBeInstanceOf(Error)
-    expect(error).toBeInstanceOf(HttpError)
-    expect(error.status).toBe(status)
-    expect(error.message).toBe(message)
-  })
-})

package/test/types/Logger.test.ts

@@ -1,91 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from 'bun:test'
-
-import { LogData, RequestInfo, StoreData } from '~/types'
-
-interface Logger {
-  info(request: RequestInfo, data: LogData, store: StoreData): void
-  warning(request: RequestInfo, data: LogData, store: StoreData): void
-  error(request: RequestInfo, data: LogData, store: StoreData): void
-}
-
-describe('Logger interface', () => {
-  let logger: Logger
-
-  beforeEach(() => {
-    logger = {
-      info: jest.fn(),
-      warning: jest.fn(),
-      error: jest.fn()
-    }
-  })
-
-  it('Defines the Logger interface correctly', () => {
-    expect(logger).toEqual(
-      expect.objectContaining({
-        info: expect.any(Function),
-        warning: expect.any(Function),
-        error: expect.any(Function)
-      })
-    )
-  })
-
-  it('Calls the info log function with the correct arguments', () => {
-    const request: RequestInfo = {
-      url: '/info',
-      method: 'GET',
-      headers: {
-        get: function () {
-          throw new Error('Function not implemented.')
-        }
-      }
-    }
-    const data: LogData = { status: 200, message: 'Info log message' }
-    const store: StoreData = {
-      beforeTime: 0n
-    }
-
-    logger.info(request, data, store)
-
-    expect(logger.info).toHaveBeenCalledWith(request, data, store)
-  })
-
-  it('Calls the warning log function with the correct arguments', () => {
-    const request: RequestInfo = {
-      url: '/warning',
-      method: 'POST',
-      headers: {
-        get: function () {
-          throw new Error('Function not implemented.')
-        }
-      }
-    }
-    const data: LogData = { status: 404, message: 'Warning log message' }
-    const store: StoreData = {
-      beforeTime: 0n
-    }
-
-    logger.warning(request, data, store)
-
-    expect(logger.warning).toHaveBeenCalledWith(request, data, store)
-  })
-
-  it('Calls the error log function with the correct arguments', () => {
-    const request: RequestInfo = {
-      url: '/error',
-      method: 'DELETE',
-      headers: {
-        get: function () {
-          throw new Error('Function not implemented.')
-        }
-      }
-    }
-    const data: LogData = { status: 500, message: 'Error log message' }
-    const store: StoreData = {
-      beforeTime: 0n
-    }
-
-    logger.error(request, data, store)
-
-    expect(logger.error).toHaveBeenCalledWith(request, data, store)
-  })
-})

package/test/types/RequestInfo.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { RequestInfo } from '~/types'
-
-describe('Request Infomation interface', () => {
-  it('Defines the RequestInfo interface correctly', () => {
-    const headers = { get: () => 'value' }
-    const method = 'GET'
-    const url = 'https://example.com/api'
-
-    const request: RequestInfo = { headers, method, url }
-
-    expect(request).toEqual(
-      expect.objectContaining({
-        headers: expect.objectContaining({
-          get: expect.any(Function)
-        }),
-        method: expect.any(String),
-        url: expect.any(String)
-      })
-    )
-  })
-})

package/test/types/Server.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { Server } from '~/types'
-
-describe('Server interface', () => {
-  it('Defines the Server interface correctly', () => {
-    const server: Server = {
-      hostname: 'example.com',
-      port: 8080,
-      protocol: 'https'
-    }
-
-    expect(server).toEqual(
-      expect.objectContaining({
-        hostname: expect.any(String),
-        port: expect.any(Number),
-        protocol: expect.any(String)
-      })
-    )
-  })
-
-  it('Allows optional properties in the Server interface', () => {
-    const serverWithoutOptionalProps: Server = {}
-
-    expect(serverWithoutOptionalProps).toEqual(expect.objectContaining({}))
-  })
-})

package/test/types/StoreData.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { StoreData } from '~/types'
-
-describe('Store Data interface', () => {
-  it('Defines the StoreData interface correctly', () => {
-    const beforeTime: bigint = BigInt(1633393533526) // Example bigint value
-
-    const storeData: StoreData = { beforeTime }
-
-    expect(storeData).toEqual(
-      expect.objectContaining({
-        beforeTime: expect.any(BigInt)
-      })
-    )
-  })
-})

package/test/utils/duration.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import durationString from '~/utils/duration'
-
-describe('Duration String', () => {
-  const testCases = [
-    [
-      'Generates a string representing the duration in Seconds (s) unit',
-      1e9,
-      's'
-    ],
-    [
-      'Generates a string representing the duration in Milliseconds (ms) unit',
-      1e6,
-      'ms'
-    ],
-    [
-      'Generates a string representing the duration in Microseconds (µs) unit',
-      1e3,
-      'µs'
-    ]
-    // [
-    //   'Generates a string representing the duration in Nanoseconds (ns) unit',
-    //   1,
-    //   'ns'
-    // ]
-  ]
-
-  for (const [description, nanoseconds, unit] of testCases) {
-    it(`${description}`, () => {
-      const beforeTime = process.hrtime.bigint() - BigInt(String(nanoseconds))
-      const result = durationString(beforeTime)
-
-      expect(result).toMatch(String(unit))
-    })
-  }
-})

package/test/utils/log.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import chalk from 'chalk'
-
-import logString from '~/utils/log'
-
-describe('Log String', () => {
-  it('Produces a green background string for INFO log level', () => {
-    const result = logString('INFO')
-    expect(result).toBe(chalk.bgGreen.black('INFO   '))
-  })
-
-  it('Produces a yellow background string for WARNING log leve', () => {
-    const result = logString('WARNING')
-    expect(result).toBe(chalk.bgYellow.black('WARNING'))
-  })
-
-  it('Produces a red background string for ERROR log level', () => {
-    const result = logString('ERROR')
-    expect(result).toBe(chalk.bgRed.black('ERROR  '))
-  })
-
-  it('Returns the unmodified input string for unrecognized log levels', () => {
-    const result = logString('DEBUG') // Assuming 'DEBUG' is not in the colorMap
-    expect(result).toBe('DEBUG') // No coloring, returns the original string
-  })
-})

package/test/utils/method.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import chalk from 'chalk'
-
-import methodString from '~/utils/method'
-
-describe('Method String', () => {
-  it('Displays a colored string for the GET method', () => {
-    const result = methodString('GET')
-    expect(result).toBe(chalk.green('GET    '))
-  })
-
-  it('Displays a colored string for the POST method', () => {
-    const result = methodString('POST')
-    expect(result).toBe(chalk.yellow('POST   '))
-  })
-
-  it('Outputs the original method string if it is not recognized', () => {
-    const result = methodString('INVALID_METHOD')
-    expect(result).toBe('INVALID_METHOD') // No coloring, returns the original string
-  })
-})

package/test/utils/path.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-
-import { RequestInfo } from '~/types'
-import pathString from '~/utils/path'
-
-describe('Path String', () => {
-  it('Extracts the pathname from a valid URL', () => {
-    const testPath: RequestInfo = {
-      url: 'https://www.example.com/path/to/resource',
-      headers: new Map(),
-      method: 'GET'
-    }
-    const result = pathString(testPath)
-    expect(result).toBe('/path/to/resource')
-  })
-
-  it('Handles malformed URL gracefully', () => {
-    const testPath: RequestInfo = {
-      url: 'invalid url',
-      headers: new Map(),
-      method: 'GET'
-    }
-    const result = pathString(testPath)
-    expect(result).toBeUndefined()
-  })
-
-  it('Returns undefined if the URL is missing', () => {
-    const testPath: RequestInfo = {
-      url: '',
-      headers: new Map(),
-      method: 'GET'
-    }
-    const result = pathString(testPath)
-    expect(result).toBeUndefined()
-  })
-})

package/test/utils/start.test.ts

@@ -1,38 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, jest } from 'bun:test'
-
-import { Server } from '~/types'
-import startServer from '~/utils/start'
-
-describe('Start String', () => {
-  let originalConsoleLog: typeof console.log
-  let mockConsoleLog: jest.Mock
-
-  beforeEach(() => {
-    originalConsoleLog = console.log
-    mockConsoleLog = jest.fn()
-    console.log = mockConsoleLog
-  })
-
-  afterEach(() => {
-    console.log = originalConsoleLog
-  })
-
-  it('Correctly logs the expected message upon server start', () => {
-    const config: Server = {
-      hostname: 'localhost',
-      port: 3000,
-      protocol: 'http'
-    }
-
-    startServer(config)
-
-    const expectedMessage = `🦊 Elysia is running at http://localhost:3000`
-
-    // Extract the arguments passed to console.log during the function call
-    const logMessage = mockConsoleLog.mock.calls
-      .map(args => args.join(' '))
-      .join(' ')
-
-    expect(logMessage).toMatch(expectedMessage)
-  })
-})

package/test/utils/status.test.ts

@@ -1,31 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import chalk from 'chalk'
-
-import statusString from '~/utils/status'
-
-describe('Status String', () => {
-  it('Presents the status string in green for a 200 status code', () => {
-    const result = statusString(200)
-    expect(result).toBe(chalk.green('200'))
-  })
-
-  it('Presents the status string in cyan for a 301 status code', () => {
-    const result = statusString(301)
-    expect(result).toBe(chalk.cyan('301'))
-  })
-
-  it('Presents the status string in yellow for a 404 status code', () => {
-    const result = statusString(404)
-    expect(result).toBe(chalk.yellow('404'))
-  })
-
-  it('Presents the status string in red for a 500 status code', () => {
-    const result = statusString(500)
-    expect(result).toBe(chalk.red('500'))
-  })
-
-  it('Presents the status string in white for a 100 status code', () => {
-    const result = statusString(100)
-    expect(result).toBe(chalk.white('100'))
-  })
-})

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "compilerOptions": {
-    "noUncheckedIndexedAccess": true,
-    "strict": true,
-    "allowImportingTsExtensions": true,
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "paths": {
-      "~/*": ["./src/*"]
-    },
-    "resolveJsonModule": true,
-    "types": ["bun-types"],
-    "downlevelIteration": true,
-    "noEmit": true,
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "jsx": "react",
-    "jsxFactory": "ElysiaJSX",
-    "jsxFragmentFactory": "ElysiaJSX.Fragment",
-    "lib": ["ESNext"],
-    "moduleDetection": "force",
-    "target": "ESNext",
-    "composite": true,
-    "skipLibCheck": true
-  }
-}