@logux/server 0.12.10 → 0.13.0

package/add-sync-map/index.d.ts

@@ -27,9 +27,9 @@ export type WithoutTime<Value extends SyncMapTypes | SyncMapTypes[]> = {
   [WITH_TIME]: false
 }
 
-export type SyncMapData<Value extends SyncMapValues> = { id: string } & {
+export type SyncMapData<Value extends SyncMapValues> = {
   [Key in keyof Value]: WithoutTime<Value[Key]> | WithTime<Value[Key]>
-}
+} & { id: string }
 
 /**
  * Add last changed time to value to use in conflict resolution.

package/allowed-meta/index.d.ts

@@ -3,7 +3,7 @@
  *
  *```js
  * import { ALLOWED_META } from '@logux/server'
- * async function outMap (action, meta) {
+ * async function onSend (action, meta) {
  *   const filtered = { }
  *   for (const i in meta) {
  *     if (ALLOWED_META.includes(i)) {

package/base-server/index.d.ts

@@ -13,13 +13,33 @@ import type {
   ServerConnection,
   TestTime
 } from '@logux/core'
-import type { Server as HTTPServer, IncomingMessage, ServerResponse } from 'http'
 import type { Unsubscribe } from 'nanoevents'
+import type {
+  Server as HTTPServer,
+  IncomingMessage,
+  ServerResponse
+} from 'node:http'
 import type { LogFn } from 'pino'
 
 import type { ChannelContext, Context } from '../context/index.js'
 import type { ServerClient } from '../server-client/index.js'
 
+interface TypeOptions {
+  /**
+   * Name of the queue that will be used to process actions
+   * of the specified type. Default is 'main'
+   */
+  queue?: string
+}
+
+interface ChannelOptions {
+  /**
+   * Name of the queue that will be used to process channels
+   * with the specified name pattern. Default is 'main'
+   */
+  queue?: string
+}
+
 export interface ServerMeta extends Meta {
   /**
    * All nodes subscribed to channel will receive the action.
@@ -446,7 +466,10 @@ type ActionCallbacks<
   TypeAction extends Action,
   Data extends object,
   Headers extends object
-> = (
+> = {
+  finally?: ActionFinally<TypeAction, Data, Headers>
+  resend?: Resender<TypeAction, Data, Headers>
+} & (
   | {
       access: Authorizer<TypeAction, Data, Headers>
       process?: Processor<TypeAction, Data, Headers>
@@ -454,17 +477,18 @@ type ActionCallbacks<
   | {
       accessAndProcess: Processor<TypeAction, Data, Headers>
     }
-) & {
-  finally?: ActionFinally<TypeAction, Data, Headers>
-  resend?: Resender<TypeAction, Data, Headers>
-}
+)
 
 type ChannelCallbacks<
   SubscribeAction extends Action,
   Data extends object,
   ChannelParams extends object | string[],
   Headers extends object
-> = (
+> = {
+  filter?: FilterCreator<SubscribeAction, Data, ChannelParams, Headers>
+  finally?: ChannelFinally<SubscribeAction, Data, ChannelParams, Headers>
+  unsubscribe?: ChannelUnsubscribe<Data, ChannelParams, Headers>
+} & (
   | {
       access: ChannelAuthorizer<SubscribeAction, Data, ChannelParams, Headers>
       load?: ChannelLoader<SubscribeAction, Data, ChannelParams, Headers>
@@ -477,11 +501,7 @@ type ChannelCallbacks<
         Headers
       >
     }
-) & {
-  filter?: FilterCreator<SubscribeAction, Data, ChannelParams, Headers>
-  finally?: ChannelFinally<SubscribeAction, Data, ChannelParams, Headers>
-  unsubscribe?: ChannelUnsubscribe<Data, ChannelParams, Headers>
-}
+)
 
 interface ActionReporter {
   action: Readonly<Action>
@@ -505,6 +525,7 @@ interface AuthenticationReporter {
 
 interface ReportersArguments {
   add: ActionReporter
+  addClean: ActionReporter
   authenticated: AuthenticationReporter
   clean: CleanReporter
   clientError: {
@@ -803,6 +824,7 @@ export class BaseServer<
    *
    * @param pattern Pattern for channel name.
    * @param callbacks Callback during subscription process.
+   * @param options Additional options
    */
   channel<
     ChannelParams extends object = {},
@@ -810,12 +832,14 @@ export class BaseServer<
     SubscribeAction extends LoguxSubscribeAction = LoguxSubscribeAction
   >(
     pattern: string,
-    callbacks: ChannelCallbacks<SubscribeAction, Data, ChannelParams, Headers>
+    callbacks: ChannelCallbacks<SubscribeAction, Data, ChannelParams, Headers>,
+    options?: ChannelOptions
   ): void
 
   /**
    * @param pattern Regular expression for channel name.
    * @param callbacks Callback during subscription process.
+   * @param options Additional options
    */
   channel<
     ChannelParams extends string[] = string[],
@@ -823,7 +847,8 @@ export class BaseServer<
     SubscribeAction extends LoguxSubscribeAction = LoguxSubscribeAction
   >(
     pattern: RegExp,
-    callbacks: ChannelCallbacks<SubscribeAction, Data, ChannelParams, Headers>
+    callbacks: ChannelCallbacks<SubscribeAction, Data, ChannelParams, Headers>,
+    options?: ChannelOptions
   ): void
 
   /**
@@ -975,7 +1000,7 @@ export class BaseServer<
    * @param listener Client listener.
    */
   on(
-    event: 'authenticated',
+    event: 'authenticated' | 'unauthenticated',
     listener: (client: ServerClient, latencyMilliseconds: number) => void
   ): Unsubscribe
 
@@ -1009,7 +1034,8 @@ export class BaseServer<
     event: 'unsubscribed',
     listener: (
       action: LoguxUnsubscribeAction,
-      meta: Readonly<ServerMeta>
+      meta: Readonly<ServerMeta>,
+      clientNodeId: string
     ) => void
   ): Unsubscribe
 
@@ -1120,10 +1146,12 @@ export class BaseServer<
   /**
    * @param actionCreator Action creator function.
    * @param callbacks Callbacks for action created by creator.
+   * @param options Additional options
    */
   type<Creator extends AbstractActionCreator, Data extends object = {}>(
     actionCreator: Creator,
-    callbacks: ActionCallbacks<ReturnType<Creator>, Data, Headers>
+    callbacks: ActionCallbacks<ReturnType<Creator>, Data, Headers>,
+    options?: TypeOptions
   ): void
 
   /**
@@ -1147,10 +1175,12 @@ export class BaseServer<
    *
    * @param name The action’s type or action’s type matching rule as RegExp..
    * @param callbacks Callbacks for actions with this type.
+   * @param options Additional options
    */
   type<TypeAction extends Action = AnyAction, Data extends object = {}>(
     name: RegExp | TypeAction['type'],
-    callbacks: ActionCallbacks<TypeAction, Data, Headers>
+    callbacks: ActionCallbacks<TypeAction, Data, Headers>,
+    options?: TypeOptions
   ): void
 
   /**

package/base-server/index.js

@@ -1,10 +1,10 @@
 import { LoguxNotFoundError } from '@logux/actions'
 import { Log, MemoryStore, parseId, ServerConnection } from '@logux/core'
-import { promises as fs } from 'fs'
 import { createNanoEvents } from 'nanoevents'
 import { nanoid } from 'nanoid'
-import { dirname, join } from 'path'
-import { fileURLToPath } from 'url'
+import { promises as fs } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import UrlPattern from 'url-pattern'
 import { WebSocketServer } from 'ws'
 
@@ -185,7 +185,9 @@ export class BaseServer {
         this.emitter.emit('report', 'add', { action, meta })
       }
 
-      if (this.destroying) return
+      if (this.destroying && !this.actionToQueue.has(meta.id)) {
+        return
+      }
 
       if (action.type === 'logux/subscribe') {
         if (meta.server === this.nodeId) {
@@ -238,7 +240,7 @@ export class BaseServer {
 
       if (meta.status === 'waiting') {
         if (!processor) {
-          this.internalUnkownType(action, meta)
+          this.internalUnknownType(action, meta)
           return
         }
         if (processor.process) {
@@ -333,6 +335,10 @@ export class BaseServer {
     this.timeouts = {}
     this.lastTimeout = 0
 
+    this.typeToQueue = new Map()
+    this.queues = new Map()
+    this.actionToQueue = new Map()
+
     this.controls = {
       'GET /': {
         async request() {
@@ -355,24 +361,83 @@ export class BaseServer {
     this.listenNotes = {}
     bindBackendProxy(this)
 
+    let end = (actionId, queue, queueKey, ...args) => {
+      this.actionToQueue.delete(actionId)
+      if (queue.length() === 0) {
+        this.queues.delete(queueKey)
+      }
+      queue.next(...args)
+    }
+    let undoRemainingTasks = queue => {
+      let remainingTasks = queue.getQueue()
+      if (remainingTasks) {
+        for (let task of remainingTasks) {
+          this.undo(task.action, task.meta, 'error')
+          this.actionToQueue.delete(task.meta.id)
+        }
+      }
+      queue.killAndDrain()
+    }
+    this.on('error', (e, action, meta) => {
+      let queueKey = this.actionToQueue.get(meta?.id)
+      if (queueKey) {
+        let queue = this.queues.get(queueKey)
+        undoRemainingTasks(queue)
+        end(meta.id, queue, queueKey, e)
+      }
+    })
+    this.on('processed', (action, meta) => {
+      if (action.type === 'logux/undo') {
+        let queueKey = this.actionToQueue.get(action.id)
+        if (queueKey) {
+          let queue = this.queues.get(queueKey)
+          undoRemainingTasks(queue)
+          end(action.id, queue, queueKey, null, meta)
+        }
+      } else if (action.type === 'logux/processed') {
+        let queueKey = this.actionToQueue.get(action.id)
+        if (queueKey) {
+          let queue = this.queues.get(queueKey)
+          end(action.id, queue, queueKey, null, meta)
+        }
+      } else if (
+        action.type !== 'logux/subscribed' &&
+        action.type !== 'logux/unsubscribed'
+      ) {
+        let queueKey = this.actionToQueue.get(meta.id)
+        if (queueKey) {
+          let queue = this.queues.get(queueKey)
+          end(meta.id, queue, queueKey, null, meta)
+        }
+      }
+    })
+
     this.unbind.push(() => {
       for (let i of this.connected.values()) i.destroy()
       for (let i in this.timeouts) {
         clearTimeout(this.timeouts[i])
       }
     })
-    this.unbind.push(
-      () =>
-        new Promise(resolve => {
-          if (this.processing === 0) {
-            resolve()
-          } else {
-            this.on('processed', () => {
-              if (this.processing === 0) resolve()
-            })
-          }
+    this.unbind.push(() => {
+      return new Promise(resolve => {
+        if (this.processing === 0) {
+          resolve()
+        } else {
+          this.on('processed', () => {
+            if (this.processing === 0) resolve()
+          })
+        }
+      })
+    })
+    this.unbind.push(() => {
+      return Promise.allSettled(
+        [...this.queues.values()].map(queue => {
+          return new Promise(resolve => {
+            queue.drain = resolve
+          })
         })
-    )
+      )
+    })
   }
 
   addClient(connection) {
@@ -409,7 +474,7 @@ export class BaseServer {
     return [undoAction, undoMeta]
   }
 
-  channel(pattern, callbacks) {
+  channel(pattern, callbacks, options = {}) {
     normalizeChannelCallbacks(`Channel ${pattern}`, callbacks)
     let channel = Object.assign({}, callbacks)
     if (typeof pattern === 'string') {
@@ -419,6 +484,8 @@ export class BaseServer {
     } else {
       channel.regexp = pattern
     }
+
+    channel.queueName = options.queue || 'main'
     this.channels.push(channel)
   }
 
@@ -497,7 +564,7 @@ export class BaseServer {
     this.httpListener = listener
   }
 
-  internalUnkownType(action, meta) {
+  internalUnknownType(action, meta) {
     this.contexts.delete(action)
     this.log.changeMeta(meta.id, { status: 'error' })
     this.emitter.emit('report', 'unknownType', {
@@ -657,7 +724,7 @@ export class BaseServer {
         }
       }
     }
-    this.emitter.emit('unsubscribed', action, meta)
+    this.emitter.emit('unsubscribed', action, meta, clientNodeId)
     this.emitter.emit('report', 'unsubscribed', {
       actionId: meta.id,
       channel: action.channel
@@ -785,9 +852,10 @@ export class BaseServer {
                 let ctx = this.createContext(action, meta)
                 let client = this.clientIds.get(clientId)
                 for (let filter of Object.values(subscriber.filters)) {
-                  filter = typeof filter === 'function'
-                    ? await filter(ctx, action, meta)
-                    : filter
+                  filter =
+                    typeof filter === 'function'
+                      ? await filter(ctx, action, meta)
+                      : filter
                   if (filter && client) {
                     ignoreClients.add(clientId)
                     client.node.onAdd(action, meta)
@@ -924,7 +992,10 @@ export class BaseServer {
     if (!match) this.wrongChannel(action, meta)
   }
 
-  type(name, callbacks) {
+  type(name, callbacks, options = {}) {
+    let queue = options.queue || 'main'
+    this.typeToQueue.set(name, queue)
+
     if (typeof name === 'function') name = name.type
     normalizeTypeCallbacks(`Action type ${name}`, callbacks)
 
@@ -946,7 +1017,7 @@ export class BaseServer {
   }
 
   unknownType(action, meta) {
-    this.internalUnkownType(action, meta)
+    this.internalUnknownType(action, meta)
     this.unknownTypes[meta.id] = true
   }
 

package/bind-backend-proxy/index.js

@@ -1,8 +1,8 @@
 import { LoguxError } from '@logux/core'
-import http from 'http'
-import https from 'https'
 import JSONStream from 'JSONStream'
 import { nanoid } from 'nanoid'
+import http from 'node:http'
+import https from 'node:https'
 
 const VERSION = 4
 
@@ -126,7 +126,7 @@ export function bindBackendProxy(app) {
         })
       )
     }
-    let accessResolve, accessReject
+    let accessReject, accessResolve
     accessing.set(
       meta.id,
       new Promise((resolve, reject) => {
@@ -134,7 +134,7 @@ export function bindBackendProxy(app) {
         accessReject = reject
       })
     )
-    let processResolve, processReject
+    let processReject, processResolve
     processing.set(
       meta.id,
       new Promise((resolve, reject) => {

package/create-http-server/index.js

@@ -1,7 +1,7 @@
-import { promises as fs } from 'fs'
-import http from 'http'
-import https from 'https'
-import { isAbsolute, join } from 'path'
+import { promises as fs } from 'node:fs'
+import http from 'node:http'
+import https from 'node:https'
+import { isAbsolute, join } from 'node:path'
 
 const PEM_PREAMBLE = '-----BEGIN'
 

package/create-reporter/index.js

@@ -1,8 +1,8 @@
-import os from 'os'
-import { dirname, join, sep } from 'path'
+import os from 'node:os'
+import { dirname, join, sep } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import pico from 'picocolors'
 import pino from 'pino'
-import { fileURLToPath } from 'url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 export const PATH_TO_PRETTIFYING_PINO_TRANSPORT = join(

package/filtered-node/index.js

@@ -16,24 +16,12 @@ export class FilteredNode extends ServerNode {
     delete this.received
   }
 
-  async syncSinceQuery(lastSynced) {
-    let data = { added: 0, entries: [] }
-    await this.log.each({ order: 'added' }, (action, meta) => {
-      if (meta.added <= lastSynced) {
-        return false
-      } else {
-        if (
-          (has(meta.clients, this.client.clientId) ||
-            has(meta.nodes, this.client.nodeId) ||
-            has(meta.users, this.client.userId)) &&
-          !has(meta.excludeClients, this.client.clientId)
-        ) {
-          if (meta.added > data.added) data.added = meta.added
-          data.entries.push([action, meta])
-        }
-        return true
-      }
-    })
-    return data
+  syncFilter(action, meta) {
+    return (
+      (has(meta.clients, this.client.clientId) ||
+        has(meta.nodes, this.client.nodeId) ||
+        has(meta.users, this.client.userId)) &&
+      !has(meta.excludeClients, this.client.clientId)
+    )
   }
 }

package/human-formatter/index.js

@@ -1,11 +1,10 @@
-import { once } from 'events'
-import os from 'os'
+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 { Transform } from 'stream'
 import stripAnsi from 'strip-ansi'
-import yyyymmdd from 'yyyy-mm-dd'
 
 import { mulberry32, onceXmur3 } from './utils.js'
 
@@ -39,6 +38,17 @@ const LABELS = {
 
 const COLORS = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan']
 
+function formatNow() {
+  let date = new Date()
+  let year = date.getFullYear()
+  let month = String(date.getMonth() + 1).padStart(2, '0')
+  let day = String(date.getDate()).padStart(2, '0')
+  let hour = String(date.getHours()).padStart(2, '0')
+  let minutes = String(date.getMinutes()).padStart(2, '0')
+  let seconds = String(date.getSeconds()).padStart(2, '0')
+  return `${year}-${month}-${day} ${hour}:${minutes}:${seconds}`
+}
+
 function rightPag(str, length) {
   let add = length - stripAnsi(str).length
   for (let i = 0; i < add; i++) str += ' '
@@ -47,7 +57,7 @@ function rightPag(str, length) {
 
 function label(c, type, color, labelBg, labelText, message) {
   let pagged = rightPag(c[labelBg](c[labelText](type)), 8)
-  let time = c.dim(`at ${yyyymmdd.withTime(new Date())}`)
+  let time = c.dim(`at ${formatNow()}`)
   let highlighted = message.replace(/`([^`]+)`/g, c.yellow('$1'))
   return `${pagged}${c.bold(c[color](highlighted))} ${time}`
 }

package/options-loader/index.test.js

@@ -1,4 +1,4 @@
-import { resolve } from 'path'
+import { resolve } from 'node:path'
 import { describe, expect, it } from 'vitest'
 
 import { loadOptions, number, oneOf } from './index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logux/server",
-  "version": "0.12.10",
+  "version": "0.13.0",
   "description": "Build own Logux server or make proxy between WebSocket and HTTP backend on any language",
   "keywords": [
     "logux",
@@ -18,7 +18,7 @@
   "homepage": "https://logux.org/",
   "repository": "logux/server",
   "engines": {
-    "node": "^14.0.0 || ^16.0.0 || >=18.0.0"
+    "node": "^18.0.0 || ^18.0.0 || >=22.0.0"
   },
   "type": "module",
   "types": "./index.d.ts",
@@ -27,24 +27,24 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@logux/actions": "^0.3.1",
-    "@logux/core": "^0.8.5",
+    "@logux/actions": "^0.4.0",
+    "@logux/core": "^0.9.0",
     "JSONStream": "^1.3.5",
-    "cookie": "^0.5.0",
-    "dotenv": "^16.3.1",
-    "fast-glob": "^3.3.1",
+    "cookie": "^0.6.0",
+    "dotenv": "^16.4.5",
+    "fast-glob": "^3.3.2",
+    "fastq": "^1.17.1",
     "nanodelay": "^2.0.2",
-    "nanoevents": "^8.0.0",
-    "nanoid": "^4.0.2",
+    "nanoevents": "^9.0.0",
+    "nanoid": "^5.0.7",
     "netmask": "^2.0.2",
     "node-fetch": "^3.3.2",
-    "picocolors": "^1.0.0",
-    "pino": "8.15.0",
-    "pino-abstract-transport": "^1.0.0",
-    "semver": "^7.5.4",
+    "picocolors": "^1.0.1",
+    "pino": "9.3.2",
+    "pino-abstract-transport": "^1.2.0",
+    "semver": "^7.6.3",
     "strip-ansi": "^7.1.0",
     "url-pattern": "^1.0.3",
-    "ws": "^8.13.0",
-    "yyyy-mm-dd": "^1.0.2"
+    "ws": "^8.18.0"
   }
 }

package/server/index.js

@@ -1,5 +1,5 @@
 import glob from 'fast-glob'
-import { join, relative } from 'path'
+import { join, relative } from 'node:path'
 import pico from 'picocolors'
 
 import { BaseServer } from '../base-server/index.js'

package/server-client/index.js

@@ -1,11 +1,16 @@
 import { LoguxError, parseId } from '@logux/core'
 import cookie from 'cookie'
+import fastq from 'fastq'
 import semver from 'semver'
 
 import { ALLOWED_META } from '../allowed-meta/index.js'
 import { filterMeta } from '../filter-meta/index.js'
 import { FilteredNode } from '../filtered-node/index.js'
 
+async function onSend(action, meta) {
+  return [action, filterMeta(meta)]
+}
+
 function reportDetails(client) {
   return {
     connectionId: client.key,
@@ -14,6 +19,51 @@ function reportDetails(client) {
   }
 }
 
+function denyBack(app, clientId, action, meta) {
+  app.emitter.emit('report', 'denied', { actionId: meta.id })
+  let [undoAction, undoMeta] = app.buildUndo(action, meta, 'denied')
+  undoMeta.clients = (undoMeta.clients || []).concat([clientId])
+  app.log.add(undoAction, undoMeta)
+  app.debugActionError(meta, `Action "${meta.id}" was denied`)
+}
+
+async function queueWorker(task, next) {
+  let { action, app, clientId, meta, onReceiveResolve, queue } = task
+  queue.next = next
+
+  let type = action.type
+  if (type === 'logux/subscribe' || type === 'logux/unsubscribe') {
+    return onReceiveResolve([action, meta])
+  }
+
+  let processor = app.getProcessor(type)
+  if (!processor) {
+    app.internalUnknownType(action, meta)
+    return onReceiveResolve(false)
+  }
+
+  let ctx = app.createContext(action, meta)
+  try {
+    let result = await processor.access(ctx, action, meta)
+    if (app.unknownTypes[meta.id]) {
+      delete app.unknownTypes[meta.id]
+      app.finally(processor, ctx, action, meta)
+      return false
+    } else if (!result) {
+      app.finally(processor, ctx, action, meta)
+      denyBack(app, clientId, action, meta)
+      return onReceiveResolve(false)
+    } else {
+      return onReceiveResolve([action, meta])
+    }
+  } catch (e) {
+    app.undo(action, meta, 'error')
+    app.emitter.emit('error', e, action, meta)
+    app.finally(processor, ctx, action, meta)
+    return onReceiveResolve(false)
+  }
+}
+
 export class ServerClient {
   constructor(app, connection, key) {
     this.app = app
@@ -33,9 +83,8 @@ export class ServerClient {
 
     this.node = new FilteredNode(this, app.nodeId, app.log, connection, {
       auth: this.auth.bind(this),
-      inFilter: this.filter.bind(this),
-      inMap: this.inMap.bind(this),
-      outMap: this.outMap.bind(this),
+      onReceive: this.onReceive.bind(this),
+      onSend,
       ping: app.options.ping,
       subprotocol: app.options.subprotocol,
       timeout: app.options.timeout
@@ -77,6 +126,7 @@ export class ServerClient {
     }
 
     if (nodeId === 'server' || userId === 'server') {
+      this.app.emitter.emit('unauthenticated', this, 0)
       this.app.emitter.emit('report', 'unauthenticated', reportDetails(this))
       return false
     }
@@ -133,20 +183,13 @@ export class ServerClient {
       this.app.emitter.emit('authenticated', this, Date.now() - start)
       this.app.emitter.emit('report', 'authenticated', reportDetails(this))
     } else {
+      this.app.emitter.emit('unauthenticated', this, Date.now() - start)
       this.app.emitter.emit('report', 'unauthenticated', reportDetails(this))
       this.app.rememberBadAuth(this.remoteAddress)
     }
     return result
   }
 
-  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`)
-  }
-
   destroy() {
     this.destroyed = true
     this.node.destroy()
@@ -162,9 +205,6 @@ export class ServerClient {
       }
     }
     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) {
@@ -174,6 +214,8 @@ export class ServerClient {
           this.app.performUnsubscribe(this.nodeId, action, meta)
         }
       }
+      this.app.clientIds.delete(this.clientId)
+      this.app.nodeIds.delete(this.nodeId)
     }
     if (!this.app.destroying) {
       this.app.emitter.emit('disconnected', this)
@@ -181,61 +223,68 @@ export class ServerClient {
     this.app.connected.delete(this.key)
   }
 
-  async filter(action, meta) {
-    let ctx = this.app.createContext(action, meta)
+  isSubprotocol(range) {
+    return semver.satisfies(this.node.remoteSubprotocol, range)
+  }
+
+  onReceive(action, meta) {
+    if (this.app.actionToQueue.has(meta.id)) {
+      return Promise.resolve(false)
+    }
 
-    let wrongUser = !this.clientId || this.clientId !== ctx.clientId
+    let actionClientId = parseId(meta.id).clientId
+    let wrongUser = !this.clientId || this.clientId !== actionClientId
     let wrongMeta = Object.keys(meta).some(i => !ALLOWED_META.includes(i))
     if (wrongUser || wrongMeta) {
-      this.app.contexts.delete(action)
-      this.denyBack(action, meta)
-      return false
+      denyBack(this.app, this.clientId, action, meta)
+      return Promise.resolve(false)
     }
 
-    let type = action.type
-    if (type === 'logux/subscribe' || type === 'logux/unsubscribe') {
-      return true
-    }
+    return new Promise(resolve => {
+      let clientId = parseId(meta.id).clientId
+      let queueName = ''
 
-    let processor = this.app.getProcessor(type)
-    if (!processor) {
-      this.app.internalUnkownType(action, meta)
-      return false
-    }
+      let isChannel =
+        (action.type === 'logux/subscribe' ||
+          action.type === 'logux/unsubscribe') &&
+        action.channel
 
-    try {
-      let result = await processor.access(ctx, action, meta)
-      if (this.app.unknownTypes[meta.id]) {
-        delete this.app.unknownTypes[meta.id]
-        this.app.finally(processor, ctx, action, meta)
-        return false
-      } else if (!result) {
-        this.app.finally(processor, ctx, action, meta)
-        this.denyBack(action, meta)
-        return false
+      if (isChannel) {
+        for (let channel of this.app.channels) {
+          let pattern = channel.regexp || channel.pattern.regex
+          if (action.channel.match(pattern)) {
+            queueName = channel.queue
+            break
+          }
+        }
       } else {
-        return true
+        queueName = this.app.typeToQueue.get(action.type)
       }
-    } catch (e) {
-      this.app.undo(action, meta, 'error')
-      this.app.emitter.emit('error', e, action, meta)
-      this.app.finally(processor, ctx, action, meta)
-      return false
-    }
-  }
 
-  async inMap(action, meta) {
-    if (!meta.subprotocol) {
-      meta.subprotocol = this.node.remoteSubprotocol
-    }
-    return [action, meta]
-  }
+      queueName = queueName || 'main'
+      let queueKey = `${clientId}/${queueName}`
+      let queue = this.app.queues.get(queueKey)
 
-  isSubprotocol(range) {
-    return semver.satisfies(this.node.remoteSubprotocol, range)
-  }
+      if (!queue) {
+        queue = fastq(queueWorker, 1)
+        this.app.queues.set(queueKey, queue)
+      }
+
+      if (!meta.subprotocol) {
+        meta.subprotocol = this.node.remoteSubprotocol
+      }
 
-  async outMap(action, meta) {
-    return [action, filterMeta(meta)]
+      this.app.actionToQueue.set(meta.id, queueKey)
+      queue.push({
+        action,
+        app: this.app,
+        clientId,
+        meta,
+        onReceiveResolve: result => {
+          resolve(result)
+        },
+        queue
+      })
+    })
   }
 }

package/test-client/index.js

@@ -18,7 +18,7 @@ export class TestClient {
     this.node = new ClientNode(this.nodeId, this.log, this.pair.left, {
       ...opts,
       fixTime: false,
-      outMap: (action, meta) => {
+      onSend(action, meta) {
         return [action, filterMeta(meta)]
       }
     })

package/vite.config.ts

@@ -3,9 +3,21 @@ import { defineConfig } from 'vitest/config'
 export default defineConfig({
   test: {
     coverage: {
-      exclude: ['node_modules', 'server/index.js', '*/*.test.*'],
-      lines: 100,
-      provider: 'v8'
+      exclude: [
+        'node_modules',
+        'server/index.js',
+        'test/*',
+        '**/*.d.ts',
+        '**/*.test.ts',
+        '*/errors.ts',
+        '*/types.ts',
+        '*.config.*',
+        'human-formatter'
+      ],
+      provider: 'v8',
+      thresholds: {
+        lines: 100
+      }
     },
     environment: 'node',
     exclude: ['node_modules', 'test/servers']