@logux/server 0.12.2 → 0.12.4

package/server/index.js

@@ -1,80 +1,60 @@
+import glob from 'fast-glob'
 import { join, relative } from 'path'
 import pico from 'picocolors'
-import glob from 'fast-glob'
 
-import { createReporter } from '../create-reporter/index.js'
 import { BaseServer } from '../base-server/index.js'
-import { loadOptions, oneOf, number } from '../options-loader/index.js'
+import { createReporter } from '../create-reporter/index.js'
+import { loadOptions, number, oneOf } from '../options-loader/index.js'
 
 let cliOptionsSpec = {
+  envPrefix: 'LOGUX',
+  examples: [
+    '$0 --port 31337 --host 127.0.0.1',
+    'LOGUX_PORT=1337 LOGUX_HOST=127.0.0.1 $0'
+  ],
   options: {
+    backend: {
+      description: 'Backend to process actions'
+    },
+    cert: {
+      description: 'Path to SSL certificate'
+    },
+    controlMask: {
+      description: 'CIDR masks of control servers'
+    },
+    controlSecret: {
+      description: 'Secret to control Logux server'
+    },
     host: {
       alias: 'h',
       description: 'Host to bind server'
     },
-    port: {
-      alias: 'p',
-      description: 'Port to bind server',
-      parse: number
-    },
     key: {
       description: 'Path to SSL key'
     },
-    cert: {
-      description: 'Path to SSL certificate'
-    },
-    supports: {
-      description: 'Range of supported client subprotocols'
-    },
-    subprotocol: {
-      description: 'Server subprotocol'
-    },
     logger: {
       alias: 'l',
       description: 'Logger type',
       parse: value => oneOf(['human', 'json'], value)
     },
-    backend: {
-      description: 'Backend to process actions'
-    },
-    controlSecret: {
-      description: 'Secret to control Logux server'
-    },
-    controlMask: {
-      description: 'CIDR masks of control servers'
+    port: {
+      alias: 'p',
+      description: 'Port to bind server',
+      parse: number
     },
     redis: {
       description: 'Redis URL for Logux Server Pro scaling'
+    },
+    subprotocol: {
+      description: 'Server subprotocol'
+    },
+    supports: {
+      description: 'Range of supported client subprotocols'
     }
-  },
-  envPrefix: 'LOGUX',
-  examples: [
-    '$0 --port 31337 --host 127.0.0.1',
-    'LOGUX_PORT=1337 LOGUX_HOST=127.0.0.1 $0'
-  ]
+  }
 }
 
 export class Server extends BaseServer {
-  static loadOptions(process, defaults) {
-    let [help, options] = loadOptions(
-      cliOptionsSpec,
-      process,
-      defaults.root ? { path: join(defaults.root, '.env') } : undefined
-    )
-    if (help) {
-      process.stdout.write(help + '\n')
-      return process.exit(0)
-    }
-    try {
-      return Object.assign(defaults, options)
-    } catch (e) {
-      process.stderr.write(
-        `${pico.bgRed(pico.black(' FATAL '))} ${e.message}\n`
-      )
-      return process.exit(1)
-    }
-  }
-
   constructor(opts = {}) {
     if (!opts.logger) {
       opts.logger = 'human'
@@ -122,11 +102,22 @@ export class Server extends BaseServer {
     })
   }
 
-  async listen(...args) {
+  static loadOptions(process, defaults) {
+    let [help, options] = loadOptions(
+      cliOptionsSpec,
+      process,
+      defaults.root ? { path: join(defaults.root, '.env') } : undefined
+    )
+    if (help) {
+      process.stdout.write(help + '\n')
+      return process.exit(0)
+    }
     try {
-      return BaseServer.prototype.listen.apply(this, args)
-    } catch (err) {
-      this.emitter.emit('report', 'error', { err })
+      return Object.assign(defaults, options)
+    } catch (e) {
+      process.stderr.write(
+        `${pico.bgRed(pico.black(' FATAL '))} ${e.message}\n`
+      )
       return process.exit(1)
     }
   }
@@ -135,8 +126,8 @@ export class Server extends BaseServer {
     files = ['modules/*/index.js', 'modules/*.js', '!**/*.{test,spec}.js']
   ) {
     let matches = await glob(files, {
-      cwd: this.options.root,
       absolute: true,
+      cwd: this.options.root,
       onlyFiles: true
     })
 
@@ -158,4 +149,13 @@ export class Server extends BaseServer {
       })
     )
   }
+
+  async listen(...args) {
+    try {
+      return BaseServer.prototype.listen.apply(this, args)
+    } catch (err) {
+      this.emitter.emit('report', 'error', { err })
+      return process.exit(1)
+    }
+  }
 }

package/server-client/index.d.ts

@@ -1,6 +1,6 @@
-import { ServerConnection, ServerNode } from '@logux/core'
+import type { ServerConnection, ServerNode } from '@logux/core'
 
-import { BaseServer } from '../base-server/index.js'
+import type { BaseServer } from '../base-server/index.js'
 
 /**
  * Logux client connected to server.
@@ -10,24 +10,11 @@ import { BaseServer } from '../base-server/index.js'
  * ```
  */
 export class ServerClient {
-  /**
-   * @param app The server.
-   * @param connection The Logux connection.
-   * @param key Client number used as `app.connected` key.
-   */
-  constructor(app: BaseServer, connection: ServerConnection, key: number)
-
   /**
    * Server, which received client.
    */
   app: BaseServer
 
-  /**
-   * User ID. It will be filled from client’s node ID.
-   * It will be undefined before correct authentication.
-   */
-  userId?: string
-
   /**
    * Unique persistence machine ID.
    * It will be undefined before correct authentication.
@@ -35,28 +22,22 @@ export class ServerClient {
   clientId?: string
 
   /**
-   * Unique node ID.
-   * It will be undefined before correct authentication.
-   */
-  nodeId?: string
-
-  /**
-   * Does server process some action from client.
+   * The Logux wrapper to WebSocket connection.
    *
    * ```js
-   * console.log('Clients in processing:', clients.map(i => i.processing))
+   * console.log(client.connection.ws.upgradeReq.headers)
    * ```
    */
-  processing: boolean
+  connection: ServerConnection
 
   /**
-   * The Logux wrapper to WebSocket connection.
+   * HTTP headers of WS connection.
    *
    * ```js
-   * console.log(client.connection.ws.upgradeReq.headers)
+   * client.httpHeaders['User-Agent']
    * ```
    */
-  connection: ServerConnection
+  httpHeaders: { [name: string]: string }
 
   /**
    * Client number used as `app.connected` key.
@@ -70,31 +51,55 @@ export class ServerClient {
   key: string
 
   /**
-   * Client IP address.
+   * Node instance to synchronize logs.
    *
    * ```js
-   * const clientCity = detectLocation(client.remoteAddress)
+   * if (client.node.state === 'synchronized')
    * ```
    */
-  remoteAddress: string
+  node: ServerNode
 
   /**
-   * HTTP headers of WS connection.
+   * Unique node ID.
+   * It will be undefined before correct authentication.
+   */
+  nodeId?: string
+
+  /**
+   * Does server process some action from client.
    *
    * ```js
-   * client.httpHeaders['User-Agent']
+   * console.log('Clients in processing:', clients.map(i => i.processing))
    * ```
    */
-  httpHeaders: { [name: string]: string }
+  processing: boolean
 
   /**
-   * Node instance to synchronize logs.
+   * Client IP address.
    *
    * ```js
-   * if (client.node.state === 'synchronized')
+   * const clientCity = detectLocation(client.remoteAddress)
    * ```
    */
-  node: ServerNode
+  remoteAddress: string
+
+  /**
+   * User ID. It will be filled from client’s node ID.
+   * It will be undefined before correct authentication.
+   */
+  userId?: string
+
+  /**
+   * @param app The server.
+   * @param connection The Logux connection.
+   * @param key Client number used as `app.connected` key.
+   */
+  constructor(app: BaseServer, connection: ServerConnection, key: number)
+
+  /**
+   * Disconnect client.
+   */
+  destroy(): void
 
   /**
    * Check client subprotocol version. It uses `semver` npm package
@@ -110,9 +115,4 @@ export class ServerClient {
    * @returns Is version satisfies requirements.
    */
   isSubprotocol(range: string): boolean
-
-  /**
-   * Disconnect client.
-   */
-  destroy(): void
 }

package/server-client/index.js

@@ -2,15 +2,15 @@ import { LoguxError, parseId } from '@logux/core'
 import cookie from 'cookie'
 import semver from 'semver'
 
-import { FilteredNode } from '../filtered-node/index.js'
 import { ALLOWED_META } from '../allowed-meta/index.js'
 import { filterMeta } from '../filter-meta/index.js'
+import { FilteredNode } from '../filtered-node/index.js'
 
 function reportDetails(client) {
   return {
     connectionId: client.key,
-    subprotocol: client.node.remoteSubprotocol,
-    nodeId: client.nodeId
+    nodeId: client.nodeId,
+    subprotocol: client.node.remoteSubprotocol
   }
 }
 
@@ -32,13 +32,13 @@ export class ServerClient {
     }
 
     this.node = new FilteredNode(this, app.nodeId, app.log, connection, {
-      subprotocol: app.options.subprotocol,
+      auth: this.auth.bind(this),
       inFilter: this.filter.bind(this),
-      timeout: app.options.timeout,
-      outMap: this.outMap.bind(this),
       inMap: this.inMap.bind(this),
+      outMap: this.outMap.bind(this),
       ping: app.options.ping,
-      auth: this.auth.bind(this)
+      subprotocol: app.options.subprotocol,
+      timeout: app.options.timeout
     })
     if (this.app.env === 'development') {
       this.node.setLocalHeaders({ env: 'development' })
@@ -61,44 +61,6 @@ export class ServerClient {
     this.app.emitter.emit('connected', this)
   }
 
-  isSubprotocol(range) {
-    return semver.satisfies(this.node.remoteSubprotocol, range)
-  }
-
-  destroy() {
-    this.destroyed = true
-    this.node.destroy()
-    if (this.userId) {
-      let users = this.app.userIds.get(this.userId)
-      if (users) {
-        users = users.filter(i => i !== this)
-        if (users.length === 0) {
-          this.app.userIds.delete(this.userId)
-        } else {
-          this.app.userIds.set(this.userId, users)
-        }
-      }
-    }
-    if (this.clientId) {
-      this.app.clientIds.delete(this.clientId)
-      this.app.nodeIds.delete(this.nodeId)
-
-      for (let channel in this.app.subscribers) {
-        let subscriber = this.app.subscribers[channel][this.nodeId]
-        if (subscriber) {
-          let action = { type: 'logux/unsubscribe', channel }
-          let actionId = this.app.log.generateId()
-          let meta = { id: actionId, time: parseInt(actionId), reasons: [] }
-          this.app.performUnsubscribe(this.nodeId, action, meta)
-        }
-      }
-    }
-    if (!this.app.destroying) {
-      this.app.emitter.emit('disconnected', this)
-    }
-    this.app.connected.delete(this.key)
-  }
-
   async auth(nodeId, token) {
     this.nodeId = nodeId
     let { clientId, userId } = parseId(nodeId)
@@ -129,11 +91,11 @@ export class ServerClient {
     let result
     try {
       result = await this.app.authenticator({
-        headers: this.node.remoteHeaders,
-        cookie: cookie.parse(headers.cookie || ''),
-        userId: this.userId,
         client: this,
-        token
+        cookie: cookie.parse(headers.cookie || ''),
+        headers: this.node.remoteHeaders,
+        token,
+        userId: this.userId
       })
     } catch (e) {
       if (e.name === 'LoguxError') {
@@ -177,15 +139,46 @@ export class ServerClient {
     return result
   }
 
-  async outMap(action, meta) {
-    return [action, filterMeta(meta)]
+  denyBack(action, meta) {
+    this.app.emitter.emit('report', 'denied', { actionId: meta.id })
+    let [undoAction, undoMeta] = this.app.buildUndo(action, meta, 'denied')
+    undoMeta.clients = (undoMeta.clients || []).concat([this.clientId])
+    this.app.log.add(undoAction, undoMeta)
+    this.app.debugActionError(meta, `Action "${meta.id}" was denied`)
   }
 
-  async inMap(action, meta) {
-    if (!meta.subprotocol) {
-      meta.subprotocol = this.node.remoteSubprotocol
+  destroy() {
+    this.destroyed = true
+    this.node.destroy()
+    if (this.userId) {
+      let users = this.app.userIds.get(this.userId)
+      if (users) {
+        users = users.filter(i => i !== this)
+        if (users.length === 0) {
+          this.app.userIds.delete(this.userId)
+        } else {
+          this.app.userIds.set(this.userId, users)
+        }
+      }
     }
-    return [action, meta]
+    if (this.clientId) {
+      this.app.clientIds.delete(this.clientId)
+      this.app.nodeIds.delete(this.nodeId)
+
+      for (let channel in this.app.subscribers) {
+        let subscriber = this.app.subscribers[channel][this.nodeId]
+        if (subscriber) {
+          let action = { channel, type: 'logux/unsubscribe' }
+          let actionId = this.app.log.generateId()
+          let meta = { id: actionId, reasons: [], time: parseInt(actionId) }
+          this.app.performUnsubscribe(this.nodeId, action, meta)
+        }
+      }
+    }
+    if (!this.app.destroying) {
+      this.app.emitter.emit('disconnected', this)
+    }
+    this.app.connected.delete(this.key)
   }
 
   async filter(action, meta) {
@@ -231,11 +224,18 @@ export class ServerClient {
     }
   }
 
-  denyBack(action, meta) {
-    this.app.emitter.emit('report', 'denied', { actionId: meta.id })
-    let [undoAction, undoMeta] = this.app.buildUndo(action, meta, 'denied')
-    undoMeta.clients = (undoMeta.clients || []).concat([this.clientId])
-    this.app.log.add(undoAction, undoMeta)
-    this.app.debugActionError(meta, `Action "${meta.id}" was denied`)
+  async inMap(action, meta) {
+    if (!meta.subprotocol) {
+      meta.subprotocol = this.node.remoteSubprotocol
+    }
+    return [action, meta]
+  }
+
+  isSubprotocol(range) {
+    return semver.satisfies(this.node.remoteSubprotocol, range)
+  }
+
+  async outMap(action, meta) {
+    return [action, filterMeta(meta)]
   }
 }

package/test-client/index.d.ts

@@ -1,18 +1,18 @@
-import { LoguxSubscribeAction, LoguxUnsubscribeAction } from '@logux/actions'
-import { Action, AnyAction, TestLog, TestPair } from '@logux/core'
+import type { LoguxSubscribeAction, LoguxUnsubscribeAction } from '@logux/actions'
+import type { Action, AnyAction, TestLog, TestPair } from '@logux/core'
 
-import { ServerMeta } from '../base-server/index.js'
-import { TestServer } from '../test-server/index.js'
+import type { ServerMeta } from '../base-server/index.js'
+import type { TestServer } from '../test-server/index.js'
 
 export class LoguxActionError extends Error {
   action: Action
 }
 
 export interface TestClientOptions {
+  cookie?: object
+  headers?: object
   httpHeaders?: { [key: string]: string }
   subprotocol?: string
-  headers?: object
-  cookie?: object
   token?: string
 }
 
@@ -59,11 +59,14 @@ export interface TestClientOptions {
  */
 export class TestClient {
   /**
-   * @param server Test server.
-   * @param userId User ID.
-   * @param opts Other options.
+   * Client’s ID.
+   *
+   * ```js
+   * let client = new TestClient(server, '10')
+   * client.clientId //=> '10:1'
+   * ```
    */
-  constructor(server: TestServer, userId: string, opts?: TestClientOptions)
+  clientId: string
 
   /**
    * Client’s log with extra methods to check actions inside.
@@ -85,14 +88,13 @@ export class TestClient {
   nodeId: string
 
   /**
-   * Client’s ID.
+   * Connection channel between client and server to track sent messages.
    *
    * ```js
-   * let client = new TestClient(server, '10')
-   * client.clientId //=> '10:1'
+   * console.log(client.pair.leftSent)
    * ```
    */
-  clientId: string
+  pair: TestPair
 
   /**
    * User ID.
@@ -105,13 +107,27 @@ export class TestClient {
   userId: string
 
   /**
-   * Connection channel between client and server to track sent messages.
+   * @param server Test server.
+   * @param userId User ID.
+   * @param opts Other options.
+   */
+  constructor(server: TestServer, userId: string, opts?: TestClientOptions)
+
+  /**
+   * Collect actions added by server and other clients during the `test` call.
    *
    * ```js
-   * console.log(client.pair.leftSent)
+   * let answers = await client.collect(async () => {
+   *   client.log.add({ type: 'pay' })
+   *   await delay(10)
+   * })
+   * expect(actions).toEqual([{ type: 'paid' }])
    * ```
+   *
+   * @param test Function, where do you expect action will be received
+   * @returns Promise with all received actions
    */
-  pair: TestPair
+  collect(test: () => Promise<any>): Promise<Action[]>
 
   /**
    * Connect to test server.
@@ -137,22 +153,6 @@ export class TestClient {
    */
   disconnect(): Promise<void>
 
-  /**
-   * Collect actions added by server and other clients during the `test` call.
-   *
-   * ```js
-   * let answers = await client.collect(async () => {
-   *   client.log.add({ type: 'pay' })
-   *   await delay(10)
-   * })
-   * expect(actions).toEqual([{ type: 'paid' }])
-   * ```
-   *
-   * @param test Function, where do you expect action will be received
-   * @returns Promise with all received actions
-   */
-  collect(test: () => Promise<any>): Promise<Action[]>
-
   /**
    * Send action to the sever and collect all response actions.
    *
@@ -168,6 +168,21 @@ export class TestClient {
    */
   process(action: AnyAction, meta?: Partial<ServerMeta>): Promise<Action[]>
 
+  /**
+   * Collect actions received from server during the `test` call.
+   *
+   * ```js
+   * let answers = await client1.received(async () => {
+   *   await client2.process({ type: 'resend' })
+   * })
+   * expect(actions).toEqual([{ type: 'local' }])
+   * ```
+   *
+   * @param test Function, where do you expect action will be received
+   * @returns Promise with all received actions
+   */
+  received(test: () => any | Promise<any>): Promise<Action[]>
+
   /**
    * Subscribe to the channel and collect all actions dunring the subscription.
    *
@@ -184,7 +199,7 @@ export class TestClient {
    * @returns Promise with all actions from the server.
    */
   subscribe(
-    channel: string | LoguxSubscribeAction,
+    channel: LoguxSubscribeAction | string,
     filter?: object,
     since?: { id: string; time: number }
   ): Promise<Action[]>
@@ -201,22 +216,7 @@ export class TestClient {
    * @returns Promise until server will remove client from subscribers.
    */
   unsubscribe(
-    channel: string | LoguxUnsubscribeAction,
+    channel: LoguxUnsubscribeAction | string,
     filter?: object
   ): Promise<Action[]>
-
-  /**
-   * Collect actions received from server during the `test` call.
-   *
-   * ```js
-   * let answers = await client1.received(async () => {
-   *   await client2.process({ type: 'resend' })
-   * })
-   * expect(actions).toEqual([{ type: 'local' }])
-   * ```
-   *
-   * @param test Function, where do you expect action will be received
-   * @returns Promise with all received actions
-   */
-  received(test: () => Promise<any> | any): Promise<Action[]>
 }