logixlysia 2.3.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [3.0.0](https://github.com/PunGrumpy/logixlysia/compare/v2.3.1...v3.0.0) (2024-04-08)
+
+
+### ⚠ BREAKING CHANGES
+
+* **options:** 
+
+### Features
+
+* **options:** add support for custom log format ([acc9380](https://github.com/PunGrumpy/logixlysia/commit/acc9380ea25691e7d7fec175094cb6a9878b6c69))
+
+## [2.3.1](https://github.com/PunGrumpy/logixlysia/compare/v2.3.0...v2.3.1) (2024-04-07)
+
+
+### Bug Fixes
+
+* **index:** remove duplicate logging when options IP enabled ([2e99bd6](https://github.com/PunGrumpy/logixlysia/commit/2e99bd628b7160fb43161ca08e49f711b74e8666))
+
 ## [2.3.0](https://github.com/PunGrumpy/logixlysia/compare/v2.2.3...v2.3.0) (2024-04-06)
 
 

package/README.md

@@ -18,7 +18,13 @@ import { logger } from 'logixlysia'
 
 const app = new Elysia({
   name: 'Logixlysia Example'
-}).use(logger())
+}).use(
+  logger({
+    ip: false,
+    customLogMessage:
+      '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}'
+  })
+)
 
 app.listen(3000)
 ```
@@ -27,9 +33,10 @@ app.listen(3000)
 
 ### Options
 
-| Option | Type      | Description                                                           | Default |
-| ------ | --------- | --------------------------------------------------------------------- | ------- |
-| `ip`   | `boolean` | Display the incoming IP address based on the `X-Forwarded-For` header | `false` |
+| Option             | Type      | Description                                                           | Default                                                                   |
+| ------------------ | --------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| `ip`               | `boolean` | Display the incoming IP address based on the `X-Forwarded-For` header | `false`                                                                   |
+| `customLogMessage` | `string`  | Custom log message to display                                         | `🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}` |
 
 ## `📄` License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "2.3.0",
+  "version": "3.0.0",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -21,7 +21,7 @@
     "test:ci": "bun test --timeout 5000 --coverage",
     "publish": "npm publish",
     "dev": "bun run --watch example/basic.ts",
-    "prepare": "husky install",
+    "prepare": "husky",
     "lint:staged": "lint-staged",
     "prettier": "prettier --write ."
   },
@@ -77,6 +77,8 @@
   "devDependencies": {
     "@elysiajs/eden": "^1.0.4",
     "bun-types": "^1.0.22",
+    "commitizen": "^4.3.0",
+    "cz-conventional-changelog": "^3.3.0",
     "husky": "^9.0.7",
     "lint-staged": "^15.2.0",
     "prettier": "^3.1.1"

package/src/index.ts

@@ -2,7 +2,7 @@ import Elysia from 'elysia'
 import { createLogger, handleHttpError } from './logger'
 import startString from './utils/start'
 import { Server } from 'bun'
-import { Options } from './options'
+import { Options } from './types'
 
 /**
  * Creates a logger.
@@ -20,7 +20,7 @@ import { Options } from './options'
  * @returns {Elysia} The logger.
  */
 export const logger = (options?: Options): Elysia => {
-  const log = createLogger()
+  const log = createLogger(options)
 
   const elysia = new Elysia({
     name: 'Logixlysia'
@@ -32,26 +32,9 @@ export const logger = (options?: Options): Elysia => {
       ctx.store = { beforeTime: process.hrtime.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 }
-      )
+      log.log('INFO', request, { status: 200 }, store as { beforeTime: bigint })
     })
     .onError({ as: 'global' }, ({ request, error, store }) => {
-      // log.log('ERROR', request, error, store as { beforeTime: bigint })
       handleHttpError(request, error, store as { beforeTime: bigint })
     })
 

package/src/logger.ts

@@ -4,51 +4,45 @@ import methodString from './utils/method'
 import logString from './utils/log'
 import pathString from './utils/path'
 import statusString from './utils/status'
-import { RequestInfo } from './types/RequestInfo'
-import { LogData, LogLevel, Logger } from './types/Logger'
-import { StoreData } from './types/StoreData'
-import { HttpError } from './types/HttpError'
+import { HttpError, RequestInfo } from './types'
+import { LogLevel, LogData, Logger, StoreData, Options } from './types'
 
 /**
- * Asynchronously logs a message constructed from various log components.
+ * Logs a message.
  *
- * @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 {Promise<void>}
+ * @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.
  */
-async function log(
+function log(
   level: LogLevel,
   request: RequestInfo,
   data: LogData,
-  store: StoreData
-): Promise<void> {
-  const logMessage = buildLogMessage(level, request, data, store)
-  try {
-    await writeToLogAsync(logMessage)
-  } catch (error) {
-    console.error('Error logging message:', error)
-  }
+  store: StoreData,
+  options?: Options
+): void {
+  const logMessage = buildLogMessage(level, request, data, store, options)
+  console.log(logMessage)
 }
 
 /**
- * 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.
+ * Builds a log message.
  *
- * @returns {string} - The constructed log 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.
+ * @returns {string} The log message.
  */
 function buildLogMessage(
   level: LogLevel,
   request: RequestInfo,
   data: LogData,
-  store: StoreData
+  store: StoreData,
+  options?: Options
 ): string {
   const nowStr = chalk.bgYellow(chalk.black(new Date().toLocaleString()))
   const levelStr = logString(level)
@@ -57,57 +51,60 @@ function buildLogMessage(
   const pathnameStr = pathString(request)
   const statusStr = statusString(data.status || 200)
   const messageStr = data.message || ''
+  const ipStr =
+    options?.ip && request.headers.get('x-forwarded-for')
+      ? `IP: ${request.headers.get('x-forwarded-for')}`
+      : ''
 
-  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()
+  const logFormat =
+    options?.customLogFormat ||
+    '🦊 {now} {level} {duration} {method} {pathname} {status} {message} {ip}'
+  const logMessage = logFormat
+    .replace('{now}', nowStr)
+    .replace('{level}', levelStr)
+    .replace('{duration}', durationStr)
+    .replace('{method}', methodStr)
+    .replace('{pathname}', pathnameStr || '')
+    .replace('{status}', statusStr)
+    .replace('{message}', messageStr)
+    .replace('{ip}', ipStr || '')
 
-    setTimeout(() => {
-      reject(new Error('Timed out while writing to log.'))
-    })
-  })
+  return logMessage
 }
 
 /**
- * Creates a logger instance with an asynchronous log method.
+ * Creates a logger.
  *
- * @returns {Logger} - The logger instance.
+ * @param {Options} options The options.
+ * @returns {Logger} The logger.
  */
-export const createLogger = (): Logger => ({
-  log: (level, request, data, store) => log(level, request, data, store)
+export const createLogger = (options?: Options): Logger => ({
+  log: (level, request, data, store) =>
+    log(level, request, data, store, options),
+  customLogFormat: options?.customLogFormat
 })
 
 /**
- * Handle HTTP errors and log them with the appropriate status code.
+ * Handles an HTTP error.
  *
- * @param {RequestInfo} request - The request information.
- * @param {Error} error - The error object.
- * @param {StoreData} store - The store data.
+ * @param {RequestInfo} request The request.
+ * @param {Error} error The error.
+ * @param {StoreData} store The store data.
+ * @param {Options} options The options.
  */
 export const handleHttpError = (
   request: RequestInfo,
   error: Error,
-  store: StoreData
+  store: StoreData,
+  options?: Options
 ): void => {
   const statusCode = error instanceof HttpError ? error.status : 500
   const logMessage = buildLogMessage(
     'ERROR',
     request,
     { status: statusCode },
-    store
+    store,
+    options
   )
   console.error(logMessage)
 }

package/src/types.ts

@@ -0,0 +1,62 @@
+interface RequestInfo {
+  headers: { get: (key: string) => any }
+  method: string
+  url: string
+}
+
+interface Server {
+  hostname?: string
+  port?: number
+  protocol?: string
+}
+
+interface ColorMap {
+  [key: string]: (str: string) => string
+}
+
+type LogLevel = 'INFO' | 'WARNING' | 'ERROR' | string
+
+interface LogData {
+  status?: number
+  message?: string
+}
+
+interface Logger {
+  log(
+    level: LogLevel,
+    request: RequestInfo,
+    data: LogData,
+    store: StoreData
+  ): void
+  customLogFormat?: string
+}
+
+interface StoreData {
+  beforeTime: bigint
+}
+
+class HttpError extends Error {
+  status: number
+
+  constructor(status: number, message: string) {
+    super(message)
+    this.status = status
+  }
+}
+
+interface Options {
+  ip?: boolean
+  customLogFormat?: string
+}
+
+export {
+  RequestInfo,
+  Server,
+  ColorMap,
+  LogLevel,
+  LogData,
+  Logger,
+  StoreData,
+  HttpError,
+  Options
+}

package/src/utils/colorMapping.ts

@@ -1,5 +1,5 @@
 import chalk from 'chalk'
-import { ColorMap } from '~/types/ColorMap'
+import { ColorMap } from '~/types'
 
 /**
  * The color map for the log levels.

package/src/utils/path.ts

@@ -1,4 +1,4 @@
-import { RequestInfo } from '~/types/RequestInfo'
+import { RequestInfo } from '~/types'
 
 /**
  * Returns the path string.

package/src/utils/start.ts

@@ -1,4 +1,4 @@
-import { Server } from '~/types/Server'
+import { Server } from '~/types'
 
 /**
  * Creates a box text.

package/test/logixlysia.test.ts

@@ -3,51 +3,120 @@ import { edenTreaty } from '@elysiajs/eden'
 import { describe, it, expect, beforeAll, beforeEach } from 'bun:test'
 import { logger } from '../src'
 
-describe('Logixlysia', () => {
+describe('Logixlysia with IP logging enabled', () => {
   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)
+  beforeAll(() => {
+    server = new Elysia()
+      .use(
+        logger({
+          ip: true,
+          customLogFormat:
+            '🦊 {now} {duration} {level} {method} {pathname} {status} {message} {ip}'
+        })
+      )
+      .get('/', ctx => {
+        const ipAddress = ctx.request.headers.get('x-forwarded-for') || 'null'
+        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' }
+      })
+    }
 
-      app = edenTreaty<typeof server>('http://127.0.0.1:3000')
+    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 () => {
+    const requestCount = 5
+
+    for (let i = 0; i < requestCount; i++) {
+      const response = await app.get('/')
+    }
 
-    beforeEach(() => {
-      logs = []
+    logs.forEach(log => {
+      expect(log).toMatch(/^🦊 .+ INFO .+ .+ GET \/ .+ IP: null$/)
     })
+  })
+})
+
+describe('Logixlysia with IP logging disabled', () => {
+  let server: Elysia
+  let app: any
+  let logs: string[] = []
 
-    it("Responds correctly to GET '/' requests", async () => {
-      const requestCount = 5
+  beforeAll(() => {
+    server = new Elysia()
+      .use(
+        logger({
+          ip: false,
+          customLogFormat:
+            '🦊 {now} {duration} {level} {method} {pathname} {status} {message} {ip}'
+        })
+      )
+      .get('/', () => '🦊 Logixlysia Getting')
+      .post('logixlysia', () => '🦊 Logixlysia Posting')
+      .listen(3000)
 
-      for (let i = 0; i < requestCount; i++) {
-        logs.push((await app.get('/')).data)
-      }
+    app = edenTreaty<typeof server>('http://127.0.0.1:3000')
+  })
 
-      logs.forEach(log => {
-        expect(log).toBe('🦊 Logixlysia Getting')
-      })
+  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
+  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
-        )
-      }
+    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')
-      })
+    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)
+  })
 })

package/test/types/ColorMap.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { ColorMap } from '~/types/ColorMap'
+import { ColorMap } from '~/types'
 
 describe('Color Mapping Interface', () => {
   it('Defines an object with string keys mapping to functions', () => {

package/test/types/HttpError.test.ts

@@ -0,0 +1,15 @@
+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,7 +1,5 @@
 import { beforeEach, describe, expect, it, jest } from 'bun:test'
-import { LogData } from '~/types/Logger'
-import { RequestInfo } from '~/types/RequestInfo'
-import { StoreData } from '~/types/StoreData'
+import { RequestInfo, LogData, StoreData } from '~/types'
 
 interface Logger {
   info(request: RequestInfo, data: LogData, store: StoreData): void

package/test/types/RequestInfo.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { RequestInfo } from '~/types/RequestInfo'
+import { RequestInfo } from '~/types'
 
 describe('Request Infomation interface', () => {
   it('Defines the RequestInfo interface correctly', () => {

package/test/types/Server.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { Server } from '~/types/Server'
+import { Server } from '~/types'
 
 describe('Server interface', () => {
   it('Defines the Server interface correctly', () => {

package/test/types/StoreData.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { StoreData } from '~/types/StoreData'
+import { StoreData } from '~/types'
 
 describe('Store Data interface', () => {
   it('Defines the StoreData interface correctly', () => {

package/test/utils/path.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { RequestInfo } from '~/types/RequestInfo'
+import { RequestInfo } from '~/types'
 import pathString from '~/utils/path'
 
 describe('Path String', () => {

package/test/utils/start.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, jest } from 'bun:test'
-import { Server } from '~/types/Server'
+import { Server } from '~/types'
 import startString from '~/utils/start'
 
 describe('Start String', () => {

package/.czrc

@@ -1,3 +0,0 @@
-{
-  "path": "cz-conventional-changelog"
-}

package/src/options.ts

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

package/src/types/ColorMap.ts

@@ -1,12 +0,0 @@
-/**
- * The color map interface.
- *
- * @interface ColorMap
- *
- * @property {string} key The color function.
- */
-interface ColorMap {
-  [key: string]: (str: string) => string
-}
-
-export { ColorMap }

package/src/types/HttpError.ts

@@ -1,11 +0,0 @@
-/**
- * Custom Error class for HTTP errors.
- */
-export class HttpError extends Error {
-  status: number
-
-  constructor(status: number, message: string) {
-    super(message)
-    this.status = status
-  }
-}

package/src/types/Logger.ts

@@ -1,40 +0,0 @@
-import { RequestInfo } from './RequestInfo'
-import { StoreData } from './StoreData'
-
-/**
- * The log level, including standard and custom levels.
- *
- * @type {string}
- */
-type LogLevel = 'INFO' | 'WARNING' | 'ERROR' | string
-
-/**
- * The log data interface.
- *
- * @interface LogData
- *
- * @property {number} status - The status code.
- * @property {string} message - The message.
- */
-interface LogData {
-  status?: number
-  message?: string
-}
-
-/**
- * The logger interface.
- *
- * @interface Logger
- *
- * @property {Function} log - Logs a message with a given log level.
- */
-interface Logger {
-  log(
-    level: LogLevel,
-    request: RequestInfo,
-    data: LogData,
-    store: StoreData
-  ): void
-}
-
-export { LogLevel, LogData, Logger }

package/src/types/RequestInfo.ts

@@ -1,16 +0,0 @@
-/**
- * The request info.
- *
- * @interface RequestInfo
- *
- * @property {Object} headers The request headers.
- * @property {string} method The request method.
- * @property {string} url The request URL.
- */
-interface RequestInfo {
-  headers: { get: (key: string) => any }
-  method: string
-  url: string
-}
-
-export { RequestInfo }

package/src/types/Server.ts

@@ -1,16 +0,0 @@
-/**
- * The server information.
- *
- * @interface Server
- *
- * @property {string} hostname The server hostname.
- * @property {number} port The server port.
- * @property {string} protocol The server protocol.
- */
-interface Server {
-  hostname?: string
-  port?: number
-  protocol?: string
-}
-
-export { Server }

package/src/types/StoreData.ts

@@ -1,12 +0,0 @@
-/**
- * The store data interface.
- *
- * @interface StoreData
- *
- * @property {bigint} beforeTime The time before the request.
- */
-interface StoreData {
-  beforeTime: bigint
-}
-
-export { StoreData }