@logux/server 0.10.1 → 0.10.5

package/base-server/index.d.ts

@@ -247,9 +247,11 @@ interface Authorizer<
   Data extends object,
   Headers extends object
 > {
-  (ctx: Context<Data, Headers>, action: TypeAction, meta: ServerMeta):
-    | boolean
-    | Promise<boolean>
+  (
+    ctx: Context<Data, Headers>,
+    action: Readonly<TypeAction>,
+    meta: Readonly<ServerMeta>
+  ): boolean | Promise<boolean>
 }
 
 /**
@@ -265,9 +267,11 @@ interface Resender<
   Data extends object,
   Headers extends object
 > {
-  (ctx: Context<Data, Headers>, action: TypeAction, meta: ServerMeta):
-    | Resend
-    | Promise<Resend>
+  (
+    ctx: Context<Data, Headers>,
+    action: Readonly<TypeAction>,
+    meta: Readonly<ServerMeta>
+  ): Resend | Promise<Resend>
 }
 
 /**
@@ -285,8 +289,8 @@ interface Processor<
 > {
   (
     ctx: Context<Data, Headers>,
-    action: TypeAction,
-    meta: ServerMeta
+    action: Readonly<TypeAction>,
+    meta: Readonly<ServerMeta>
   ): void | Promise<void>
 }
 
@@ -303,7 +307,11 @@ interface ActionFinally<
   Data extends object,
   Headers extends object
 > {
-  (ctx: Context<Data, Headers>, action: TypeAction, meta: ServerMeta): void
+  (
+    ctx: Context<Data, Headers>,
+    action: Readonly<TypeAction>,
+    meta: Readonly<ServerMeta>
+  ): void
 }
 
 /**
@@ -315,7 +323,11 @@ interface ActionFinally<
  * @returns Should action be sent to client.
  */
 interface ChannelFilter<Headers extends object> {
-  (ctx: Context<{}, Headers>, action: Action, meta: ServerMeta): boolean
+  (
+    ctx: Context<{}, Headers>,
+    action: Readonly<Action>,
+    meta: Readonly<ServerMeta>
+  ): boolean
 }
 
 /**
@@ -334,8 +346,8 @@ interface ChannelAuthorizer<
 > {
   (
     ctx: ChannelContext<Data, ChannelParams, Headers>,
-    action: SubscribeAction,
-    meta: ServerMeta
+    action: Readonly<SubscribeAction>,
+    meta: Readonly<ServerMeta>
   ): boolean | Promise<boolean>
 }
 
@@ -355,8 +367,8 @@ interface FilterCreator<
 > {
   (
     ctx: ChannelContext<Data, ChannelParams, Headers>,
-    action: SubscribeAction,
-    meta: ServerMeta
+    action: Readonly<SubscribeAction>,
+    meta: Readonly<ServerMeta>
   ): Promise<ChannelFilter<Headers>> | ChannelFilter<Headers> | void
 }
 
@@ -376,8 +388,8 @@ interface ChannelLoader<
 > {
   (
     ctx: ChannelContext<Data, ChannelParams, Headers>,
-    action: SubscribeAction,
-    meta: ServerMeta
+    action: Readonly<SubscribeAction>,
+    meta: Readonly<ServerMeta>
   ): SendBackActions | Promise<SendBackActions>
 }
 
@@ -397,8 +409,8 @@ interface ChannelFinally<
 > {
   (
     ctx: ChannelContext<Data, ChannelParams, Headers>,
-    action: SubscribeAction,
-    meta: ServerMeta
+    action: Readonly<SubscribeAction>,
+    meta: Readonly<ServerMeta>
   ): void
 }
 
@@ -418,7 +430,7 @@ interface ChannelUnsubscribe<
   (
     ctx: ChannelContext<Data, ChannelParams, Headers>,
     action: LoguxUnsubscribeAction,
-    meta: ServerMeta
+    meta: Readonly<ServerMeta>
   ): void
 }
 
@@ -464,8 +476,8 @@ type ChannelCallbacks<
 }
 
 interface ActionReporter {
-  action: Action
-  meta: ServerMeta
+  action: Readonly<Action>
+  meta: Readonly<ServerMeta>
 }
 
 interface SubscriptionReporter {
@@ -585,7 +597,7 @@ interface GetProcessor {
 }
 
 interface PostProcessor {
-  isValid(command: object): false
+  isValid(command: object): boolean
   command(command: object, request: object): Promise<void>
 }
 
@@ -817,7 +829,7 @@ export class BaseServer<
    */
   on(
     event: 'error',
-    listener: (err: Error, action: Action, meta: ServerMeta) => void
+    listener: (err: Error, action: Action, meta: Readonly<ServerMeta>) => void
   ): Unsubscribe
 
   /**
@@ -843,7 +855,16 @@ export class BaseServer<
    * @param listener Action listener.
    */
   on(
-    event: 'preadd' | 'add' | 'clean' | 'backendSent',
+    event: 'add' | 'clean' | 'backendSent',
+    listener: (action: Action, meta: Readonly<ServerMeta>) => void
+  ): Unsubscribe
+
+  /**
+   * @param event The event name.
+   * @param listener Action listener.
+   */
+  on(
+    event: 'preadd',
     listener: (action: Action, meta: ServerMeta) => void
   ): Unsubscribe
 
@@ -855,7 +876,7 @@ export class BaseServer<
     event: 'processed' | 'backendGranted' | 'backendProcessed',
     listener: (
       action: Action,
-      meta: ServerMeta,
+      meta: Readonly<ServerMeta>,
       latencyMilliseconds: number
     ) => void
   ): Unsubscribe
@@ -868,7 +889,7 @@ export class BaseServer<
     event: 'subscribed',
     listener: (
       action: LoguxSubscribeAction,
-      meta: ServerMeta,
+      meta: Readonly<ServerMeta>,
       latencyMilliseconds: number
     ) => void
   ): Unsubscribe
@@ -879,7 +900,7 @@ export class BaseServer<
    */
   on(
     event: 'subscribing',
-    listener: (action: LoguxSubscribeAction, meta: ServerMeta) => void
+    listener: (action: LoguxSubscribeAction, meta: Readonly<ServerMeta>) => void
   ): Unsubscribe
 
   /**
@@ -888,7 +909,10 @@ export class BaseServer<
    */
   on(
     event: 'unsubscribed',
-    listener: (action: LoguxUnsubscribeAction, meta: ServerMeta) => void
+    listener: (
+      action: LoguxUnsubscribeAction,
+      meta: Readonly<ServerMeta>
+    ) => void
   ): Unsubscribe
 
   /**
@@ -1058,7 +1082,10 @@ export class BaseServer<
    * @param meta Action’s meta.
    * @returns Promise until new action will be resend to clients and processed.
    */
-  process(action: AnyAction, meta?: Partial<ServerMeta>): Promise<ServerMeta>
+  process(
+    action: AnyAction,
+    meta?: Partial<ServerMeta>
+  ): Promise<Readonly<ServerMeta>>
 
   /**
    * Undo action from client.

package/base-server/index.js

@@ -14,6 +14,7 @@ import { createHttpServer } from '../create-http-server/index.js'
 import { ServerClient } from '../server-client/index.js'
 import { Context } from '../context/index.js'
 
+const SKIP_PROCESS = Symbol('skipProcess')
 const RESEND_META = ['channels', 'users', 'clients', 'nodes']
 
 function optionError(msg) {
@@ -48,11 +49,15 @@ export async function wasNot403(cb) {
 
 function normalizeTypeCallbacks(name, callbacks) {
   if (callbacks && callbacks.accessAndProcess) {
-    callbacks.access = (...args) => {
+    callbacks.access = (ctx, ...args) => {
       return wasNot403(async () => {
-        await callbacks.accessAndProcess(...args)
+        await callbacks.accessAndProcess(ctx, ...args)
+        ctx[SKIP_PROCESS] = true
       })
     }
+    callbacks.process = async (ctx, ...args) => {
+      if (!ctx[SKIP_PROCESS]) await callbacks.accessAndProcess(ctx, ...args)
+    }
   }
   if (!callbacks || !callbacks.access) {
     throw new Error(`${name} must have access callback`)
@@ -373,12 +378,12 @@ export class BaseServer {
     if (!this.authenticator) {
       throw new Error('You must set authentication callback by server.auth()')
     }
-    this.http = await createHttpServer(this.options)
-    this.ws = new WebSocket.Server({ server: this.http })
+    this.httpServer = await createHttpServer(this.options)
+    this.ws = new WebSocket.Server({ server: this.httpServer })
     if (!this.options.server) {
       await new Promise((resolve, reject) => {
         this.ws.on('error', reject)
-        this.http.listen(this.options.port, this.options.host, resolve)
+        this.httpServer.listen(this.options.port, this.options.host, resolve)
       })
     }
     bindControlServer(this, this.httpListener)
@@ -390,12 +395,12 @@ export class BaseServer {
           this.ws.close()
         })
     )
-    if (this.http) {
+    if (this.httpServer) {
       this.unbind.push(
         () =>
           new Promise(resolve => {
-            this.http.on('close', resolve)
-            this.http.close()
+            this.httpServer.on('close', resolve)
+            this.httpServer.close()
           })
       )
     }

package/bind-control-server/index.js

@@ -18,7 +18,7 @@ function isValidBody(body) {
 
 export function bindControlServer(app, custom) {
   let masks = app.options.controlMask.split(/,\s*/).map(i => ip.cidrSubnet(i))
-  app.http.on('request', async (req, res) => {
+  app.httpServer.on('request', async (req, res) => {
     let urlString = req.url
     if (/^\/\w+%3F/.test(urlString)) urlString = decodeURIComponent(urlString)
     let reqUrl = new URL(urlString, 'http://localhost')

package/create-reporter/index.js

@@ -222,14 +222,19 @@ function createLogger(options) {
   )
 }
 
-function cleanFromKeys(obj, regexp) {
+function cleanFromKeys(obj, regexp, seen) {
   let result = {}
   for (let key in obj) {
     let v = obj[key]
     if (typeof v === 'string') {
       result[key] = v.replace(regexp, '[SECRET]')
     } else if (typeof v === 'object' && !Array.isArray(v) && v !== null) {
-      result[key] = cleanFromKeys(v, regexp)
+      if (seen.includes(v)) {
+        throw new Error('Circular reference in action')
+      }
+      seen.push(v)
+      result[key] = cleanFromKeys(v, regexp, seen)
+      seen.pop()
     } else {
       result[key] = v
     }
@@ -242,8 +247,9 @@ export function createReporter(options) {
   function reporter(type, details) {
     let report = REPORTERS[type](details)
     let level = report.level || 'info'
+    let seen = []
     reporter.logger[level](
-      cleanFromKeys(report.details || details || {}, cleanFromLog),
+      cleanFromKeys(report.details || details || {}, cleanFromLog, seen),
       report.msg.replace(cleanFromLog, '[SECRET]')
     )
   }

package/human-formatter/index.js

@@ -1,17 +1,4 @@
-import {
-  green,
-  bgGreen,
-  yellow,
-  bgYellow,
-  red,
-  bgRed,
-  black,
-  white,
-  gray,
-  dim,
-  bold,
-  options as colorette
-} from 'colorette'
+import { createColors } from 'nanocolors'
 import stripAnsi from 'strip-ansi'
 import yyyymmdd from 'yyyy-mm-dd'
 import path from 'path'
@@ -183,25 +170,8 @@ function prettyStackTrace(c, stack, basepath) {
 }
 
 export function humanFormatter(options) {
-  let c = {
-    green,
-    bgGreen,
-    yellow,
-    bgYellow,
-    red,
-    bgRed,
-    black,
-    white,
-    gray,
-    dim,
-    bold
-  }
-  this.color = true
-  if (options.color === false || !colorette.enabled) {
-    this.color = false
-    let empty = str => str
-    for (let color in c) c[color] = empty
-  }
+  let c = createColors(options.color)
+  this.color = c.isColorSupported
   let basepath = options.basepath || process.cwd()
   if (basepath.slice(-1) !== path.sep) basepath += path.sep
   this.basepath = basepath

package/options-loader/index.js

@@ -1,4 +1,4 @@
-import { bold, cyan, yellow, green, red } from 'colorette'
+import { bold, cyan, yellow, green, red } from 'nanocolors'
 import dotenv from 'dotenv'
 
 export function loadOptions(spec, process, env) {
@@ -31,11 +31,8 @@ export function loadOptions(spec, process, env) {
       key.startsWith(spec.envPrefix)
     )
   )
-  envArgs = parseValues(
-    spec,
-    mapArgs(Object.assign(envArgs, dotenvArgs), namesMap)
-  )
-  return [null, Object.assign(envArgs, cliArgs)]
+  envArgs = parseValues(spec, mapArgs({ ...envArgs, ...dotenvArgs }, namesMap))
+  return [null, { ...envArgs, ...cliArgs }]
 }
 
 function gatherCliArgs(argv) {

package/options-loader/index.test.js

@@ -0,0 +1,257 @@
+import { resolve } from 'path'
+
+import { loadOptions, oneOf, number } from './index.js'
+
+function fakeProcess(argv, env = {}) {
+  return { argv, env }
+}
+
+describe('loadOptions', () => {
+  it('returns help', () => {
+    let [help, options] = loadOptions(
+      {
+        options: {
+          port: {
+            description: 'port',
+            parse: number
+          }
+        },
+        examples: ['$0']
+      },
+      fakeProcess(['node', 'test/test.js', '--help'])
+    )
+
+    expect(help).toMatchSnapshot()
+    expect(options).toBeNull()
+  })
+
+  it('uses CLI args for options', () => {
+    let [, options] = loadOptions(
+      {
+        options: {
+          port: {
+            description: 'port',
+            parse: number
+          }
+        }
+      },
+      fakeProcess(['', '--port', '1337'])
+    )
+    expect(options.port).toEqual(1337)
+  })
+
+  it('uses env for options', () => {
+    let [, options] = loadOptions(
+      {
+        options: {
+          port: {
+            description: 'port',
+            parse: number
+          }
+        },
+        envPrefix: 'LOGUX'
+      },
+      fakeProcess([], {
+        LOGUX_PORT: '31337'
+      }),
+      {}
+    )
+
+    expect(options.port).toEqual(31337)
+  })
+
+  it('uses dotenv file for options', () => {
+    let [, options] = loadOptions(
+      {
+        options: {
+          port: {
+            description: 'port',
+            parse: number
+          }
+        },
+        envPrefix: 'LOGUX'
+      },
+      fakeProcess([], {}),
+      {
+        path: resolve(process.cwd(), 'options-loader/test.env')
+      }
+    )
+
+    expect(options.port).toEqual(31337)
+  })
+
+  it('composes correct env and CLI names for argument with complex name', () => {
+    let [, options] = loadOptions(
+      {
+        options: {
+          somePort: {
+            description: 'port',
+            parse: number
+          }
+        },
+        envPrefix: 'LOGUX'
+      },
+      fakeProcess(['--some-port', '1'], {
+        LOGUX_SOME_PORT: '1'
+      }),
+      {}
+    )
+
+    expect(options.somePort).toEqual(1)
+  })
+
+  it('uses combined options', () => {
+    let [, options] = loadOptions(
+      {
+        options: {
+          key: {
+            description: 'port'
+          },
+          cert: {
+            description: 'cert'
+          }
+        },
+        envPrefix: 'LOGUX'
+      },
+      fakeProcess(['', '--key', './key.pem'], { LOGUX_CERT: './cert.pem' })
+    )
+
+    expect(options.cert).toEqual('./cert.pem')
+    expect(options.key).toEqual('./key.pem')
+  })
+
+  it('uses arg and env in given priority', () => {
+    let optionsSpec = {
+      options: {
+        port: {
+          description: 'port',
+          parse: number
+        },
+        key: {
+          description: 'key'
+        },
+        cert: {
+          description: 'cert'
+        }
+      },
+      envPrefix: 'LOGUX'
+    }
+
+    let [, options1] = loadOptions(
+      optionsSpec,
+      fakeProcess(['', '--port', '3'], { LOGUX_PORT: '2' }),
+      undefined
+    )
+    let [, options2] = loadOptions(
+      optionsSpec,
+      fakeProcess([], { LOGUX_PORT: '2' }),
+      undefined
+    )
+
+    expect(options1.port).toEqual(3)
+    expect(options2.port).toEqual(2)
+  })
+
+  it('parses aliases', () => {
+    let [, options] = loadOptions(
+      {
+        options: {
+          port: {
+            alias: 'p',
+            description: 'port'
+          }
+        }
+      },
+      fakeProcess(['', '-p', '1'])
+    )
+    expect(options.port).toEqual('1')
+  })
+
+  it('parses multiple args', () => {
+    let [, options] = loadOptions(
+      {
+        options: {
+          port: {
+            alias: 'p',
+            description: 'port'
+          },
+          key: {
+            description: 'key'
+          }
+        }
+      },
+      fakeProcess(['', '-p', '1', '--key', '1'])
+    )
+    expect(options.port).toEqual('1')
+    expect(options.key).toEqual('1')
+  })
+
+  it('throws on missing values', () => {
+    expect(() =>
+      loadOptions(
+        {
+          options: {
+            port: {
+              description: 'port'
+            }
+          }
+        },
+        fakeProcess(['', '--port'])
+      )
+    ).toThrowErrorMatchingSnapshot()
+  })
+
+  it('throws on unknown args', () => {
+    expect(() =>
+      loadOptions(
+        {
+          options: {
+            port: {
+              description: 'port'
+            }
+          }
+        },
+        fakeProcess(['', '--unknown', '1'])
+      )
+    ).toThrowErrorMatchingSnapshot()
+  })
+
+  it('throws on unparsed args', () => {
+    expect(() =>
+      loadOptions(
+        {
+          options: {
+            port: {
+              description: 'port',
+              parse: number
+            }
+          }
+        },
+        fakeProcess(['', '--port', 'W_W'])
+      )
+    ).toThrowErrorMatchingSnapshot()
+  })
+})
+
+describe('parsers', () => {
+  describe('oneOf', () => {
+    it('should return error on invalid values', () => {
+      let result = oneOf(['1', '2'], '3')
+      expect(result[0]).toMatchSnapshot()
+    })
+    it('should return null on correct values', () => {
+      expect(oneOf(['1', '2'], '1')).toEqual([null, '1'])
+    })
+  })
+
+  describe('number', () => {
+    it('should return error on invalid values', () => {
+      let result = number('not a number')
+      expect(result[0]).toMatchSnapshot()
+    })
+    it('should return null on correct values', () => {
+      expect(number('1')).toEqual([null, 1])
+      expect(number('1why parseInt is so permissive')).toEqual([null, 1])
+    })
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logux/server",
-  "version": "0.10.1",
+  "version": "0.10.5",
   "description": "Build own Logux server or make proxy between WebSocket and HTTP backend on any language",
   "keywords": [
     "logux",
@@ -27,24 +27,24 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@logux/actions": "^0.2.0",
-    "@logux/core": "^0.7.0",
+    "@logux/actions": "^0.2.1",
+    "@logux/core": "^0.7.2",
     "@types/node-fetch": "^2.5.10",
     "JSONStream": "^1.3.5",
-    "colorette": "^1.2.2",
     "cookie": "^0.4.1",
-    "dotenv": "^9.0.2",
-    "globby": "^11.0.3",
+    "dotenv": "^10.0.0",
+    "globby": "^11.0.4",
     "ip": "^1.1.5",
-    "nanodelay": "^2.0.0",
-    "nanoevents": "^6.0.0",
-    "nanoid": "^3.1.23",
+    "nanocolors": "^0.2.12",
+    "nanodelay": "^2.0.1",
+    "nanoevents": "^6.0.1",
+    "nanoid": "^3.1.28",
     "node-fetch": "^2.6.1",
-    "pino": "^6.11.3",
+    "pino": "^6.13.3",
     "semver": "^7.3.5",
-    "strip-ansi": "^7.0.0",
+    "strip-ansi": "^7.0.1",
     "url-pattern": "^1.0.3",
-    "ws": "^7.4.5",
+    "ws": "^7.5.0",
     "yyyy-mm-dd": "^1.0.2"
   }
 }

package/server/index.js

@@ -1,6 +1,6 @@
 import { join, relative } from 'path'
 import globby from 'globby'
-import { bgRed, black } from 'colorette'
+import { bgRed, black } from 'nanocolors'
 
 import { createReporter } from '../create-reporter/index.js'
 import { BaseServer } from '../base-server/index.js'
@@ -130,7 +130,9 @@ export class Server extends BaseServer {
     }
   }
 
-  async autoloadModules(files = ['modules/*/index.js', 'modules/*.js']) {
+  async autoloadModules(
+    files = ['modules/*/index.js', 'modules/*.js', '!**/*.{test,spec}.js']
+  ) {
     let matches = await globby(files, {
       cwd: this.options.root,
       absolute: true,