@logux/server 0.16.2 → 0.17.0

package/context/index.d.ts

@@ -97,7 +97,7 @@ export class ConnectContext<Headers extends object = unknown> {
    *
    * @param action The action or the array of actions.
    * @param meta Action’s meta.
-   * @returns Promise until action was added to the server log.
+   * @returns Promise until the action was sent to the client.
    */
   sendBack<TypeAction extends Action = AnyAction>(
     action:
@@ -141,6 +141,18 @@ export class Context<
    */
   isServer: boolean
 
+  /**
+   * Signal, which will be aborted when the action will be undone
+   * by `queueTimeout`.
+   *
+   * ```js
+   * process (ctx, action) {
+   *   return fetch(url, { signal: ctx.signal })
+   * }
+   * ```
+   */
+  signal: AbortSignal
+
   constructor(server: Server, meta: ServerMeta)
 }
 

package/context/index.js

@@ -1,7 +1,7 @@
 import { parseId } from '@logux/core'
 
 export class Context {
-  constructor(server, meta) {
+  constructor(server, meta, task) {
     this.server = server
     this.data = {}
 
@@ -31,6 +31,8 @@ export class Context {
     } else {
       this.headers = {}
     }
+
+    if (task) this.signal = task.controller.signal
   }
 
   drain() {
@@ -38,7 +40,7 @@ export class Context {
   }
 
   sendBack(actions, meta = {}) {
-    let common = { clients: [this.clientId], status: 'processed', ...meta }
+    let common = { clients: [this.clientId], ...meta }
     if (Array.isArray(actions)) {
       return this.server.log.add(
         actions.map(item => {

package/create-reporter/index.js

@@ -79,6 +79,14 @@ const REPORTERS = {
 
   destroy: () => ({ msg: 'Shutting down Logux server' }),
 
+  destroyDetached: () => ({
+    level: 'warn',
+    msg: 'Shutting down, but some actions that exceeded ' +
+      'queueTimeout will be killed'
+  }),
+
+  duplicate: () => ({ level: 'warn', msg: 'Action was already received' }),
+
   disconnect: () => ({ msg: 'Client was disconnected' }),
 
   error: record => {

package/filtered-node/index.js

@@ -1,9 +1,27 @@
-import { ServerNode } from '@logux/core'
+import { idToTime, ServerNode } from '@logux/core'
+
+import { Context } from '../context/index.js'
+import { filterMeta } from '../filter-meta/index.js'
 
 function has(array, item) {
   return array && array.includes(item)
 }
 
+async function loadOnConnect(app, client, lastSynced) {
+  let entries = await app.connectLoader(new Context(app, client), lastSynced)
+  let added = 0
+  for (let entry of entries) {
+    // `added` should be taken before `filterMeta()` removes it
+    let entryAdded = entry[1].added
+    if (entryAdded > added) added = entryAdded
+    entry[1] = filterMeta(entry[1])
+    // The core needs `added` to set the sync position of every message
+    // and removes it before sending the action to the client
+    if (typeof entryAdded !== 'undefined') entry[1].added = entryAdded
+  }
+  return { added, entries }
+}
+
 export class FilteredNode extends ServerNode {
   constructor(client, nodeId, log, connection, options) {
     super(nodeId, log, connection, options)
@@ -24,4 +42,23 @@ export class FilteredNode extends ServerNode {
       !has(meta.excludeClients, this.client.clientId)
     )
   }
+
+  async syncSinceQuery(lastSynced) {
+    let app = this.client.app
+    let data = app.connectLoader
+      ? await loadOnConnect(app, this.client, lastSynced)
+      : await super.syncSinceQuery(lastSynced)
+
+    let actions = data.entries.length
+    if (actions > 0) {
+      let id = app.log.generateId()
+      // Entries are ordered from the newest to the oldest one,
+      // so the last entry will be sent to the client first
+      data.entries.push([
+        { actions, type: 'logux/prepare' },
+        { id, time: idToTime(id) }
+      ])
+    }
+    return data
+  }
 }

package/index.d.ts

@@ -25,6 +25,11 @@ export {
   PostgresStore,
   PostgresStoreOptions
 } from './postgres-store/index.js'
+export {
+  ProcessingEntry,
+  ProcessingOutcome,
+  ProcessingStore
+} from './processing-store/index.js'
 export {
   del,
   get,

package/index.js

@@ -9,6 +9,7 @@ export { BaseServer, wasNot403 } from './base-server/index.js'
 export { Context } from './context/index.js'
 export { filterMeta } from './filter-meta/index.js'
 export { PostgresStore } from './postgres-store/index.js'
+export { ProcessingStore } from './processing-store/index.js'
 export { ResponseError } from './request/index.js'
 export { Server } from './server/index.js'
 export { TestClient } from './test-client/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logux/server",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "Build own Logux server",
   "keywords": [
     "collaborative",
@@ -24,13 +24,12 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@logux/actions": "^0.7.3",
-    "@logux/core": "^0.11.7",
+    "@logux/actions": "^0.8.0",
+    "@logux/core": "^0.12.0",
     "cookie": "^2.0.1",
-    "fastq": "^1.20.3",
     "nanoevents": "^10.0.0",
     "nanoid": "^6.0.1",
-    "ws": "^8.21.3"
+    "ws": "^8.22.0"
   },
   "engines": {
     "node": "^22.5.0 || ^24.0.0 || >=26.0.0"

package/postgres-store/index.d.ts

@@ -108,7 +108,7 @@ export class PostgresStore<
     opts?: PostgresStoreOptions<Packers>
   )
 
-  add(action: AnyAction, meta: Meta): Promise<false | Meta>
+  add(entries: [AnyAction, Meta][]): Promise<(false | Meta)[]>
 
   addReason(reasons: string[], criteria: Criteria): Promise<void>
 
@@ -124,6 +124,8 @@ export class PostgresStore<
 
   getLastSynced(): Promise<LastSynced>
 
+  has(ids: string[]): Promise<string[]>
+
   /**
    * Bring the log tables to the latest version, creating them if they were
    * not created by the application’s migration.

package/postgres-store/index.js

@@ -76,6 +76,13 @@ function position(meta) {
   return toSorted({ ...meta, time: meta.time ?? 0 })
 }
 
+// A row of the `VALUES` list. Every cell keeps its own parameter with
+// an explicit type, since the drivers send them all as text
+function valuesSql(params, at, cells) {
+  let sql = cells.map(([type, value]) => `${params.add(value)}::${type}`)
+  return `(${at}, ${sql.join(', ')})`
+}
+
 function criteriaSql(criteria, params) {
   let where = []
   if (typeof criteria.id !== 'undefined') {
@@ -167,48 +174,76 @@ export class PostgresStore {
     this.packers = { [zero.type]: zeroPacker, ...opts.packers }
   }
 
-  async add(action, meta) {
-    let packed = this.packers[action.type]?.pack(action)
-    let rest = { ...meta }
-    delete rest.added
-    let rows = await this.query(
-      // The action with the same ID is ignored, so it must not spend
-      // the next `added` number
-      `WITH "found" AS (
-         SELECT 1 FROM "logux_log" WHERE "id" = $1
+  async add(entries) {
+    if (entries.length === 0) return []
+
+    let params = new Params()
+    let rows = entries.map(([action, meta], i) => {
+      let packed = this.packers[action.type]?.pack(action)
+      let rest = { ...meta }
+      delete rest.added
+      // The place in the call sets the `added` order and keeps the first
+      // action among the duplicates of the same call
+      return valuesSql(params, i + 1, [
+        ['text', meta.id],
+        ['text', position(meta)],
+        ['bigint', meta.time ?? 0],
+        ['text', typeof action.type === 'string' ? action.type : ''],
+        ['text[]', meta.reasons ?? []],
+        ['text[]', meta.indexes ?? []],
+        ['jsonb', toJson(rest)],
+        ['jsonb', toJson(packed ? packed.action : action)],
+        ['bytea', packed ? packed.blob : null]
+      ])
+    })
+
+    // The action with the same ID is ignored, so it must not spend
+    // the next `added` number
+    let added = await this.query(
+      `WITH "input" (
+         "at", "id", "sorted", "time", "type",
+         "reasons", "indexes", "meta", "action", "blob"
+       ) AS (
+         VALUES ${rows.join(', ')}
+       ), "fresh" AS (
+         SELECT DISTINCT ON ("id") * FROM "input"
+         WHERE NOT EXISTS (
+           SELECT 1 FROM "logux_log" WHERE "logux_log"."id" = "input"."id"
+         )
+         ORDER BY "id", "at"
+       ), "numbered" AS (
+         SELECT *, row_number() OVER (ORDER BY "at") AS "offset" FROM "fresh"
        ), "next" AS (
-         UPDATE "logux_extra" SET "value" = "value" + 1
-         WHERE "key" = 'added' AND NOT EXISTS (SELECT 1 FROM "found")
-         RETURNING "value" AS "added"
+         UPDATE "logux_extra"
+         SET "value" = "value" + (SELECT count(*) FROM "numbered")
+         WHERE "key" = 'added' AND EXISTS (SELECT 1 FROM "numbered")
+         RETURNING "value" - (SELECT count(*) FROM "numbered") AS "base"
        )
        INSERT INTO "logux_log" (
          "added", "id", "sorted", "time", "type",
          "reasons", "indexes", "meta", "action", "blob"
        )
        SELECT
-         "next"."added", $1, $2, $3, $4,
-         $5::text[], $6::text[], $7::jsonb, $8::jsonb, $9
-       FROM "next"
+         "next"."base" + "numbered"."offset", "id", "sorted", "time", "type",
+         "reasons", "indexes", "meta", "action", "blob"
+       FROM "numbered", "next"
        ON CONFLICT ("id") DO NOTHING
-       RETURNING "added"`,
-      [
-        meta.id,
-        position(meta),
-        meta.time ?? 0,
-        typeof action.type === 'string' ? action.type : '',
-        meta.reasons ?? [],
-        meta.indexes ?? [],
-        toJson(rest),
-        toJson(packed ? packed.action : action),
-        packed ? packed.blob : null
-      ]
+       RETURNING "added", "id"`,
+      params.values
     )
-    if (rows.length === 0) return false
+
     // Drivers can return `bigint` as a string not to lose the precision above
     // `Number.MAX_SAFE_INTEGER`. Logux keeps `added` in `meta` as a number,
     // so these columns can never go that high
-    meta.added = Number(rows[0].added)
-    return meta
+    let numbers = new Map(added.map(i => [i.id, Number(i.added)]))
+    return entries.map(([, meta]) => {
+      let number = numbers.get(meta.id)
+      if (typeof number === 'undefined') return false
+      // Only the first action with the ID was inserted
+      numbers.delete(meta.id)
+      meta.added = number
+      return meta
+    })
   }
 
   async addReason(reasons, criteria) {
@@ -320,6 +355,15 @@ export class PostgresStore {
     return synced
   }
 
+  async has(ids) {
+    if (ids.length === 0) return []
+    let rows = await this.query(
+      `SELECT "id" FROM "logux_log" WHERE "id" = ANY($1::text[])`,
+      [ids]
+    )
+    return rows.map(i => i.id)
+  }
+
   async init() {
     if (this.transaction) {
       await this.transaction(query => this.migrate(query, true))