logixlysia 3.7.0 → 4.1.0

package/CHANGELOG.md

@@ -1,11 +1,29 @@
 # Changelog
 
+## [4.1.0](https://github.com/PunGrumpy/logixlysia/compare/v4.0.0...v4.1.0) (2025-01-31)
+
+
+### Features
+
+* **logging:** add status string parsing and error handling ([32800ac](https://github.com/PunGrumpy/logixlysia/commit/32800acb0fbfdf957e2975b5773b0a350e3af0d8)), closes [#71](https://github.com/PunGrumpy/logixlysia/issues/71)
+
+## [4.0.0](https://github.com/PunGrumpy/logixlysia/compare/v3.7.0...v4.0.0) (2024-10-28)
+
+
+### ⚠ BREAKING CHANGES
+
+* **timestamp:** The timestamp format in logs will now respect the new timestamp configuration options when provided
+
+### Features
+
+* **timestamp:** add customize timestamp formatting ([5a4e2a5](https://github.com/PunGrumpy/logixlysia/commit/5a4e2a5230443761d8c2ca99d9ebc586ff26a8c0)), closes [#69](https://github.com/PunGrumpy/logixlysia/issues/69)
+
 ## [3.7.0](https://github.com/PunGrumpy/logixlysia/compare/v3.6.2...v3.7.0) (2024-09-26)
 
 
 ### Features
 
-* **optional:** add startup message config ([c7a76db](https://github.com/PunGrumpy/logixlysia/commit/c7a76dbc0f30f4c9c607b52dedc49979e26b67ec))
+* **optional:** add startup message config ([#66](https://github.com/PunGrumpy/logixlysia/pull/66)) ([c7a76db](https://github.com/PunGrumpy/logixlysia/commit/c7a76dbc0f30f4c9c607b52dedc49979e26b67ec)) by [@n0ky4](https://github.com/n0ky4)
 
 ## [3.6.2](https://github.com/PunGrumpy/logixlysia/compare/v3.6.1...v3.6.2) (2024-09-18)
 

package/README.md

@@ -23,6 +23,9 @@ const app = new Elysia({
     config: {
       showStartupMessage: true,
       startupMessageFormat: 'simple',
+      timestamp: {
+        translateTime: 'yyyy-mm-dd HH:MM:ss'
+      },
       ip: true,
       logFilePath: './logs/example.log',
       customLogFormat:
@@ -42,6 +45,9 @@ app.listen(3000)
 > [!NOTE]
 > You can discover more about example in the [example](example) directory.
 
+> [!TIP]
+> Also, you can play my example with Swagger UI on `http://localhost:3000/swagger`.
+
 ## `📚` Documentation
 
 ### Options
@@ -50,6 +56,7 @@ app.listen(3000)
 | ---------------------- | ------------------------ | --------------------------------------------------------------------- | ------------------------------------------------------------------------- |
 | `showStartupMessage`   | `boolean`                | Display the startup message                                           | `true`                                                                    |
 | `startupMessageFormat` | `"banner"` \| `"simple"` | Choose the startup message format                                     | `"banner"`                                                                |
+| `timestamp`            | `object`                 | Display the timestamp in the logs                                     | `{ translateTime: 'yyyy-mm-dd HH:MM:ss' }`                                |
 | `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}` |
 | `logFilter`            | `object`                 | Filter the logs based on the level, method, and status                | `null`                                                                    |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "3.7.0",
+  "version": "4.1.0",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -10,6 +10,12 @@
   "maintainers": [
     "PunGrumpy"
   ],
+  "contributors": [
+    {
+      "name": "n0ky4",
+      "url": "https://github.com/n0ky4"
+    }
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -70,22 +76,23 @@
     "middleware"
   ],
   "dependencies": {
+    "@elysiajs/swagger": "^1.2.0",
     "chalk": "^5.3.0",
-    "elysia": "^1.1.16"
+    "elysia": "^1.1.23"
   },
   "devDependencies": {
     "@elysiajs/eden": "^1.1.3",
-    "@eslint/js": "^9.11.1",
+    "@eslint/js": "^9.13.0",
     "@trunkio/launcher": "^1.3.2",
-    "@typescript-eslint/eslint-plugin": "^8.7.0",
-    "@typescript-eslint/parser": "^8.7.0",
-    "bun-types": "^1.1.29",
+    "@typescript-eslint/eslint-plugin": "^8.11.0",
+    "@typescript-eslint/parser": "^8.11.0",
+    "bun-types": "^1.1.33",
     "eslint-plugin-simple-import-sort": "^12.1.1",
-    "globals": "^15.9.0",
+    "globals": "^15.11.0",
     "husky": "^9.1.6",
     "lint-staged": "^15.2.10",
     "prettier": "^3.3.3",
-    "typescript-eslint": "^8.7.0"
+    "typescript-eslint": "^8.11.0"
   },
   "peerDependencies": {
     "typescript": "^5.2.2"

package/src/core/buildLogMessage.ts

@@ -10,6 +10,7 @@ import {
 } from '../types'
 import {
   durationString,
+  formatTimestamp,
   logString,
   methodString,
   pathString,
@@ -38,14 +39,16 @@ export function buildLogMessage(
   const now = new Date()
   const components: LogComponents = {
     now: actuallyUseColors
-      ? chalk.bgYellow(chalk.black(now.toLocaleString()))
-      : now.toLocaleString(),
+      ? chalk.bgYellow(
+          chalk.black(formatTimestamp(now, options?.config?.timestamp))
+        )
+      : formatTimestamp(now, options?.config?.timestamp),
     epoch: Math.floor(now.getTime() / 1000).toString(),
-    level: logString(level, actuallyUseColors),
-    duration: durationString(store.beforeTime, actuallyUseColors),
-    method: methodString(request.method, actuallyUseColors),
+    level: logString(level, useColors),
+    duration: durationString(store.beforeTime, useColors),
+    method: methodString(request.method, useColors),
     pathname: pathString(request),
-    status: statusString(data.status || 200, actuallyUseColors),
+    status: statusString(data.status || 200, useColors),
     message: data.message || '',
     ip:
       options?.config?.ip && request.headers.get('x-forwarded-for')

package/src/index.ts

@@ -3,6 +3,7 @@ import { Elysia } from 'elysia'
 import { createLogger } from './core'
 import { startServer } from './plugins'
 import { HttpError, Options, Server } from './types'
+import { getStatusCode } from './utils/status'
 
 export default function logixlysia(options?: Options): Elysia {
   const log = createLogger(options)
@@ -11,19 +12,29 @@ export default function logixlysia(options?: Options): Elysia {
     name: 'Logixlysia'
   })
     .onStart(ctx => {
-        const showStartupMessage = options?.config?.showStartupMessage ?? true
-        if (showStartupMessage) startServer(ctx.server as Server, options)}
-    )
+      const showStartupMessage = options?.config?.showStartupMessage ?? true
+      if (showStartupMessage) startServer(ctx.server as Server, options)
+    })
     .onRequest(ctx => {
       ctx.store = { beforeTime: process.hrtime.bigint() }
     })
-    .onAfterHandle({ as: 'global' }, ({ request, store }) => {
-      log.log('INFO', request, { status: 200 }, store as { beforeTime: bigint })
+    .onAfterHandle({ as: 'global' }, ({ request, set, store }) => {
+      const status = getStatusCode(set.status || 200)
+      log.log(
+        'INFO',
+        request,
+        {
+          status,
+          message: set.headers?.['x-message'] || ''
+        },
+        store as { beforeTime: bigint }
+      )
     })
-    .onError({ as: 'global' }, ({ request, error, store }) => {
+    .onError({ as: 'global' }, ({ request, error, set, store }) => {
+      const status = getStatusCode(set.status || 500)
       log.handleHttpError(
         request,
-        error as HttpError,
+        { ...error, status } as HttpError,
         store as { beforeTime: bigint }
       )
     })
@@ -31,4 +42,3 @@ export default function logixlysia(options?: Options): Elysia {
 
 export { createLogger, handleHttpError } from './core'
 export { logToTransports } from './transports'
-

package/src/types/index.ts

@@ -77,6 +77,10 @@ export interface Transport {
   log: TransportFunction
 }
 
+export interface TimestampConfig {
+  translateTime?: boolean | string
+}
+
 export interface Options {
   config?: {
     customLogFormat?: string
@@ -91,5 +95,6 @@ export interface Options {
     showStartupMessage?: boolean
     startupMessageFormat?: 'banner' | 'simple'
     transports?: Transport[]
+    timestamp?: TimestampConfig // Add this new option
   }
 }

package/src/utils/index.ts

@@ -4,3 +4,4 @@ export { default as logString } from './log'
 export { default as methodString } from './method'
 export { default as pathString } from './path'
 export { default as statusString } from './status'
+export { formatTimestamp } from './timestamp'

package/src/utils/status.ts

@@ -1,18 +1,21 @@
 import chalk from 'chalk'
+import { StatusMap } from 'elysia'
+
+export function getStatusCode(status: string | number): number {
+  if (typeof status === 'number') return status
+  return (StatusMap as Record<string, number>)[status] || 500
+}
 
 export default function statusString(
   status: number,
   useColors: boolean
 ): string {
-  const color =
-    status >= 500
-      ? 'red'
-      : status >= 400
-        ? 'yellow'
-        : status >= 300
-          ? 'cyan'
-          : status >= 200
-            ? 'green'
-            : 'white'
-  return useColors ? chalk[color](status.toString()) : status.toString()
+  const statusStr = status.toString()
+  if (!useColors) return statusStr
+
+  if (status >= 500) return chalk.red(statusStr)
+  if (status >= 400) return chalk.yellow(statusStr)
+  if (status >= 300) return chalk.cyan(statusStr)
+  if (status >= 200) return chalk.green(statusStr)
+  return chalk.white(statusStr)
 }

package/src/utils/timestamp.ts

@@ -0,0 +1,48 @@
+import { TimestampConfig } from '../types'
+
+// const DEFAULT_TIMESTAMP_FORMAT = 'yyyy-mm-dd HH:MM:ss'
+const SYS_TIME = 'SYS:STANDARD'
+
+const pad = (n: number): string => n.toString().padStart(2, '0')
+
+function formatSystemTime(date: Date): string {
+  const year = date.getFullYear()
+  const month = pad(date.getMonth() + 1)
+  const day = pad(date.getDate())
+  const hours = pad(date.getHours())
+  const minutes = pad(date.getMinutes())
+  const seconds = pad(date.getSeconds())
+  const ms = date.getMilliseconds().toString().padStart(3, '0')
+
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`
+}
+
+function formatCustomTime(date: Date, format: string): string {
+  const tokens: { [key: string]: string | number } = {
+    yyyy: date.getFullYear(),
+    yy: date.getFullYear().toString().slice(-2),
+    mm: pad(date.getMonth() + 1),
+    dd: pad(date.getDate()),
+    HH: pad(date.getHours()),
+    MM: pad(date.getMinutes()),
+    ss: pad(date.getSeconds()),
+    SSS: pad(date.getMilliseconds()),
+    Z: -date.getTimezoneOffset() / 60
+  }
+
+  return format.replace(/yyyy|yy|mm|dd|HH|MM|ss|SSS|Z/g, match =>
+    (tokens[match] ?? '').toString()
+  )
+}
+
+export function formatTimestamp(date: Date, config?: TimestampConfig): string {
+  if (!config || !config.translateTime) {
+    return date.toISOString()
+  }
+
+  if (config.translateTime === true || config.translateTime === SYS_TIME) {
+    return formatSystemTime(date)
+  }
+
+  return formatCustomTime(date, config.translateTime)
+}

package/tests/utils/status.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from 'bun:test'
+import { Elysia } from 'elysia'
+
+import logixlysia from '../../src/index'
+
+test('handles numeric status codes', async () => {
+  const app = new Elysia().use(logixlysia()).get('/rate-limited', ({ set }) => {
+    set.status = 429
+    return 'Rate Limited'
+  })
+
+  const res = await app.handle(new Request('http://localhost/rate-limited'))
+  expect(res.status).toBe(429)
+})
+
+test('handles string status codes', async () => {
+  const app = new Elysia().use(logixlysia()).get('/not-found', ({ set }) => {
+    set.status = 'Not Found'
+    return 'Resource not found'
+  })
+
+  const res = await app.handle(new Request('http://localhost/not-found'))
+  expect(res.status).toBe(404)
+})
+
+test('handles custom error status', async () => {
+  const app = new Elysia().use(logixlysia()).get('/error', ({ set }) => {
+    set.status = 418
+    const error = new Error('Custom error')
+    throw error
+  })
+
+  const res = await app.handle(new Request('http://localhost/error'))
+  expect(res.status).toBe(418)
+})
+
+test('handles custom error status with message', async () => {
+  const app = new Elysia().use(logixlysia()).get('/error', ({ set }) => {
+    set.status = "I'm a teapot"
+    const error = new Error('Custom error')
+    throw error
+  })
+
+  const res = await app.handle(new Request('http://localhost/error'))
+  expect(res.status).toBe(418)
+})

package/tests/utils/timestamp.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from 'bun:test'
+
+import { formatTimestamp } from '../../src/utils/timestamp'
+
+test('formatTimestamp with different configurations', () => {
+  const testDate = new Date('2024-01-15T14:30:45.123Z')
+
+  // Test default format
+  expect(formatTimestamp(testDate)).toBe(testDate.toISOString())
+
+  // Test system time format
+  expect(formatTimestamp(testDate, { translateTime: true })).toMatch(
+    /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/
+  )
+
+  // Test custom format
+  expect(
+    formatTimestamp(testDate, {
+      translateTime: 'yyyy-mm-dd HH:MM:ss.SSS'
+    })
+  ).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/)
+
+  // Test different custom formats
+  expect(
+    formatTimestamp(testDate, {
+      translateTime: 'HH:MM:ss'
+    })
+  ).toMatch(/^\d{2}:\d{2}:\d{2}$/)
+
+  expect(
+    formatTimestamp(testDate, {
+      translateTime: 'yyyy/mm/dd'
+    })
+  ).toMatch(/^\d{4}\/\d{2}\/\d{2}$/)
+})