logixlysia 2.0.1 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.1.0](https://github.com/PunGrumpy/logixlysia/compare/v2.0.2...v2.1.0) (2024-01-25)
+
+
+### Features
+
+* **logger:** implement asynchronous logging functionality ([1017af0](https://github.com/PunGrumpy/logixlysia/commit/1017af0a28bd6121a85ec814a9177fd303c2572c))
+
+## [2.0.2](https://github.com/PunGrumpy/logixlysia/compare/v2.0.1...v2.0.2) (2024-01-07)
+
+
+### Bug Fixes
+
+* **logger:** change time from `iso` to `local` ([33ff28a](https://github.com/PunGrumpy/logixlysia/commit/33ff28a4a41db1dda7ca224e4807bd2451b95985))
+
 ## [2.0.1](https://github.com/PunGrumpy/logixlysia/compare/v2.0.0...v2.0.1) (2024-01-03)
 
 

package/lint-staged.config.cjs

@@ -9,11 +9,17 @@ const isPnpm = existsSync(join(process.cwd(), 'pnpm-lock.yaml'))
 const packageManager = isBun ? 'bun' : isYarn ? 'yarn' : isPnpm ? 'pnpm' : 'npm'
 
 const options = {
+  // TypeScript & JavaScript files
   '**/*.(ts|tsx)': () => `${packageManager} tsc --noEmit`,
   '**/*.(ts|tsx|js)': filenames => [
     `${packageManager} eslint --fix ${filenames.join(' ')}`,
     `${packageManager} prettier --write ${filenames.join(' ')}`
   ],
+  '**/*.(css|less|scss)': filenames =>
+    `${packageManager} test --timeout 5000 --coverage --update-snapshots ${filenames.join(
+      ' '
+    )}`,
+  // Markdown & JSON files
   '**/*.(md|json)': filenames =>
     `${packageManager} prettier --write ${filenames.join(' ')}`
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -15,11 +15,15 @@
   },
   "license": "MIT",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "dev": "bun run --watch example/basic.ts",
-    "prepare": "husky install",
+    "pretest": "bun run lint && bun run lint:fix && bun run prettier",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
+    "prepublish": "bun run pretest && bun run test",
+    "test": "bun test --timeout 5000 --coverage --update-snapshots",
+    "test:ci": "bun test --timeout 5000 --coverage --update-snapshots",
+    "publish": "bun run prepublish && npm publish",
+    "dev": "bun run --watch example/basic.ts",
+    "prepare": "husky install",
     "lint:staged": "lint-staged",
     "prettier": "prettier --write ."
   },
@@ -66,17 +70,17 @@
     "middleware"
   ],
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.13.2",
-    "@typescript-eslint/parser": "^6.13.2",
+    "@typescript-eslint/eslint-plugin": "^6.18.1",
+    "@typescript-eslint/parser": "^6.18.1",
     "chalk": "^5.3.0",
-    "elysia": "^0.8.3",
-    "eslint": "^8.55.0"
+    "elysia": "^0.8.9",
+    "eslint": "^8.56.0"
   },
   "devDependencies": {
-    "bun-types": "^1.0.15",
+    "bun-types": "^1.0.22",
     "husky": "^8.0.3",
     "lint-staged": "^15.2.0",
-    "prettier": "^3.1.0"
+    "prettier": "^3.1.1"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/index.ts

@@ -6,7 +6,7 @@ import { Server } from 'bun'
 /**
  * Creates a logger.
  *
- * @export {Function} The logger.
+ * @export
  * @module logger
  * @category Logger
  * @subcategory Functions
@@ -28,20 +28,13 @@ export const logger = (): Elysia => {
       startString(ctx.server as Server)
     })
     .onRequest(ctx => {
-      ctx.store = { beforeTime: process.hrtime.bigint() } as {
-        beforeTime: bigint
-      }
-    })
-    .onBeforeHandle(ctx => {
-      ctx.store = { beforeTime: process.hrtime.bigint() } as {
-        beforeTime: bigint
-      }
+      ctx.store = { beforeTime: process.hrtime.bigint() }
     })
     .onAfterHandle(({ request, store }) => {
-      log.info(request, {}, store as { beforeTime: bigint })
+      log.log('INFO', request, {}, store as { beforeTime: bigint })
     })
     .onError(({ request, error, store }) => {
-      log.error(request, error, store as { beforeTime: bigint })
+      log.log('ERROR', request, error, store as { beforeTime: bigint })
     })
 
   return elysia

package/src/logger.ts

@@ -9,27 +9,47 @@ import { LogData, LogLevel, Logger } from './types/Logger'
 import { StoreData } from './types/StoreData'
 
 /**
- * Logs a message to the console.
+ * Asynchronously logs a message constructed from various log components.
  *
- * @param {LogLevel} level The log level.
- * @param {RequestInfo} request The request information.
- * @param {LogData} data The log data.
- * @param {StoreData} store The store data.
+ * @async
+ * @param {LogLevel} level - The log level.
+ * @param {RequestInfo} request - The request information.
+ * @param {LogData} data - The log data.
+ * @param {StoreData} store - The store data.
  *
- * @returns {void} The log message.
+ * @returns {Promise<void>}
  */
-function log(
+async function log(
   level: LogLevel,
   request: RequestInfo,
   data: LogData,
   store: StoreData
-): void {
-  const logStr: string[] = []
-  const nowStr = chalk.bgYellow(
-    chalk.black(
-      new Date().toISOString().replace('T', ' ').replace('Z', '').slice(0, -4)
-    )
-  )
+): Promise<void> {
+  const logMessage = buildLogMessage(level, request, data, store)
+  try {
+    await writeToLogAsync(logMessage)
+  } catch (error) {
+    console.error('Error logging message:', error)
+  }
+}
+
+/**
+ * Builds the log message string from given parameters.
+ *
+ * @param {LogLevel} level - The log level.
+ * @param {RequestInfo} request - The request information.
+ * @param {LogData} data - The log data.
+ * @param {StoreData} store - The store data.
+ *
+ * @returns {string} - The constructed log message.
+ */
+function buildLogMessage(
+  level: LogLevel,
+  request: RequestInfo,
+  data: LogData,
+  store: StoreData
+): string {
+  const nowStr = chalk.bgYellow(chalk.black(new Date().toLocaleString()))
   const levelStr = logString(level)
   const durationStr = durationString(store.beforeTime)
   const methodStr = methodString(request.method)
@@ -37,21 +57,34 @@ function log(
   const statusStr = statusString(data.status || 200)
   const messageStr = data.message || ''
 
-  logStr.push(
-    `🦊 ${nowStr} ${levelStr} ${durationStr} ${methodStr} ${pathnameStr} ${statusStr} ${messageStr}`
-  )
+  return `🦊 ${nowStr} ${levelStr} ${durationStr} ${methodStr} ${pathnameStr} ${statusStr} ${messageStr}`
+}
+
+/**
+ * Writes a log message to the console asynchronously.
+ *
+ * @async
+ * @param {string} message - The message to log.
+ *
+ * @returns {Promise<void>}
+ * @throws {Error} - If the timeout is reached.
+ */
+function writeToLogAsync(message: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    console.log(message)
+    resolve()
 
-  console.log(logStr.join(' '))
+    setTimeout(() => {
+      reject(new Error('Timed out while writing to log.'))
+    })
+  })
 }
 
 /**
- * Creates a formatted logger.
+ * Creates a logger instance with an asynchronous log method.
  *
- * @returns {Logger} The formatted logger.
+ * @returns {Logger} - The logger instance.
  */
 export const createLogger = (): Logger => ({
-  info: (request, data, store) => log(LogLevel.INFO, request, data, store),
-  warning: (request, data, store) =>
-    log(LogLevel.WARNING, request, data, store),
-  error: (request, data, store) => log(LogLevel.ERROR, request, data, store)
+  log: (level, request, data, store) => log(level, request, data, store)
 })

package/src/types/Logger.ts

@@ -2,27 +2,19 @@ import { RequestInfo } from './RequestInfo'
 import { StoreData } from './StoreData'
 
 /**
- * The log level.
+ * The log level, including standard and custom levels.
  *
- * @enum {string}
- *
- * @property {string} INFO - The info log level.
- * @property {string} WARNING - The warning log level.
- * @property {string} ERROR - The error log level.
+ * @type {string}
  */
-enum LogLevel {
-  INFO = 'INFO',
-  WARNING = 'WARNING',
-  ERROR = 'ERROR'
-}
+type LogLevel = 'INFO' | 'WARNING' | 'ERROR' | string
 
 /**
  * The log data interface.
  *
  * @interface LogData
  *
- * @property {number} status The status code.
- * @property {string} message The message.
+ * @property {number} status - The status code.
+ * @property {string} message - The message.
  */
 interface LogData {
   status?: number
@@ -34,14 +26,15 @@ interface LogData {
  *
  * @interface Logger
  *
- * @property {Function} info Logs an info message.
- * @property {Function} warning Logs a warning message.
- * @property {Function} error Logs an error message.
+ * @property {Function} log - Logs a message with a given log level.
  */
 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
+  log(
+    level: LogLevel,
+    request: RequestInfo,
+    data: LogData,
+    store: StoreData
+  ): void
 }
 
 export { LogLevel, LogData, Logger }

package/src/utils/colorMapping.ts

@@ -0,0 +1,40 @@
+import chalk from 'chalk'
+import { ColorMap } from '~/types/ColorMap'
+
+/**
+ * The color map for the log levels.
+ *
+ * @type {ColorMap}
+ * @property {chalk.Chalk} INFO The color for the INFO log level.
+ * @property {chalk.Chalk} WARNING The color for the WARNING log level.
+ * @property {chalk.Chalk} ERROR The color for the ERROR log level.
+ */
+const LogLevelColorMap: ColorMap = {
+  INFO: chalk.bgGreen.black,
+  WARNING: chalk.bgYellow.black,
+  ERROR: chalk.bgRed.black
+}
+
+/**
+ * The color map for the HTTP methods.
+ *
+ * @type {ColorMap}
+ * @property {chalk.Chalk} GET The color for the GET HTTP method.
+ * @property {chalk.Chalk} POST The color for the POST HTTP method.
+ * @property {chalk.Chalk} PUT The color for the PUT HTTP method.
+ * @property {chalk.Chalk} DELETE The color for the DELETE HTTP method.
+ * @property {chalk.Chalk} PATCH The color for the PATCH HTTP method.
+ * @property {chalk.Chalk} OPTIONS The color for the OPTIONS HTTP method.
+ * @property {chalk.Chalk} HEAD The color for the HEAD HTTP method.
+ */
+const HttpMethodColorMap: ColorMap = {
+  GET: chalk.white,
+  POST: chalk.yellow,
+  PUT: chalk.blue,
+  DELETE: chalk.red,
+  PATCH: chalk.green,
+  OPTIONS: chalk.cyan,
+  HEAD: chalk.magenta
+}
+
+export { LogLevelColorMap, HttpMethodColorMap }

package/src/utils/duration.ts

@@ -9,30 +9,21 @@ import chalk from 'chalk'
  */
 function durationString(beforeTime: bigint): string {
   const now = process.hrtime.bigint()
-  const timeDifference = now - beforeTime
-  const nanoseconds = Number(timeDifference)
-
-  const durationInMicroseconds = (nanoseconds / 1e3).toFixed(0)
-  const durationInMilliseconds = (nanoseconds / 1e6).toFixed(0)
+  const nanoseconds = Number(now - beforeTime)
 
   let timeMessage: string = ''
 
   if (nanoseconds >= 1e9) {
-    const seconds = (nanoseconds / 1e9).toFixed(2)
-    timeMessage = `${seconds}s`
+    timeMessage = `${(nanoseconds / 1e9).toFixed(2)}s`
   } else if (nanoseconds >= 1e6) {
-    timeMessage = `${durationInMilliseconds}ms`
+    timeMessage = `${(nanoseconds / 1e6).toFixed(0)}ms`
   } else if (nanoseconds >= 1e3) {
-    timeMessage = `${durationInMicroseconds}µs`
+    timeMessage = `${(nanoseconds / 1e3).toFixed(0)}µs`
   } else {
     timeMessage = `${nanoseconds}ns`
   }
 
-  if (timeMessage) {
-    timeMessage = chalk.gray(timeMessage).padStart(8).padEnd(16)
-  }
-
-  return timeMessage
+  return timeMessage ? chalk.gray(timeMessage).padStart(8).padEnd(16) : ''
 }
 
 export default durationString

package/src/utils/log.ts

@@ -1,5 +1,4 @@
-import chalk from 'chalk'
-import { ColorMap } from '~/types/ColorMap'
+import { LogLevelColorMap } from './colorMapping'
 
 /**
  * Converts a log level to a colored string representation.
@@ -9,16 +8,10 @@ import { ColorMap } from '~/types/ColorMap'
  * @returns {string} A colored string representing the log level.
  */
 function logString(log: string): string {
-  const colorMap: ColorMap = {
-    INFO: chalk.bgGreen,
-    WARNING: chalk.bgYellow,
-    ERROR: chalk.bgRed
-  }
-
-  const colorFunction = colorMap[log]
+  const colorFunction = LogLevelColorMap[log]
 
   if (colorFunction) {
-    return colorFunction(chalk.black(log.padEnd(7)))
+    return colorFunction(log.padEnd(7))
   }
 
   return log

package/src/utils/method.ts

@@ -1,5 +1,4 @@
-import chalk from 'chalk'
-import { ColorMap } from '~/types/ColorMap'
+import { HttpMethodColorMap } from './colorMapping'
 
 /**
  * Converts an HTTP request method to a colored string representation.
@@ -9,17 +8,7 @@ import { ColorMap } from '~/types/ColorMap'
  * @returns {string} A colored string representing the method.
  */
 function methodString(method: string): string {
-  const colorMap: ColorMap = {
-    GET: chalk.white,
-    POST: chalk.yellow,
-    PUT: chalk.blue,
-    DELETE: chalk.red,
-    PATCH: chalk.green,
-    OPTIONS: chalk.cyan,
-    HEAD: chalk.magenta
-  }
-
-  const colorFunction = colorMap[method]
+  const colorFunction = HttpMethodColorMap[method]
 
   if (colorFunction) {
     return colorFunction(method.padEnd(7))

package/src/utils/path.ts

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

package/src/utils/start.ts

@@ -9,8 +9,9 @@ import { Server } from '~/types/Server'
  * @returns {string} The box text.
  */
 function createBoxText(text: string, width: number): string {
-  const padding = ' '.repeat((width - text.length) / 2)
-  return `${padding}${text}${padding}`
+  const paddingLength = Math.max(0, (width - text.length + 1) / 2)
+  const padding = ' '.repeat(paddingLength)
+  return `${padding}${text}${padding}`.slice(0, width)
 }
 
 /**
@@ -29,15 +30,13 @@ function startString(config: Server): void {
   const boxWidth = Math.max(title.length, messageWidth) + 4
   const border = '─'.repeat(boxWidth)
 
-  process.stdout.write('\x1Bc')
-
   console.log(`
       ┌${border}┐
-      │${createBoxText('', boxWidth)} │
+      │${createBoxText('', boxWidth)}│
       │${createBoxText(title, boxWidth)}│
-      │${createBoxText('', boxWidth)} │
+      │${createBoxText('', boxWidth)}│
       │${createBoxText(message, boxWidth)}│
-      │${createBoxText('', boxWidth)} │
+      │${createBoxText('', boxWidth)}│
       └${border}┘
     `)
 }

package/src/utils/status.ts

@@ -8,20 +8,18 @@ import chalk from 'chalk'
  * @returns {string} The status string.
  */
 function statusString(status: number): string {
-  if (status >= 500) {
-    return chalk.red(status.toString())
+  switch (true) {
+    case status >= 500:
+      return chalk.red(status.toString())
+    case status >= 400:
+      return chalk.yellow(status.toString())
+    case status >= 300:
+      return chalk.cyan(status.toString())
+    case status >= 200:
+      return chalk.green(status.toString())
+    default:
+      return status.toString()
   }
-  if (status >= 400) {
-    return chalk.yellow(status.toString())
-  }
-  if (status >= 300) {
-    return chalk.cyan(status.toString())
-  }
-  if (status >= 200) {
-    return chalk.green(status.toString())
-  }
-
-  return status.toString()
 }
 
 export default statusString

package/test/types/ColorMap.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'bun:test'
+import { ColorMap } from '~/types/ColorMap'
+
+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/Logger.test.ts

@@ -0,0 +1,92 @@
+import { beforeEach, describe, expect, it, jest } from 'bun:test'
+import { LogData } from '~/types/Logger'
+import { RequestInfo } from '~/types/RequestInfo'
+import { StoreData } from '~/types/StoreData'
+
+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

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'bun:test'
+import { RequestInfo } from '~/types/RequestInfo'
+
+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

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'bun:test'
+import { Server } from '~/types/Server'
+
+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

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'bun:test'
+import { StoreData } from '~/types/StoreData'
+
+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

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

package/test/utils/log.test.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,20 @@
+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.white('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

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'bun:test'
+import { RequestInfo } from '~/types/RequestInfo'
+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

@@ -0,0 +1,35 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from 'bun:test'
+import { Server } from '~/types/Server'
+import startString from '~/utils/start'
+
+describe('Start String', () => {
+  let originalConsoleLog: any
+  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'
+    }
+
+    startString(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
+
+    expect(logMessage).toMatch(expectedMessage)
+  })
+})

package/test/utils/status.test.ts

@@ -0,0 +1,30 @@
+import chalk from 'chalk'
+import { describe, expect, it } from 'bun:test'
+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 green for a 301 status code', () => {
+    const result = statusString(301)
+    expect(result).toBe(chalk.cyan('301'))
+  })
+
+  it('Presents the status string in green for a 404 status code', () => {
+    const result = statusString(404)
+    expect(result).toBe(chalk.yellow('404'))
+  })
+
+  it('Presents the status string in green for a 500 status code', () => {
+    const result = statusString(500)
+    expect(result).toBe(chalk.red('500'))
+  })
+
+  it('Presents the status string in green for a 100 status code', () => {
+    const result = statusString(100)
+    expect(result).toBe('100')
+  })
+})