@logux/server 0.13.1 → 0.14.0

package/human-formatter/index.js

@@ -1,10 +1,5 @@
-import { once } from 'node:events'
 import os from 'node:os'
-import { Transform } from 'node:stream'
-import pico from 'picocolors'
-import pino from 'pino'
-import abstractTransport from 'pino-abstract-transport'
-import stripAnsi from 'strip-ansi'
+import { stripVTControlCharacters, styleText } from 'node:util'
 
 import { mulberry32, onceXmur3 } from './utils.js'
 
@@ -30,10 +25,11 @@ const PARAMS_BLACKLIST = {
 }
 
 const LABELS = {
-  30: (c, str) => label(c, ' INFO ', 'green', 'bgGreen', 'black', str),
-  40: (c, str) => label(c, ' WARN ', 'yellow', 'bgYellow', 'black', str),
-  50: (c, str) => label(c, ' ERROR ', 'red', 'bgRed', 'white', str),
-  60: (c, str) => label(c, ' FATAL ', 'red', 'bgRed', 'white', str)
+  20: str => label(' DEBUG ', 'white', 'bgWhite', 'black', str),
+  30: str => label(' INFO ', 'green', 'bgGreen', 'black', str),
+  40: str => label(' WARN ', 'yellow', 'bgYellow', 'black', str),
+  50: str => label(' ERROR ', 'red', 'bgRed', 'white', str),
+  60: str => label(' FATAL ', 'red', 'bgRed', 'white', str)
 }
 
 const COLORS = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan']
@@ -50,16 +46,16 @@ function formatNow() {
 }
 
 function rightPag(str, length) {
-  let add = length - stripAnsi(str).length
+  let add = length - stripVTControlCharacters(str).length
   for (let i = 0; i < add; i++) str += ' '
   return str
 }
 
-function label(c, type, color, labelBg, labelText, message) {
-  let pagged = rightPag(c[labelBg](c[labelText](type)), 8)
-  let time = c.dim(`at ${formatNow()}`)
-  let highlighted = message.replace(/`([^`]+)`/g, c.yellow('$1'))
-  return `${pagged}${c.bold(c[color](highlighted))} ${time}`
+function label(type, color, labelBg, labelText, message) {
+  let pagged = rightPag(styleText(labelBg, styleText(labelText, type)), 8)
+  let time = styleText('dim', `at ${formatNow()}`)
+  let highlighted = message.replace(/`([^`]+)`/g, styleText('yellow', '$1'))
+  return `${pagged}${styleText('bold', styleText(color, highlighted))} ${time}`
 }
 
 function formatName(key) {
@@ -88,7 +84,7 @@ function shuffledColors(str) {
   return result
 }
 
-function splitAndColorize(c, partLength, str) {
+function splitAndColorize(partLength, str) {
   let strBuilder = []
   let colors = shuffledColors(str)
 
@@ -104,58 +100,58 @@ function splitAndColorize(c, partLength, str) {
     if (strToColorize.length === 1) {
       color = colors[Math.abs(n - 1) % colors.length]
     }
-    strBuilder.push(c[color](strToColorize))
+    strBuilder.push(styleText(color, strToColorize))
   }
 
   return strBuilder.join('')
 }
 
-function formatNodeId(c, nodeId) {
+function formatNodeId(nodeId) {
   let pos = nodeId.lastIndexOf(':')
   if (pos === -1) {
     return nodeId
   } else {
     let s = nodeId.split(':')
-    let id = c.bold(s[0])
-    let random = splitAndColorize(c, 3, s[1])
+    let id = styleText('bold', s[0])
+    let random = splitAndColorize(3, s[1])
     return `${id}:${random}`
   }
 }
 
-function formatValue(c, value) {
+function formatValue(value) {
   if (typeof value === 'string') {
-    return '"' + c.bold(value) + '"'
+    return '"' + styleText('bold', value) + '"'
   } else if (Array.isArray(value)) {
-    return formatArray(c, value)
+    return formatArray(value)
   } else if (typeof value === 'object' && value) {
-    return formatObject(c, value)
+    return formatObject(value)
   } else {
-    return c.bold(value)
+    return styleText('bold', `${value}`)
   }
 }
 
-function formatObject(c, obj) {
-  let items = Object.keys(obj).map(k => `${k}: ${formatValue(c, obj[k])}`)
+function formatObject(obj) {
+  let items = Object.keys(obj).map(k => `${k}: ${formatValue(obj[k])}`)
   return '{ ' + items.join(', ') + ' }'
 }
 
-function formatArray(c, array) {
-  let items = array.map(i => formatValue(c, i))
+function formatArray(array) {
+  let items = array.map(i => formatValue(i))
   return '[' + items.join(', ') + ']'
 }
 
-function formatActionId(c, id) {
+function formatActionId(id) {
   let p = id.split(' ')
   if (p.length === 1) {
     return p
   }
-  return `${c.bold(splitAndColorize(c, 4, p[0]))} ${formatNodeId(
-    c,
-    p[1]
-  )} ${c.bold(p[2])}`
+  return (
+    `${styleText('bold', splitAndColorize(4, p[0]))} ` +
+    `${formatNodeId(p[1])} ${styleText('bold', p[2])}`
+  )
 }
 
-function formatParams(c, params, parent) {
+function formatParams(params, parent) {
   let maxName = params.reduce((max, param) => {
     let name = param[0]
     return name.length > max ? name.length : max
@@ -169,30 +165,30 @@ function formatParams(c, params, parent) {
       let start = PADDING + rightPag(`${name}: `, maxName + 2)
 
       if (name === 'Node ID' || (parent === 'Meta' && name === 'server')) {
-        return start + formatNodeId(c, value)
+        return start + formatNodeId(value)
       } else if (
         parent === 'Meta' &&
         (name === 'clients' || name === 'excludeClients')
       ) {
-        return `${start}[${value.map(v => `"${formatNodeId(c, v)}"`).join()}]`
+        return `${start}[${value.map(v => `"${formatNodeId(v)}"`).join()}]`
       } else if (name === 'Action ID' || (parent === 'Meta' && name === 'id')) {
-        return start + formatActionId(c, value)
+        return start + formatActionId(value)
       } else if (Array.isArray(value)) {
-        return start + formatArray(c, value)
+        return start + formatArray(value)
       } else if (typeof value === 'object' && value) {
         let nested = Object.keys(value).map(key => [key, value[key]])
         return (
           start +
           NEXT_LINE +
           INDENT +
-          formatParams(c, nested, name)
+          formatParams(nested, name)
             .split(NEXT_LINE)
             .join(NEXT_LINE + INDENT)
         )
       } else if (typeof value === 'string' && parent) {
-        return start + '"' + c.bold(value) + '"'
+        return start + '"' + styleText('bold', value) + '"'
       } else {
-        return start + c.bold(value)
+        return start + styleText('bold', `${value}`)
       }
     })
     .join(NEXT_LINE)
@@ -212,7 +208,7 @@ function splitByLength(string, max) {
   return lines.map(i => i.trim())
 }
 
-function prettyStackTrace(c, stack, basepath) {
+function prettyStackTrace(stack, basepath) {
   return stack
     .split('\n')
     .slice(1)
@@ -220,24 +216,25 @@ function prettyStackTrace(c, stack, basepath) {
       let match = line.match(/\s+at ([^(]+) \(([^)]+)\)/)
       let isSystem = !match || !match[2].startsWith(basepath)
       if (isSystem) {
-        return c.gray(line.replace(/^\s*/, PADDING))
+        return styleText('gray', line.replace(/^\s*/, PADDING))
       } else {
         let func = match[1]
         let relative = match[2].slice(basepath.length)
         let converted = `${PADDING}at ${func} (./${relative})`
         let isDependency = match[2].includes('node_modules')
-        return isDependency ? c.gray(converted) : c.red(converted)
+        return isDependency
+          ? styleText('gray', converted)
+          : styleText('red', converted)
       }
     })
     .join(NEXT_LINE)
 }
 
-function humanFormatter(options) {
-  let c = pico.createColors(options.color)
+export default function humanFormatter(options) {
   let basepath = options.basepath
 
   return function format(record) {
-    let message = [LABELS[record.level](c, record.msg)]
+    let message = [LABELS[record.level](record.msg)]
     let params = Object.keys(record)
       .filter(key => !PARAMS_BLACKLIST[key])
       .map(key => [formatName(key), record[key]])
@@ -252,53 +249,26 @@ function humanFormatter(options) {
     }
 
     if (record.err && record.err.stack) {
-      message.push(prettyStackTrace(c, record.err.stack, basepath))
+      message.push(prettyStackTrace(record.err.stack, basepath))
     }
 
-    message.push(formatParams(c, params))
+    message.push(formatParams(params))
 
     if (record.note) {
       let note = record.note
       if (typeof note === 'string') {
-        note = note.replace(/`([^`]+)`/g, c.bold('$1'))
+        note = note.replace(/`([^`]+)`/g, styleText('bold', '$1'))
         note = [].concat(
           ...note
             .split('\n')
             .map(row => splitByLength(row, 80 - PADDING.length))
         )
       }
-      message.push(note.map(i => PADDING + c.gray(i)).join(NEXT_LINE))
+      message.push(
+        note.map(i => PADDING + styleText('gray', i)).join(NEXT_LINE)
+      )
     }
 
     return message.filter(i => i !== '').join(NEXT_LINE) + SEPARATOR
   }
 }
-
-export default async function (options) {
-  let format = humanFormatter(options)
-  let destination = pino.destination({
-    dest: options.destination || 1,
-    sync: options.sync || false
-  })
-  await once(destination, 'ready')
-  let transform = new Transform({
-    autoDestroy: true,
-    objectMode: true,
-    transform(chunk, encoding, callback) {
-      callback(null, format(chunk))
-    }
-  })
-
-  return abstractTransport(
-    source => {
-      source.pipe(transform)
-      transform.pipe(destination)
-    },
-    {
-      close(err, cb) {
-        transform.end()
-        transform.on('close', cb.bind(null, err))
-      }
-    }
-  )
-}

package/index.js

@@ -8,15 +8,7 @@ export { ALLOWED_META } from './allowed-meta/index.js'
 export { BaseServer, wasNot403 } from './base-server/index.js'
 export { Context } from './context/index.js'
 export { filterMeta } from './filter-meta/index.js'
-export {
-  del,
-  get,
-  patch,
-  post,
-  put,
-  request,
-  ResponseError
-} from './request/index.js'
+export { ResponseError } from './request/index.js'
 export { Server } from './server/index.js'
 export { TestClient } from './test-client/index.js'
 export { TestServer } from './test-server/index.js'

package/options-loader/index.js

@@ -1,5 +1,6 @@
-import dotenv from 'dotenv'
-import pico from 'picocolors'
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { styleText } from 'node:util'
 
 export function loadOptions(spec, process, env) {
   let rawCliArgs = gatherCliArgs(process.argv)
@@ -18,7 +19,7 @@ export function loadOptions(spec, process, env) {
   }
 
   let cliArgs = parseValues(spec, mapArgs(rawCliArgs, namesMap))
-  let dotenvArgs = parseEnvArgs(env)
+  let dotenvArgs = loadEnv(env)
   if (dotenvArgs) {
     dotenvArgs = Object.fromEntries(
       Object.entries(dotenvArgs).filter(([key]) =>
@@ -72,17 +73,38 @@ function parseValues(spec, args) {
       parsed[key] = parsingResult[1]
     } else {
       throw Error(
-        `Failed to parse ${pico.bold(key)} argument value. \n${
+        `Failed to parse ${styleText('bold', key)} argument value. \n` +
           parsingResult[0]
-        }`
       )
     }
   }
   return parsed
 }
 
-function parseEnvArgs(file) {
-  return dotenv.config(file).parsed
+function loadEnv(file) {
+  if (!file || !existsSync(file)) {
+    file = join(process.cwd(), '.env')
+    if (!existsSync(file)) return undefined
+  }
+  let result = {}
+  let lines
+  try {
+    lines = readFileSync(file, 'utf8').split('\n')
+  } catch {
+    /* c8 ignore next 2 */
+    return undefined
+  }
+  for (let line of lines) {
+    if (line.trim().startsWith('#') || !line.includes('=')) {
+      continue
+    }
+    let [key, ...valueParts] = line.split('=')
+    result[key] = valueParts
+      .join('=')
+      .trim()
+      .replace(/(^"|"$|^'|'$)/g, '')
+  }
+  return result
 }
 
 function mapArgs(parsedCliArgs, argsSpec) {
@@ -106,8 +128,9 @@ function composeHelp(spec, argv) {
   let nameColumnLength = Math.max(...options.map(it => it.full.length))
   let envColumnLength = Math.max(...options.map(it => it.env.length))
 
-  let composeName = name => pico.yellow(name.padEnd(nameColumnLength + 2))
-  let composeEnv = env => pico.cyan(env.padEnd(envColumnLength + 2))
+  let composeName = name =>
+    styleText('yellow', name.padEnd(nameColumnLength + 2))
+  let composeEnv = env => styleText('cyan', env.padEnd(envColumnLength + 2))
   let composeOptionHelp = option => {
     return (
       composeName(option.full) + composeEnv(option.env) + option.description
@@ -120,7 +143,7 @@ function composeHelp(spec, argv) {
     let lastPart = pathParts[pathParts.length - 1]
     examples = [
       '',
-      pico.bold('Examples:'),
+      styleText('bold', 'Examples:'),
       ...spec.examples.map(i => i.replace('$0', lastPart))
     ]
   }
@@ -128,7 +151,7 @@ function composeHelp(spec, argv) {
   return [
     'Start Logux Server',
     '',
-    pico.bold('Options:'),
+    styleText('bold', 'Options:'),
     ...options.map(option => composeOptionHelp(option)),
     ...examples
   ].join('\n')
@@ -157,7 +180,8 @@ export function oneOf(options, rawValue) {
   if (!options.includes(rawValue)) {
     let opt = JSON.stringify(options)
     return [
-      `Expected ${pico.green('one of ' + opt)}, got ${pico.red(rawValue)}`,
+      `Expected ${styleText('green', 'one of ' + opt)}, ` +
+        `got ${styleText('red', `${rawValue}`)}`,
       null
     ]
   } else {
@@ -168,7 +192,11 @@ export function oneOf(options, rawValue) {
 export function number(rawValue) {
   let parsed = Number.parseInt(rawValue, 10)
   if (Number.isNaN(parsed)) {
-    return [`Expected ${pico.green('number')}, got ${pico.red(rawValue)}`, null]
+    return [
+      `Expected ${styleText('green', 'number')}, ` +
+        `got ${styleText('red', `${rawValue}`)}`,
+      null
+    ]
   } else {
     return [null, parsed]
   }
@@ -176,7 +204,11 @@ export function number(rawValue) {
 
 export function string(rawValue) {
   if (typeof rawValue !== 'string') {
-    return [`Expected ${pico.green('string')}, got ${pico.red(rawValue)}`, null]
+    return [
+      `Expected ${styleText('green', 'string')}, ` +
+        `got ${styleText('red', `${rawValue}`)}`,
+      null
+    ]
   } else {
     return [null, rawValue]
   }

package/options-loader/index.test.js

@@ -1,3 +1,5 @@
+import '../test/force-colors.js'
+
 import { resolve } from 'node:path'
 import { describe, expect, it } from 'vitest'
 
@@ -73,9 +75,7 @@ describe('loadOptions', () => {
         }
       },
       fakeProcess([], {}),
-      {
-        path: resolve(process.cwd(), 'options-loader/test.env')
-      }
+      resolve(process.cwd(), 'options-loader/test.env')
     )
 
     expect(options.port).toEqual(31337)

package/options-loader/test.env

@@ -1,2 +1,4 @@
+# Comment
+
 DATABASE_URL=postgresql://localhost/logux
 LOGUX_PORT=31337

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@logux/server",
-  "version": "0.13.1",
-  "description": "Build own Logux server or make proxy between WebSocket and HTTP backend on any language",
+  "version": "0.14.0",
+  "description": "Build own Logux server",
   "keywords": [
     "logux",
     "server",
@@ -18,7 +18,7 @@
   "homepage": "https://logux.org/",
   "repository": "logux/server",
   "engines": {
-    "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+    "node": "^20.0.0 || >=22.0.0"
   },
   "type": "module",
   "types": "./index.d.ts",
@@ -27,23 +27,14 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@logux/actions": "^0.4.0",
-    "@logux/core": "^0.9.0",
-    "JSONStream": "^1.3.5",
-    "cookie": "^0.7.1",
-    "dotenv": "^16.4.5",
-    "fast-glob": "^3.3.2",
-    "fastq": "^1.17.1",
-    "nanoevents": "^9.0.0",
-    "nanoid": "^5.0.7",
-    "netmask": "^2.0.2",
-    "node-fetch": "^3.3.2",
-    "picocolors": "^1.0.1",
-    "pino": "9.3.2",
-    "pino-abstract-transport": "^1.2.0",
-    "semver": "^7.6.3",
-    "strip-ansi": "^7.1.0",
+    "@logux/actions": "^0.5.0",
+    "@logux/core": "^0.10.0",
+    "cookie": "^1.0.2",
+    "fastq": "^1.19.1",
+    "nanoevents": "^9.1.0",
+    "nanoid": "^5.1.5",
+    "tinyglobby": "^0.2.14",
     "url-pattern": "^1.0.3",
-    "ws": "^8.18.0"
+    "ws": "^8.18.3"
   }
 }

package/request/index.d.ts

@@ -1,6 +1,3 @@
-import type { RequestInit } from 'node-fetch'
-import type fetch from 'node-fetch'
-
 /**
  * Throwing this error in `accessAndProcess` or `accessAndLoad`
  * will deny the action.
@@ -9,100 +6,5 @@ export class ResponseError extends Error {
   name: 'ResponseError'
   statusCode: number
 
-  constructor(
-    statusCode: number,
-    url: string,
-    opts: RequestInit,
-    response: string
-  )
+  constructor(statusCode: number, url: string)
 }
-
-/**
- * Syntax sugar around `node-fetch`, which throws {@link ResponseError}
- * on non-2xx response.
- *
- * @param url Resource URL.
- * @param opts `fetch()` options.
- * @param fetcher A way to replace `fetch()` for tests.
- */
-export function request<Body = any>(
-  url: string,
-  opts?: RequestInit,
-  fetcher?: typeof fetch
-): Body
-
-/**
- * Syntax sugar for `GET` requests by `node-fetch`, throwing
- * {@link ResponseError} on non-2xx response and parsing JSON response.
- *
- * ```js
- * import { get } from '@logux/server'
- *
- * let user = get(url)
- * ```
- *
- * @param url Resource URL.
- * @param opts `fetch()` options.
- * @param fetcher A way to replace `fetch()` for tests.
- */
-export function get<Body = any>(
-  url: string,
-  opts?: Omit<RequestInit, 'method'>,
-  fetcher?: typeof fetch
-): Body
-
-/**
- * Syntax sugar for `POST` requests by `node-fetch`, throwing
- * {@link ResponseError} on non-2xx response.
- *
- * @param url Resource URL.
- * @param opts `fetch()` options.
- * @param fetcher A way to replace `fetch()` for tests.
- */
-export function post<Body = any>(
-  url: string,
-  opts?: Omit<RequestInit, 'method'>,
-  fetcher?: typeof fetch
-): Body
-
-/**
- * Syntax sugar for `PUT` requests by `node-fetch`, throwing
- * {@link ResponseError} on non-2xx response and parsing JSON response.
- *
- * @param url Resource URL.
- * @param opts `fetch()` options.
- * @param fetcher A way to replace `fetch()` for tests.
- */
-export function put<Body = any>(
-  url: string,
-  opts?: Omit<RequestInit, 'method'>,
-  fetcher?: typeof fetch
-): Body
-
-/**
- * Syntax sugar for `PATCH` requests by `node-fetch`, throwing
- * {@link ResponseError} on non-2xx response and parsing JSON response.
- *
- * @param url Resource URL.
- * @param opts `fetch()` options.
- * @param fetcher A way to replace `fetch()` for tests.
- */
-export function patch<Body = any>(
-  url: string,
-  opts?: Omit<RequestInit, 'method'>,
-  fetcher?: typeof fetch
-): Body
-
-/**
- * Syntax sugar for `DELETE` requests by `node-fetch`, throwing
- * {@link ResponseError} on non-2xx response and parsing JSON response.
- *
- * @param url Resource URL.
- * @param opts `fetch()` options.
- * @param fetcher A way to replace `fetch()` for tests.
- */
-export function del<Body = any>(
-  url: string,
-  opts?: Omit<RequestInit, 'method'>,
-  fetcher?: typeof fetch
-): Body

package/request/index.js

@@ -1,45 +1,7 @@
-import fetch from 'node-fetch'
-
-function argsToString(url, opts, response) {
-  let { method, ...other } = opts
-  return `${method || 'GET'} ${url} ${JSON.stringify(other)} ${response}`
-}
-
 export class ResponseError extends Error {
-  constructor(statusCode, url, opts, response) {
-    super(`${statusCode} response on ${argsToString(url, opts, response)}`)
+  constructor(statusCode, url) {
+    super(`${statusCode} response on ${url}`)
     this.name = 'ResponseError'
     this.statusCode = statusCode
   }
 }
-
-export async function request(url, opts = {}, fetcher = fetch) {
-  let response = await fetcher(url, opts)
-  if (response.status === 204) {
-    return undefined
-  } else if (response.status >= 200 && response.status <= 299) {
-    return response.json()
-  } else {
-    throw new ResponseError(response.status, url, opts, await response.text())
-  }
-}
-
-export function get(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'GET' }, fetcher)
-}
-
-export function post(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'POST' }, fetcher)
-}
-
-export function put(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'PUT' }, fetcher)
-}
-
-export function patch(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'PATCH' }, fetcher)
-}
-
-export function del(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'DELETE' }, fetcher)
-}