logixlysia 2.0.1 → 2.0.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.0.2](https://github.com/PunGrumpy/logixlysia/compare/v2.0.1...v2.0.2) (2024-01-07)
+
+
+### Bug Fixes
+
+* **logger:** change time from `iso` to `local` ([33ff28a](https://github.com/PunGrumpy/logixlysia/commit/33ff28a4a41db1dda7ca224e4807bd2451b95985))
+
 ## [2.0.1](https://github.com/PunGrumpy/logixlysia/compare/v2.0.0...v2.0.1) (2024-01-03)
 
 

package/lint-staged.config.cjs

@@ -9,11 +9,17 @@ const isPnpm = existsSync(join(process.cwd(), 'pnpm-lock.yaml'))
 const packageManager = isBun ? 'bun' : isYarn ? 'yarn' : isPnpm ? 'pnpm' : 'npm'
 
 const options = {
+  // TypeScript & JavaScript files
   '**/*.(ts|tsx)': () => `${packageManager} tsc --noEmit`,
   '**/*.(ts|tsx|js)': filenames => [
     `${packageManager} eslint --fix ${filenames.join(' ')}`,
     `${packageManager} prettier --write ${filenames.join(' ')}`
   ],
+  '**/*.(css|less|scss)': filenames =>
+    `${packageManager} test --timeout 5000 --coverage --update-snapshots ${filenames.join(
+      ' '
+    )}`,
+  // Markdown & JSON files
   '**/*.(md|json)': filenames =>
     `${packageManager} prettier --write ${filenames.join(' ')}`
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logixlysia",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "🦊 Logixlysia is a logger for Elysia",
   "type": "module",
   "module": "src/index.ts",
@@ -15,7 +15,10 @@
   },
   "license": "MIT",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "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",
@@ -66,17 +69,17 @@
     "middleware"
   ],
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.13.2",
-    "@typescript-eslint/parser": "^6.13.2",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
     "chalk": "^5.3.0",
-    "elysia": "^0.8.3",
-    "eslint": "^8.55.0"
+    "elysia": "^0.8.8",
+    "eslint": "^8.56.0"
   },
   "devDependencies": {
-    "bun-types": "^1.0.15",
+    "bun-types": "^1.0.21",
     "husky": "^8.0.3",
     "lint-staged": "^15.2.0",
-    "prettier": "^3.1.0"
+    "prettier": "^3.1.1"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/logger.ts

@@ -25,11 +25,7 @@ function log(
   store: StoreData
 ): void {
   const logStr: string[] = []
-  const nowStr = chalk.bgYellow(
-    chalk.black(
-      new Date().toISOString().replace('T', ' ').replace('Z', '').slice(0, -4)
-    )
-  )
+  const nowStr = chalk.bgYellow(chalk.black(new Date().toLocaleString()))
   const levelStr = logString(level)
   const durationStr = durationString(store.beforeTime)
   const methodStr = methodString(request.method)

package/src/utils/start.ts

@@ -29,8 +29,6 @@ function startString(config: Server): void {
   const boxWidth = Math.max(title.length, messageWidth) + 4
   const border = '─'.repeat(boxWidth)
 
-  process.stdout.write('\x1Bc')
-
   console.log(`
       ┌${border}┐
       │${createBoxText('', boxWidth)} │

package/test/types/ColorMap.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'bun:test'
+import { ColorMap } from '~/types/ColorMap'
+
+describe('Color Mapping Interface', () => {
+  it('Defines an object with string keys mapping to functions', () => {
+    const colorMap: ColorMap = {
+      red: (str: string) => `Red: ${str}`,
+      green: (str: string) => `Green: ${str}`,
+      blue: (str: string) => `Blue: ${str}`
+    }
+
+    expect(colorMap).toEqual(
+      expect.objectContaining({
+        red: expect.any(Function),
+        green: expect.any(Function),
+        blue: expect.any(Function)
+      })
+    )
+
+    Object.keys(colorMap).forEach(key => {
+      expect(typeof colorMap[key]).toBe('function')
+    })
+  })
+})

package/test/types/Logger.test.ts

@@ -0,0 +1,92 @@
+import { beforeEach, describe, expect, it, jest } from 'bun:test'
+import { LogData } from '~/types/Logger'
+import { RequestInfo } from '~/types/RequestInfo'
+import { StoreData } from '~/types/StoreData'
+
+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
+}
+
+describe('Logger interface', () => {
+  let logger: Logger
+
+  beforeEach(() => {
+    logger = {
+      info: jest.fn(),
+      warning: jest.fn(),
+      error: jest.fn()
+    }
+  })
+
+  it('Defines the Logger interface correctly', () => {
+    expect(logger).toEqual(
+      expect.objectContaining({
+        info: expect.any(Function),
+        warning: expect.any(Function),
+        error: expect.any(Function)
+      })
+    )
+  })
+
+  it('Calls the info log function with the correct arguments', () => {
+    const request: RequestInfo = {
+      url: '/info',
+      method: 'GET',
+      headers: {
+        get: function () {
+          throw new Error('Function not implemented.')
+        }
+      }
+    }
+    const data: LogData = { status: 200, message: 'Info log message' }
+    const store: StoreData = {
+      beforeTime: 0n
+    }
+
+    logger.info(request, data, store)
+
+    expect(logger.info).toHaveBeenCalledWith(request, data, store)
+  })
+
+  it('Calls the warning log function with the correct arguments', () => {
+    const request: RequestInfo = {
+      url: '/warning',
+      method: 'POST',
+      headers: {
+        get: function () {
+          throw new Error('Function not implemented.')
+        }
+      }
+    }
+    const data: LogData = { status: 404, message: 'Warning log message' }
+    const store: StoreData = {
+      beforeTime: 0n
+    }
+
+    logger.warning(request, data, store)
+
+    expect(logger.warning).toHaveBeenCalledWith(request, data, store)
+  })
+
+  it('Calls the error log function with the correct arguments', () => {
+    const request: RequestInfo = {
+      url: '/error',
+      method: 'DELETE',
+      headers: {
+        get: function () {
+          throw new Error('Function not implemented.')
+        }
+      }
+    }
+    const data: LogData = { status: 500, message: 'Error log message' }
+    const store: StoreData = {
+      beforeTime: 0n
+    }
+
+    logger.error(request, data, store)
+
+    expect(logger.error).toHaveBeenCalledWith(request, data, store)
+  })
+})

package/test/types/RequestInfo.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'bun:test'
+import { RequestInfo } from '~/types/RequestInfo'
+
+describe('Request Infomation interface', () => {
+  it('Defines the RequestInfo interface correctly', () => {
+    const headers = { get: () => 'value' }
+    const method = 'GET'
+    const url = 'https://example.com/api'
+
+    const request: RequestInfo = { headers, method, url }
+
+    expect(request).toEqual(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          get: expect.any(Function)
+        }),
+        method: expect.any(String),
+        url: expect.any(String)
+      })
+    )
+  })
+})

package/test/types/Server.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'bun:test'
+import { Server } from '~/types/Server'
+
+describe('Server interface', () => {
+  it('Defines the Server interface correctly', () => {
+    const server: Server = {
+      hostname: 'example.com',
+      port: 8080,
+      protocol: 'https'
+    }
+
+    expect(server).toEqual(
+      expect.objectContaining({
+        hostname: expect.any(String),
+        port: expect.any(Number),
+        protocol: expect.any(String)
+      })
+    )
+  })
+
+  it('Allows optional properties in the Server interface', () => {
+    const serverWithoutOptionalProps: Server = {}
+
+    expect(serverWithoutOptionalProps).toEqual(expect.objectContaining({}))
+  })
+})

package/test/types/StoreData.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'bun:test'
+import { StoreData } from '~/types/StoreData'
+
+describe('Store Data interface', () => {
+  it('Defines the StoreData interface correctly', () => {
+    const beforeTime: bigint = BigInt(1633393533526) // Example bigint value
+
+    const storeData: StoreData = { beforeTime }
+
+    expect(storeData).toEqual(
+      expect.objectContaining({
+        beforeTime: expect.any(BigInt)
+      })
+    )
+  })
+})

package/test/utils/duration.test.ts

@@ -0,0 +1,20 @@
+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']
+    ]
+
+    for (const [nanoseconds, unit] of testCases) {
+      const beforeTime = process.hrtime.bigint() - BigInt(String(nanoseconds))
+
+      const result = durationString(beforeTime)
+      expect(result).toMatch(String(unit))
+    }
+  })
+})

package/test/utils/log.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'bun:test'
+import chalk from 'chalk'
+import logString from '~/utils/log'
+
+describe('Log String', () => {
+  it('Returns a colored 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', () => {
+    const result = logString('WARNING')
+    expect(result).toBe(chalk.bgYellow.black('WARNING'))
+  })
+
+  it('Returns a colored 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', () => {
+    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

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'bun:test'
+import chalk from 'chalk'
+import methodString from '~/utils/method'
+
+describe('Method String', () => {
+  it('Returns a colored string for GET method', () => {
+    const result = methodString('GET')
+    expect(result).toBe(chalk.white('GET    '))
+  })
+
+  it('Returns a colored string for POST method', () => {
+    const result = methodString('POST')
+    expect(result).toBe(chalk.yellow('POST   '))
+  })
+
+  it('Returns the input string if method 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

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'bun:test'
+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' }
+    const result = pathString(testPath)
+    expect(result).toMatch('/path/to/resource')
+  })
+})

package/test/utils/start.test.ts

@@ -0,0 +1,35 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from 'bun:test'
+import { Server } from '~/types/Server'
+import startString from '~/utils/start'
+
+describe('Start String', () => {
+  let originalConsoleLog: any
+  let mockConsoleLog: jest.Mock
+
+  beforeEach(() => {
+    originalConsoleLog = console.log
+    mockConsoleLog = jest.fn()
+    console.log = mockConsoleLog
+  })
+
+  afterEach(() => {
+    console.log = originalConsoleLog
+  })
+
+  it('Logs the expected server start message', () => {
+    const config: Server = {
+      hostname: 'localhost',
+      port: 3000,
+      protocol: 'http'
+    }
+
+    startString(config)
+
+    const expectedMessage = `🦊 Elysia is running at http://localhost:3000`
+
+    // Extract the arguments passed to console.log during the function call
+    const [[logMessage]] = mockConsoleLog.mock.calls
+
+    expect(logMessage).toMatch(expectedMessage)
+  })
+})

package/test/utils/status.test.ts

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