@logux/server 0.16.1 → 0.16.3

package/base-server/index.d.ts

@@ -238,6 +238,13 @@ export interface BaseServerOptions {
    */
   subprotocol?: number
 
+  /**
+   * How long an action can stay in the processing queue of the client
+   * before the server answers `logux/undo` and moves to the next action.
+   * `300000` (5 minutes) by default, `0` disables it.
+   */
+  queueTimeout?: number
+
   /**
    * How many actions could be sent in a single message. `100` by default.
    *
@@ -602,6 +609,7 @@ interface ReportersArguments {
   }
   unsubscribed: SubscriptionReporter
   useless: ActionReporter
+  duplicate: ActionReporter
   wrongChannel: SubscriptionReporter
   zombie: {
     nodeId: string

package/base-server/index.js

@@ -120,6 +120,9 @@ export class BaseServer {
   constructor(opts = {}) {
     this.options = opts
     this.env = this.options.env || process.env.NODE_ENV || 'development'
+    if (typeof this.options.queueTimeout === 'undefined') {
+      this.options.queueTimeout = 5 * 60 * 1000
+    }
 
     if (typeof this.options.subprotocol === 'undefined') {
       throw optionError('Missed `subprotocol` option in server constructor')
@@ -326,6 +329,7 @@ export class BaseServer {
     this.typeToQueue = new Map()
     this.queues = new Map()
     this.actionToQueue = new Map()
+    this.queueTimers = new Map()
 
     this.httpListeners = {}
     this.httpAllListeners = []
@@ -334,6 +338,8 @@ export class BaseServer {
     this.listenNotes = {}
 
     let end = (actionId, queue, queueKey, ...args) => {
+      clearTimeout(this.queueTimers.get(actionId))
+      this.queueTimers.delete(actionId)
       this.actionToQueue.delete(actionId)
       if (queue.length() === 0) {
         this.queues.delete(queueKey)
@@ -346,17 +352,21 @@ export class BaseServer {
         for (let task of remainingTasks) {
           this.undo(task.action, task.meta, 'error')
           this.actionToQueue.delete(task.meta.id)
+          // The core waits for it to answer `synced`
+          task.onReceiveResolve(false)
         }
       }
       queue.killAndDrain()
     }
+    this.releaseQueue = (actionId, error) => {
+      let queueKey = this.actionToQueue.get(actionId)
+      if (!queueKey) return
+      let queue = this.queues.get(queueKey)
+      if (error) undoRemainingTasks(queue)
+      end(actionId, queue, queueKey, error ?? null)
+    }
     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)
-      }
+      if (meta) this.releaseQueue(meta.id, e)
     })
     this.on('processed', (action, meta) => {
       if (action.type === 'logux/undo') {
@@ -654,6 +664,26 @@ export class BaseServer {
     })
   }
 
+  /**
+   * The client re-sent the action, which the log already has: the server
+   * stored it, but the client did not get the answer. Answer again
+   * and release the queue of the client.
+   */
+  async resolveDuplicate(action, meta) {
+    let [stored, storedMeta] = await this.log.byId(meta.id)
+    this.emitter.emit('report', 'duplicate', {
+      actionId: meta.id,
+      status: storedMeta ? storedMeta.status : undefined
+    })
+    if (stored && storedMeta.status === 'processed') {
+      // The `processed` event of the answer releases the queue
+      this.markAsProcessed(storedMeta)
+    } else {
+      // Still processing or already answered by `logux/undo`
+      this.releaseQueue(meta.id)
+    }
+  }
+
   markAsProcessed(meta) {
     this.log.changeMeta(meta.id, { status: 'processed' })
     let data = parseId(meta.id)
@@ -846,10 +876,6 @@ export class BaseServer {
       meta = { ...meta, ...diff }
     }
 
-    if (this.isUseless(action, meta)) {
-      this.emitter.emit('report', 'useless', { action, meta })
-    }
-
     await this.sendAction(action, meta)
     this.runProcessor(action, meta, processor, start)
   }

package/create-reporter/index.js

@@ -79,6 +79,8 @@ const REPORTERS = {
 
   destroy: () => ({ msg: 'Shutting down Logux server' }),
 
+  duplicate: () => ({ level: 'warn', msg: 'Action was already received' }),
+
   disconnect: () => ({ msg: 'Client was disconnected' }),
 
   error: record => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logux/server",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "description": "Build own Logux server",
   "keywords": [
     "collaborative",
@@ -24,10 +24,10 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@logux/actions": "^0.7.2",
-    "@logux/core": "^0.11.6",
+    "@logux/actions": "^0.7.3",
+    "@logux/core": "^0.11.8",
     "cookie": "^2.0.1",
-    "fastq": "^1.20.1",
+    "fastq": "^1.20.3",
     "nanoevents": "^10.0.0",
     "nanoid": "^6.0.1",
     "ws": "^8.21.3"

package/server/index.js

@@ -87,9 +87,20 @@ export class Server extends BaseServer {
       process.exit(0)
     }
     process.on('SIGINT', onExit)
+    // Docker, Kubernetes and PaaS stop the process with SIGTERM.
+    process.on('SIGTERM', onExit)
+
+    // Ctrl+C to `pnpm run --parallel` go only to group.
+    if (this.env === 'development') {
+      process.stdin.on('end', onExit)
+      process.stdin.resume()
+    }
 
     this.unbind.push(() => {
       process.removeListener('SIGINT', onExit)
+      process.removeListener('SIGTERM', onExit)
+      process.stdin.removeListener('end', onExit)
+      process.stdin.pause()
     })
   }
 

package/server-client/index.js

@@ -30,9 +30,21 @@ function denyBack(app, clientId, action, meta) {
 }
 
 async function queueWorker(task, next) {
-  let { action, app, clientId, meta, onReceiveResolve, queue } = task
+  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])
@@ -56,7 +68,14 @@ async function queueWorker(task, next) {
       denyBack(app, clientId, action, meta)
       return onReceiveResolve(false)
     } else {
-      return onReceiveResolve([action, meta])
+      // 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')
@@ -315,6 +334,7 @@ export class ServerClient {
       queue.push({
         action,
         app: this.app,
+        client: this,
         clientId,
         meta,
         onReceiveResolve: result => {

package/vite.config.ts

@@ -1,25 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    coverage: {
-      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']
-  }
-})