logixlysia 2.0.2 → 2.2.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [2.2.0](https://github.com/PunGrumpy/logixlysia/compare/v2.1.0...v2.2.0) (2024-03-19)
+
+
+### Features
+
+* **options:** add show ip ([4e997c5](https://github.com/PunGrumpy/logixlysia/commit/4e997c557e9aef6046a93e0cab9fe11a87df3430))
+
+
+### Bug Fixes
+
+* **logger:** change to use array and push them ([3feefb7](https://github.com/PunGrumpy/logixlysia/commit/3feefb7a8dddc42c4eec54de40ab9dd8d5c70e70))
+
+## [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)
 
 

package/README.md

@@ -23,6 +23,14 @@ const app = new Elysia({
 app.listen(3000)
 ```
 
+## `📚` Documentation
+
+### Options
+
+| Option | Type      | Description                                                           | Default |
+| ------ | --------- | --------------------------------------------------------------------- | ------- |
+| `ip`   | `boolean` | Display the incoming IP address based on the `X-Forwarded-For` header | `false` |
+
 ## `📄` License
 
 Licensed under the [MIT License](LICENSE).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -15,14 +15,13 @@
   },
   "license": "MIT",
   "scripts": {
-    "pretest": "bun run lint && bun run prettier && bun run lint:fix",
-    "test": "bun test --timeout 5000 --coverage --update-snapshots",
-    "prepublish": "bun run test",
-    "publish": "bun run prepublish && npm publish",
-    "dev": "bun run --watch example/basic.ts",
-    "prepare": "husky install",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
+    "test": "bun test --timeout 5000 --coverage",
+    "test:ci": "bun test --timeout 5000 --coverage",
+    "publish": "npm publish",
+    "dev": "bun run --watch example/basic.ts",
+    "prepare": "husky install",
     "lint:staged": "lint-staged",
     "prettier": "prettier --write ."
   },
@@ -69,17 +68,18 @@
     "middleware"
   ],
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.17.0",
-    "@typescript-eslint/parser": "^6.17.0",
+    "@typescript-eslint/eslint-plugin": "^7.3.1",
+    "@typescript-eslint/parser": "^7.3.1",
     "chalk": "^5.3.0",
-    "elysia": "^0.8.8",
-    "eslint": "^8.56.0"
+    "elysia": "^1.0.4",
+    "eslint": "^8.57.0"
   },
   "devDependencies": {
-    "bun-types": "^1.0.21",
-    "husky": "^8.0.3",
-    "lint-staged": "^15.2.0",
-    "prettier": "^3.1.1"
+    "@elysiajs/eden": "^1.0.4",
+    "bun-types": "^1.0.33",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.2",
+    "prettier": "^3.2.5"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/index.ts

@@ -2,11 +2,12 @@ import Elysia from 'elysia'
 import { createLogger } from './logger'
 import startString from './utils/start'
 import { Server } from 'bun'
+import { Options } from './options'
 
 /**
  * Creates a logger.
  *
- * @export {Function} The logger.
+ * @export
  * @module logger
  * @category Logger
  * @subcategory Functions
@@ -18,7 +19,7 @@ import { Server } from 'bun'
  *
  * @returns {Elysia} The logger.
  */
-export const logger = (): Elysia => {
+export const logger = (options?: Options): Elysia => {
   const log = createLogger()
 
   const elysia = new Elysia({
@@ -28,20 +29,32 @@ export const logger = (): Elysia => {
       startString(ctx.server as Server)
     })
     .onRequest(ctx => {
-      ctx.store = { beforeTime: process.hrtime.bigint() } as {
-        beforeTime: bigint
-      }
+      ctx.store = { beforeTime: process.hrtime.bigint() }
     })
-    .onBeforeHandle(ctx => {
-      ctx.store = { beforeTime: process.hrtime.bigint() } as {
-        beforeTime: bigint
-      }
+    .onBeforeHandle({ as: 'global' }, ({ request, store }) => {
+      log.log('INFO', request, {}, store as { beforeTime: bigint })
     })
-    .onAfterHandle(({ request, store }) => {
-      log.info(request, {}, store as { beforeTime: bigint })
+    .onAfterHandle({ as: 'global' }, ({ request, store }) => {
+      const logStr: string[] = []
+
+      if (options?.ip) {
+        const forwardedFor = request.headers.get('x-forwarded-for')
+        if (forwardedFor) {
+          logStr.push(`IP: ${forwardedFor}`)
+        }
+      }
+
+      log.log(
+        'INFO',
+        request,
+        {
+          message: logStr.join(' ')
+        },
+        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,22 +9,46 @@ 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[] = []
+): 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)
@@ -33,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/options.ts

@@ -0,0 +1,11 @@
+/**
+ * Options for the logger.
+ */
+interface Options {
+  /**
+   * Whether to log the IP address of the client.
+   */
+  ip?: boolean
+}
+
+export { Options }

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

@@ -1,38 +1,42 @@
 import chalk from 'chalk'
 
 /**
- * Converts the time difference between the start of the request and the end of the request to a formatted string.
+ * Converts a time difference into a formatted string with the most appropriate time unit.
+ * Units used are seconds (s), milliseconds (ms), microseconds (µs), and nanoseconds (ns).
  *
- * @param {bigint} beforeTime The timestamp taken before the request.
+ * @param {bigint} beforeTime - The timestamp taken before the request.
  *
- * @returns {string} A formatted duration string with a time unit.
+ * @returns {string} A formatted duration string including the time unit.
  */
 function durationString(beforeTime: bigint): string {
-  const now = process.hrtime.bigint()
-  const timeDifference = now - beforeTime
-  const nanoseconds = Number(timeDifference)
+  const nanoseconds = Number(process.hrtime.bigint() - beforeTime)
 
-  const durationInMicroseconds = (nanoseconds / 1e3).toFixed(0)
-  const durationInMilliseconds = (nanoseconds / 1e6).toFixed(0)
+  const timeUnits = [
+    { unit: 's', threshold: 1e9 },
+    { unit: 'ms', threshold: 1e6 },
+    { unit: 'µs', threshold: 1e3 }
+  ]
 
-  let timeMessage: string = ''
-
-  if (nanoseconds >= 1e9) {
-    const seconds = (nanoseconds / 1e9).toFixed(2)
-    timeMessage = `${seconds}s`
-  } else if (nanoseconds >= 1e6) {
-    timeMessage = `${durationInMilliseconds}ms`
-  } else if (nanoseconds >= 1e3) {
-    timeMessage = `${durationInMicroseconds}µs`
-  } else {
-    timeMessage = `${nanoseconds}ns`
+  for (const { unit, threshold } of timeUnits) {
+    if (nanoseconds >= threshold) {
+      const value = (nanoseconds / threshold).toFixed(threshold === 1e9 ? 2 : 0)
+      return formatTime(value, unit)
+    }
   }
 
-  if (timeMessage) {
-    timeMessage = chalk.gray(timeMessage).padStart(8).padEnd(16)
-  }
+  return formatTime(nanoseconds.toString(), 'ns')
+}
 
-  return timeMessage
+/**
+ * Formats the time value with the given unit and applies chalk styling.
+ *
+ * @param {string} value - The time value.
+ * @param {string} unit - The time unit.
+ *
+ * @returns {string} Styled time string.
+ */
+function formatTime(value: string, unit: string): string {
+  return chalk.gray(`${value}${unit}`).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)
 }
 
 /**
@@ -31,11 +32,11 @@ function startString(config: Server): void {
 
   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/logixlysia.test.ts

@@ -0,0 +1,53 @@
+import { Elysia } from 'elysia'
+import { edenTreaty } from '@elysiajs/eden'
+import { describe, it, expect, beforeAll, beforeEach } from 'bun:test'
+import { logger } from '../src'
+
+describe('Logixlysia', () => {
+  let server: Elysia
+  let app: any
+  let logs: string[] = []
+
+  describe('IP logging disabled', () => {
+    beforeAll(() => {
+      server = new Elysia()
+        .use(logger({ ip: false }))
+        .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')
+      })
+    })
+  })
+})

package/test/utils/duration.test.ts

@@ -2,19 +2,35 @@ import { describe, expect, it } from 'bun:test'
 import durationString from '~/utils/duration'
 
 describe('Duration String', () => {
-  it('Returns a duration string with different units', () => {
-    const testCases = [
-      [1e9, 's'],
-      [1e6, 'ms'],
-      [1e3, 'µs'],
-      [1, 'ns']
+  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 [nanoseconds, unit] of testCases) {
+  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

@@ -3,22 +3,22 @@ import chalk from 'chalk'
 import logString from '~/utils/log'
 
 describe('Log String', () => {
-  it('Returns a colored string for INFO log level', () => {
+  it('Produces a green background string for INFO log level', () => {
     const result = logString('INFO')
     expect(result).toBe(chalk.bgGreen.black('INFO   '))
   })
 
-  it('Returns a colored string for WARNING log level', () => {
+  it('Produces a yellow background string for WARNING log leve', () => {
     const result = logString('WARNING')
     expect(result).toBe(chalk.bgYellow.black('WARNING'))
   })
 
-  it('Returns a colored string for ERROR log level', () => {
+  it('Produces a red background string for ERROR log level', () => {
     const result = logString('ERROR')
     expect(result).toBe(chalk.bgRed.black('ERROR  '))
   })
 
-  it('Returns the input string if log level is not recognized', () => {
+  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

@@ -3,17 +3,17 @@ import chalk from 'chalk'
 import methodString from '~/utils/method'
 
 describe('Method String', () => {
-  it('Returns a colored string for GET method', () => {
+  it('Displays a colored string for the GET method', () => {
     const result = methodString('GET')
     expect(result).toBe(chalk.white('GET    '))
   })
 
-  it('Returns a colored string for POST method', () => {
+  it('Displays a colored string for the POST method', () => {
     const result = methodString('POST')
     expect(result).toBe(chalk.yellow('POST   '))
   })
 
-  it('Returns the input string if method is not recognized', () => {
+  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,10 +1,35 @@
 import { describe, expect, it } from 'bun:test'
+import { RequestInfo } from '~/types/RequestInfo'
 import pathString from '~/utils/path'
 
 describe('Path String', () => {
-  it('Returns the path string from a URL', () => {
-    const testPath: any = { url: 'https://www.example.com/path/to/resource' }
+  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).toMatch('/path/to/resource')
+    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

@@ -16,7 +16,7 @@ describe('Start String', () => {
     console.log = originalConsoleLog
   })
 
-  it('Logs the expected server start message', () => {
+  it('Correctly logs the expected message upon server start', () => {
     const config: Server = {
       hostname: 'localhost',
       port: 3000,

package/test/utils/status.test.ts

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