logixlysia 2.0.2 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -15,14 +15,15 @@
   },
   "license": "MIT",
   "scripts": {
-    "pretest": "bun run lint && bun run prettier && bun run lint:fix",
+    "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",
-    "prepublish": "bun run test",
+    "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": "eslint . --ext .ts",
-    "lint:fix": "eslint . --ext .ts --fix",
     "lint:staged": "lint-staged",
     "prettier": "prettier --write ."
   },
@@ -69,14 +70,14 @@
     "middleware"
   ],
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.17.0",
-    "@typescript-eslint/parser": "^6.17.0",
+    "@typescript-eslint/eslint-plugin": "^6.18.1",
+    "@typescript-eslint/parser": "^6.18.1",
     "chalk": "^5.3.0",
-    "elysia": "^0.8.8",
+    "elysia": "^0.8.9",
     "eslint": "^8.56.0"
   },
   "devDependencies": {
-    "bun-types": "^1.0.21",
+    "bun-types": "^1.0.22",
     "husky": "^8.0.3",
     "lint-staged": "^15.2.0",
     "prettier": "^3.1.1"

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,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/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)
 }
 
 /**
@@ -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/utils/duration.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'bun:test'
 import durationString from '~/utils/duration'
 
 describe('Duration String', () => {
-  it('Returns a duration string with different units', () => {
+  it('Generates a string representing the duration in appropriate units', () => {
     const testCases = [
       [1e9, 's'],
       [1e6, 'ms'],

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')
   })