@logux/server 0.12.3 → 0.12.5

package/server-client/index.d.ts

@@ -1,4 +1,5 @@
 import type { ServerConnection, ServerNode } from '@logux/core'
+
 import type { BaseServer } from '../base-server/index.js'
 
 /**
@@ -9,24 +10,11 @@ import type { 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.
@@ -34,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.
@@ -69,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
@@ -109,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,5 +1,6 @@
 import type { LoguxSubscribeAction, LoguxUnsubscribeAction } from '@logux/actions'
 import type { Action, AnyAction, TestLog, TestPair } from '@logux/core'
+
 import type { ServerMeta } from '../base-server/index.js'
 import type { TestServer } from '../test-server/index.js'
 
@@ -8,10 +9,10 @@ export class LoguxActionError extends Error {
 }
 
 export interface TestClientOptions {
+  cookie?: object
+  headers?: object
   httpHeaders?: { [key: string]: string }
   subprotocol?: string
-  headers?: object
-  cookie?: object
   token?: string
 }
 
@@ -58,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.
@@ -84,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.
@@ -104,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.
@@ -136,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.
    *
@@ -167,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.
    *
@@ -183,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[]>
@@ -200,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[]>
 }

package/test-client/index.js

@@ -1,6 +1,6 @@
 import { ClientNode, TestPair } from '@logux/core'
-import { delay } from 'nanodelay'
 import cookie from 'cookie'
+import { delay } from 'nanodelay'
 
 import { filterMeta } from '../filter-meta/index.js'
 
@@ -43,6 +43,18 @@ export class TestClient {
     })
   }
 
+  async collect(test) {
+    let added = []
+    let unbind = this.node.log.on('add', (action, meta) => {
+      if (!meta.id.includes(` ${this.nodeId} `)) {
+        added.push(action)
+      }
+    })
+    await test()
+    unbind()
+    return added
+  }
+
   connect() {
     return new Promise((resolve, reject) => {
       this.node.throwsError = false
@@ -69,18 +81,6 @@ export class TestClient {
     return this.pair.wait('right')
   }
 
-  async collect(test) {
-    let added = []
-    let unbind = this.node.log.on('add', (action, meta) => {
-      if (!meta.id.includes(` ${this.nodeId} `)) {
-        added.push(action)
-      }
-    })
-    await test()
-    unbind()
-    return added
-  }
-
   process(action, meta) {
     return this.collect(async () => {
       return new Promise((resolve, reject) => {
@@ -133,10 +133,23 @@ export class TestClient {
     })
   }
 
+  async received(test) {
+    let actions = []
+    let unbind = this.log.on('add', (action, meta) => {
+      if (!meta.id.includes(` ${this.nodeId} `)) {
+        actions.push(action)
+      }
+    })
+    await test()
+    await delay(1)
+    unbind()
+    return actions
+  }
+
   async subscribe(channel, filter, since) {
     let action = channel
     if (typeof channel === 'string') {
-      action = { type: 'logux/subscribe', channel }
+      action = { channel, type: 'logux/subscribe' }
     }
     if (filter) {
       action.filter = filter
@@ -151,24 +164,11 @@ export class TestClient {
   unsubscribe(channel, filter) {
     let action = channel
     if (typeof channel === 'string') {
-      action = { type: 'logux/unsubscribe', channel }
+      action = { channel, type: 'logux/unsubscribe' }
     }
     if (filter) {
       action.filter = filter
     }
     return this.process(action)
   }
-
-  async received(test) {
-    let actions = []
-    let unbind = this.log.on('add', (action, meta) => {
-      if (!meta.id.includes(` ${this.nodeId} `)) {
-        actions.push(action)
-      }
-    })
-    await test()
-    await delay(1)
-    unbind()
-    return actions
-  }
 }