@logux/server 0.16.3 → 0.17.0

package/publishing/index.js

@@ -0,0 +1,157 @@
+import { parseId } from '@logux/core'
+
+import { Context } from '../context/index.js'
+
+function addTarget(targets, client, action, meta) {
+  let entries = targets.get(client)
+  if (entries) {
+    entries.push([action, meta])
+  } else {
+    targets.set(client, [[action, meta]])
+  }
+}
+
+function maxAdded(settled, meta) {
+  if (typeof meta.added === 'undefined' || meta.added < settled) return settled
+  return meta.added
+}
+
+/**
+ * Delivers the actions of the log to the clients.
+ *
+ * The publisher never runs `access`, `resend` or `process`: it resolves
+ * the recipients of the already stored facts and tracks the sending.
+ */
+export class Publisher {
+  constructor(server) {
+    this.server = server
+    this.pending = new Set()
+  }
+
+  #resolveTargets(action, meta, targets) {
+    let from = parseId(meta.id).clientId
+    let ignoreClients = new Set(meta.excludeClients || [])
+    ignoreClients.add(from)
+
+    if (meta.nodes) {
+      for (let id of meta.nodes) {
+        let client = this.server.nodeIds.get(id)
+        if (client) {
+          ignoreClients.add(client.clientId)
+          addTarget(targets, client, action, meta)
+        }
+      }
+    }
+
+    if (meta.clients) {
+      for (let id of meta.clients) {
+        if (this.server.clientIds.has(id)) {
+          let client = this.server.clientIds.get(id)
+          ignoreClients.add(client.clientId)
+          addTarget(targets, client, action, meta)
+        }
+      }
+    }
+
+    if (meta.users) {
+      for (let userId of meta.users) {
+        let users = this.server.userIds.get(userId)
+        if (users) {
+          for (let client of users) {
+            if (!ignoreClients.has(client.clientId)) {
+              ignoreClients.add(client.clientId)
+              addTarget(targets, client, action, meta)
+            }
+          }
+        }
+      }
+    }
+
+    if (!meta.channels) return undefined
+
+    let waiting = []
+    for (let channel of meta.channels) {
+      if (this.server.subscribers[channel]) {
+        for (let nodeId in this.server.subscribers[channel]) {
+          let clientId = parseId(nodeId).clientId
+          if (!ignoreClients.has(clientId)) {
+            let subscriber = this.server.subscribers[channel][nodeId]
+            if (subscriber) {
+              let ctx = new Context(this.server, meta)
+              let client = this.server.clientIds.get(clientId)
+              for (let filter of Object.values(subscriber.filters)) {
+                if (typeof filter === 'function') {
+                  waiting.push(
+                    Promise.resolve(filter(ctx, action, meta)).then(
+                      result => {
+                        if (result && client && !ignoreClients.has(clientId)) {
+                          ignoreClients.add(clientId)
+                          addTarget(targets, client, action, meta)
+                        }
+                      },
+                      e => {
+                        // A broken filter is a delivery problem, not a reason
+                        // to undo the already processed action
+                        this.server.emitter.emit('error', e, action, meta)
+                      }
+                    )
+                  )
+                } else if (filter && client) {
+                  ignoreClients.add(clientId)
+                  addTarget(targets, client, action, meta)
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return waiting.length > 0 ? Promise.all(waiting) : undefined
+  }
+
+  async send(entries) {
+    let targets = new Map()
+    let waiting = []
+    let settled = 0
+    for (let [action, meta] of entries) {
+      settled = maxAdded(settled, meta)
+      let promise = this.#resolveTargets(action, meta, targets)
+      if (promise) waiting.push(promise)
+    }
+    if (waiting.length > 0) await Promise.all(waiting)
+    this.#sendTargets(targets, settled)
+  }
+
+  // A barrier for the queue and the shutdown: it never rejects,
+  // the failures are reported where the sending was started
+  async settled() {
+    while (this.pending.size > 0) await Promise.all(this.pending)
+  }
+
+  // Returns the original promise, so the rejection is not swallowed
+  track(entries) {
+    let sending = this.send(entries)
+    let done = sending.then(
+      () => this.pending.delete(done),
+      () => this.pending.delete(done)
+    )
+    this.pending.add(done)
+    return sending
+  }
+
+  #sendTargets(targets, settled) {
+    for (let [client, entries] of targets) {
+      let sending = client.node.onAdd(entries)
+      // Only `ServerClient` tracks sending for `Server#drain()`
+      if (client.track) client.track(sending)
+    }
+    if (settled > 0) {
+      for (let client of this.server.connected.values()) {
+        if (!targets.has(client) && client.node.lastAddedCache < settled) {
+          client.node.lastAddedCache = settled
+        }
+      }
+    }
+    targets.clear()
+  }
+}

package/queue-manager/index.js

@@ -0,0 +1,39 @@
+/**
+ * FIFO queues of the tasks by `(clientId, queueName)`.
+ *
+ * A task keeps its queue until it is finished or until the deadline
+ * answers it: the timeout can not stop the callback, but the queue
+ * must move on.
+ */
+export class QueueManager {
+  constructor(runner) {
+    this.queues = new Map()
+    this.runner = runner
+  }
+
+  // The tasks, which did not start yet, are answered by the caller
+  cancelPending(key) {
+    let queue = this.queues.get(key)
+    if (!queue) return []
+    return queue.pending.splice(0)
+  }
+
+  push(key, task) {
+    let queue = this.queues.get(key)
+    if (!queue) {
+      queue = { chain: Promise.resolve(), pending: [] }
+      this.queues.set(key, queue)
+    }
+    task.queueKey = key
+    queue.pending.push(task)
+    queue.chain = queue.chain.then(async () => {
+      if (queue.pending.shift() !== task) return
+      await this.runner.run(task)
+      if (queue.pending.length === 0) this.queues.delete(key)
+    })
+  }
+
+  get size() {
+    return this.queues.size
+  }
+}

package/server-client/index.d.ts

@@ -82,15 +82,6 @@ export class ServerClient<ClientData extends object = unknown> {
    */
   nodeId?: string
 
-  /**
-   * Does server process some action from client.
-   *
-   * ```js
-   * console.log('Clients in processing:', clients.map(i => i.processing))
-   * ```
-   */
-  processing: boolean
-
   /**
    * Client IP address.
    *

package/server-client/index.js

@@ -1,11 +1,10 @@
 import { LoguxError, parseId } from '@logux/core'
 import { parseCookie } from 'cookie'
-import fastq from 'fastq'
 
 import { ALLOWED_META } from '../allowed-meta/index.js'
-import { Context } from '../context/index.js'
 import { filterMeta } from '../filter-meta/index.js'
 import { FilteredNode } from '../filtered-node/index.js'
+import { removeMembership } from '../processing/index.js'
 
 async function onSend(action, meta) {
   return [action, filterMeta(meta)]
@@ -21,70 +20,6 @@ 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, client, clientId, meta, onReceiveResolve, queue } = task
-  queue.next = next
-
-  if (app.options.queueTimeout) {
-    let timer = setTimeout(() => {
-      let error = new Error(
-        `Action "${meta.id}" was not processed in ${app.options.queueTimeout} ms`
-      )
-      app.undo(action, meta, 'error')
-      app.emitter.emit('error', error, action, meta)
-    }, app.options.queueTimeout)
-    if (timer.unref) timer.unref()
-    app.queueTimers.set(meta.id, timer)
-  }
-
-  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 {
-      // The queue is released by the `processed` event of the action,
-      // which never comes for the action the log already has: `log.add()`
-      // returns `false` and no `batch` event fires. The core ignores
-      // `false`, so the action is added here to see the result
-      if (client.node.received) client.node.received[meta.id] = true
-      let added = await app.log.add(action, meta)
-      if (added === false) await app.resolveDuplicate(action, meta)
-      return onReceiveResolve(false)
-    }
-  } 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
@@ -92,7 +27,6 @@ export class ServerClient {
     this.clientId = undefined
     this.nodeId = undefined
     this.data = {}
-    this.processing = false
     this.sending = new Set()
     this.connection = connection
     this.key = key.toString()
@@ -111,6 +45,7 @@ export class ServerClient {
       onReceive: this.onReceive.bind(this),
       onSend,
       ping: app.options.ping,
+      ready: () => this.waitForReady(),
       subprotocol: app.options.subprotocol,
       syncBatch: app.options.syncBatch,
       timeout: app.options.timeout
@@ -119,20 +54,6 @@ export class ServerClient {
       this.node.setLocalHeaders({ env: 'development' })
     }
 
-    if (app.connectLoader) {
-      this.node.syncSinceQuery = async lastSynced => {
-        let context = new Context(app, this)
-        let entries = await app.connectLoader(context, lastSynced)
-        let added = 0
-        for (let entry of entries) {
-          // `added` should be taken before `filterMeta()` removes it
-          if (entry[1].added > added) added = entry[1].added
-          entry[1] = filterMeta(entry[1])
-        }
-        return { added, entries }
-      }
-    }
-
     this.node.catch(err => {
       err.connectionId = this.key
       this.app.emitter.emit('error', err)
@@ -234,6 +155,7 @@ export class ServerClient {
   destroy() {
     this.destroyed = true
     this.node.destroy()
+    this.app.runner.cleanConnection(this)
     if (this.userId) {
       let users = this.app.userIds.get(this.userId)
       if (users) {
@@ -252,7 +174,7 @@ export class ServerClient {
           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)
+          removeMembership(this.app, this.nodeId, action, meta)
         }
       }
       this.app.clientIds.delete(this.clientId)
@@ -282,67 +204,26 @@ export class ServerClient {
   }
 
   onReceive(action, meta) {
-    if (this.app.actionToQueue.has(meta.id)) {
-      return Promise.resolve(false)
-    }
-
     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) {
-      denyBack(this.app, this.clientId, action, meta)
+      this.app.reportFailure('denied', action, meta)
+      void this.app.publishUndo(action, meta, 'denied', {}, this.clientId)
       return Promise.resolve(false)
     }
 
-    return new Promise(resolve => {
-      let clientId = parseId(meta.id).clientId
-      let queueName = ''
-
-      let isChannel =
-        (action.type === 'logux/subscribe' ||
-          action.type === 'logux/unsubscribe') &&
-        action.channel
-
-      if (isChannel) {
-        for (let channel of this.app.channels) {
-          let match = channel.regexp
-            ? action.channel.match(channel.regexp)
-            : channel.pattern(action.channel)
-          if (match) {
-            queueName = channel.queue
-            break
-          }
-        }
-      } else {
-        queueName = this.app.typeToQueue.get(action.type)
-      }
-
-      queueName = queueName || 'main'
-      let queueKey = `${clientId}/${queueName}`
-      let queue = this.app.queues.get(queueKey)
-
-      if (!queue) {
-        queue = fastq(queueWorker, 1)
-        this.app.queues.set(queueKey, queue)
-      }
+    if (!meta.subprotocol) {
+      meta.subprotocol = this.node.remoteSubprotocol
+    }
 
-      if (!meta.subprotocol) {
-        meta.subprotocol = this.node.remoteSubprotocol
+    return this.app.runner.submit({ action, client: this, meta }).then(
+      () => false,
+      err => {
+        if (err.transportFailure) throw err
+        return false
       }
-
-      this.app.actionToQueue.set(meta.id, queueKey)
-      queue.push({
-        action,
-        app: this.app,
-        client: this,
-        clientId,
-        meta,
-        onReceiveResolve: result => {
-          resolve(result)
-        },
-        queue
-      })
-    })
+    )
   }
 
   track(sending) {
@@ -352,4 +233,14 @@ export class ServerClient {
       this.sending.delete(done)
     })
   }
+
+  async waitForReady() {
+    if (!this.node.remoteReady) {
+      await new Promise(resolve => {
+        this.node.on('ready', resolve)
+      })
+    }
+    await this.app.runner.waitForClient(this)
+    await this.drain()
+  }
 }

package/url-pattern/index.js

@@ -1,4 +1,4 @@
-const PARAM = /:(\w+)/g
+const PARAM = /:(\w+)|\*/g
 const SPECIAL = /[.*+?^${}()|[\]\\]/g
 
 function escape(text) {
@@ -10,8 +10,14 @@ export function createPattern(pattern) {
   let source = ''
   let last = 0
   for (let param of pattern.matchAll(PARAM)) {
-    source += escape(pattern.slice(last, param.index)) + '([^/]+)'
-    names.push(param[1])
+    source += escape(pattern.slice(last, param.index))
+    if (param[1]) {
+      source += '([^/]+)'
+      names.push(param[1])
+    } else {
+      // `*` matches the rest of the URL, including `/`
+      source += '.*'
+    }
     last = param.index + param[0].length
   }
   let regexp = new RegExp('^' + source + escape(pattern.slice(last)) + '$')