logixlysia 2.1.0 → 2.2.0

package/CHANGELOG.md

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

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.1.0",
+  "version": "2.2.0",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -15,13 +15,11 @@
   },
   "license": "MIT",
   "scripts": {
-    "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",
+    "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",
@@ -70,17 +68,18 @@
     "middleware"
   ],
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.18.1",
-    "@typescript-eslint/parser": "^6.18.1",
+    "@typescript-eslint/eslint-plugin": "^7.3.1",
+    "@typescript-eslint/parser": "^7.3.1",
     "chalk": "^5.3.0",
-    "elysia": "^0.8.9",
-    "eslint": "^8.56.0"
+    "elysia": "^1.0.4",
+    "eslint": "^8.57.0"
   },
   "devDependencies": {
-    "bun-types": "^1.0.22",
-    "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,6 +2,7 @@ import Elysia from 'elysia'
 import { createLogger } from './logger'
 import startString from './utils/start'
 import { Server } from 'bun'
+import { Options } from './options'
 
 /**
  * Creates a logger.
@@ -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({
@@ -30,9 +31,28 @@ export const logger = (): Elysia => {
     .onRequest(ctx => {
       ctx.store = { beforeTime: process.hrtime.bigint() }
     })
-    .onAfterHandle(({ request, store }) => {
+    .onBeforeHandle({ as: 'global' }, ({ request, store }) => {
       log.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.log('ERROR', request, error, store as { beforeTime: bigint })
     })

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/utils/duration.ts

@@ -1,29 +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 nanoseconds = Number(now - beforeTime)
+  const nanoseconds = Number(process.hrtime.bigint() - beforeTime)
 
-  let timeMessage: string = ''
+  const timeUnits = [
+    { unit: 's', threshold: 1e9 },
+    { unit: 'ms', threshold: 1e6 },
+    { unit: 'µs', threshold: 1e3 }
+  ]
 
-  if (nanoseconds >= 1e9) {
-    timeMessage = `${(nanoseconds / 1e9).toFixed(2)}s`
-  } else if (nanoseconds >= 1e6) {
-    timeMessage = `${(nanoseconds / 1e6).toFixed(0)}ms`
-  } else if (nanoseconds >= 1e3) {
-    timeMessage = `${(nanoseconds / 1e3).toFixed(0)}µ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)
+    }
   }
 
-  return timeMessage ? chalk.gray(timeMessage).padStart(8).padEnd(16) : ''
+  return formatTime(nanoseconds.toString(), 'ns')
+}
+
+/**
+ * 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/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('Generates a string representing the duration in appropriate 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))
-    }
-  })
+    })
+  }
 })