@cuboapp/crdt 1.0.12 → 1.0.14

package/package.json

@@ -1,30 +1,35 @@
 {
   "name": "@cuboapp/crdt",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "CRDT for CUBO",
   "main": "src/index.ts",
-  "repository": "git@github.com:cuboapp/crdt.git",
+  "repository": {
+    "type": "git",
+    "url": "git@cuboapp.gitlab.yandexcloud.net:cubo/crdt.git"
+  },
   "author": "CuboSoft",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "src"
+  ],
   "dependencies": {
-    "@cuboapp/types": "^2.0.13",
-    "@cuboapp/utils": "1.0.10",
-    "@cuboapp/ws": "1.0.7",
-    "ws": "^8.19.0",
+    "@cuboapp/types": "^2.0.14",
+    "@cuboapp/utils": "1.0.12",
+    "@cuboapp/ws": "1.0.9",
     "y-protocols": "^1.0.7",
-    "yjs": "^13.6.30"
+    "yjs": "^13.6.31"
   },
   "peerDependencies": {
-    "vue": "^3.5.30",
-    "vue-router": "^5.0.2"
+    "vue": "^3.5.38",
+    "vue-router": "^5.1.0"
   },
   "devDependencies": {
-    "@types/node": "^24.10.1",
+    "@types/node": "^26.0.0",
     "@types/ws": "^8.18.1",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3"
   }
 }

package/src/client/index.ts

@@ -1,12 +1,14 @@
 import { keyBy, pick, uuid } from '@cuboapp/utils'
+import { WsClientEvent } from '@cuboapp/ws'
 import { computed, reactive } from 'vue'
-import { applyUpdate, Doc } from 'yjs'
 import { applyAwarenessUpdate, Awareness, encodeAwarenessUpdate, removeAwarenessStates } from 'y-protocols/awareness'
+import { applyUpdate, Doc } from 'yjs'
 
 import { CUBO_CRDT_EVENT } from '../constants'
 import { CuboCrdtServerDocumentIncomingAction } from '../server'
 import { CuboCrdtKey } from '../types'
 
+import { AsyncSerialQueue } from './queue'
 import {
   CuboCrdtClientDocOrigin,
   CuboCrdtClientDocUpdateOptions,
@@ -17,7 +19,6 @@ import {
   CuboCrdtClientSubscribeEvent,
   CuboCrdtClientUseOptions
 } from './types'
-import { AsyncSerialQueue } from './queue'
 
 export * from './types'
 
@@ -25,6 +26,12 @@ export class CuboCrdtClient<M> {
   public store: CuboCrdtClientStore<M> = {}
 
   private listeners: Map<string, Map<string, (ctx: CuboCrdtClientSubscribeEvent) => void | Promise<void>>> = new Map()
+
+  // реестр активных подписок — нужен, чтобы переподписаться после реконнекта
+  private subscriptions = new Map<string, { entity: string; filters?: Record<string, any>; awareness?: boolean }>()
+  private connectedOnce = false
+  private onReconnect = () => this.resubscribeAll()
+
   private eventQueue = new AsyncSerialQueue({
     errorMode: 'continue',
     onError: (e) => console.error('[CRDT] inbound queue task failed', e),
@@ -36,6 +43,13 @@ export class CuboCrdtClient<M> {
   }
 
   async start() {
+    // если сокет уже подключён к моменту старта — считаем текущий коннект «первым»,
+    // чтобы первое же событие CONNECTED (после обрыва) сработало как переподписка
+    this.connectedOnce = this.ws.connected
+
+    // переподписываемся на все документы при (ре)коннекте сокета
+    this.ws.ee.on(WsClientEvent.CONNECTED, this.onReconnect)
+
     this.ws.registerHandler(CUBO_CRDT_EVENT.EVENT, ({ message }) => {
       this.eventQueue
         .enqueue(async () => {
@@ -68,9 +82,45 @@ export class CuboCrdtClient<M> {
   }
 
   async stop() {
+    this.ws.ee.off(WsClientEvent.CONNECTED, this.onReconnect)
+
     this.ws.deleteHandler(CUBO_CRDT_EVENT.EVENT)
 
     this.listeners.clear()
+    this.subscriptions.clear()
+    this.connectedOnce = false
+  }
+
+  /**
+   * Переподписка на все активные подписки после реконнекта.
+   *
+   * При обрыве сокета бэкенд удаляет клиента вместе со всеми его подписками
+   * (removeClient -> cleanSubscribe), а после реконнекта сокету выдаётся новый id.
+   * Локальные слушатели (this.listeners) и yjs-документы при этом сохраняются,
+   * поэтому достаточно заново отправить SUBSCRIBE по реестру — заново
+   * навешивать слушатели не нужно.
+   */
+  private resubscribeAll() {
+    // первый коннект — useList() уже сам отправил SUBSCRIBE, дублировать не нужно
+    if (!this.connectedOnce) {
+      this.connectedOnce = true
+      return
+    }
+
+    if (this.debug) {
+      console.log('[CRDT] reconnected, resubscribing', { count: this.subscriptions.size })
+    }
+
+    for (const [subscribe_id, sub] of this.subscriptions) {
+      try {
+        this.ws.request({
+          method: CUBO_CRDT_EVENT.SUBSCRIBE,
+          data: { subscribe_id, entity: sub.entity, filters: sub.filters, awareness: sub.awareness }
+        })
+      } catch (e) {
+        console.error('[CRDT] resubscribe failed', subscribe_id, e)
+      }
+    }
   }
 
   public useComputedList<K extends Extract<keyof M, string>>(entity: K) {
@@ -138,8 +188,17 @@ export class CuboCrdtClient<M> {
         })
       })
 
-      // подписываемся на бэке
-      this.ws.request({ method: CUBO_CRDT_EVENT.SUBSCRIBE, data: { subscribe_id, entity, filters, awareness: opts?.awareness } })
+      // регистрируем подписку, чтобы переподписаться после реконнекта
+      this.subscriptions.set(subscribe_id, { entity: `${entity}`, filters, awareness: opts?.awareness })
+
+      // подписываемся на бэке (если сокет ещё не подключён — переподпишемся по событию CONNECTED)
+      try {
+        this.ws.request({ method: CUBO_CRDT_EVENT.SUBSCRIBE, data: { subscribe_id, entity, filters, awareness: opts?.awareness } })
+      } catch (e) {
+        if (this.debug) {
+          console.warn('[CRDT] subscribe deferred until reconnect', subscribe_id, e)
+        }
+      }
     }
 
     // отписка
@@ -148,12 +207,23 @@ export class CuboCrdtClient<M> {
         console.log('[CRDT] unsubscribe', { entity, opts, filters })
       }
 
+      // снимаем подписку из реестра переподписки
+      this.subscriptions.delete(subscribe_id)
+
       // отписываемся на бэке
-      this.ws.request({ method: CUBO_CRDT_EVENT.UNSUBSCRIBE, data: { subscribe_id } })
+      try {
+        this.ws.request({ method: CUBO_CRDT_EVENT.UNSUBSCRIBE, data: { subscribe_id } })
+      } catch (e) {
+        if (this.debug) {
+          console.warn('[CRDT] unsubscribe request failed (socket down)', subscribe_id, e)
+        }
+      }
 
       // отписываемся на фронте
       this.listeners.get(entity)?.delete(subscribe_id)
 
+      this.store[storeKey]!.state.subscribed = false
+
       // очищаем стор
       if (clear !== false) {
         const item = this.store[storeKey]
@@ -279,18 +349,49 @@ export class CuboCrdtClient<M> {
   }
 
   public upgrade(subscribe_id: string, filters?: Record<string, any>) {
+    // держим реестр в актуальном состоянии, чтобы переподписка после реконнекта
+    // использовала уже обновлённые фильтры
+    const sub = this.subscriptions.get(subscribe_id)
+    if (sub) {
+      sub.filters = filters
+    }
+
     this.ws.request({ method: CUBO_CRDT_EVENT.UPGRADE, data: { subscribe_id, filters } })
   }
 
-  private async onDocumentCreate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
-    let doc = this.store[opts.storeKey]?.docs.get(ctx.entity_id)
-    if (doc) {
-      console.warn('[CRDT] onDocumentCreate: doc already exists', { ctx, opts })
+  // апсертит строку в реактивное хранилище из текущего состояния yjs-документа
+  private applyRowJson(storeKey: string, entity_id: number, doc: Doc) {
+    const json: any = doc.getMap().toJSON()
+    const rows = this.store[storeKey]?.state.rows
+    if (!rows) {
       return
+    }
+
+    const index = rows.findIndex((r: any) => r.id === entity_id)
+    if (index >= 0) {
+      rows[index] = json
     } else {
-      doc = new Doc()
+      rows.push(json)
+    }
+  }
+
+  private async onDocumentCreate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
+    const existing = this.store[opts.storeKey]?.docs.get(ctx.entity_id)
+    if (existing) {
+      // документ уже есть локально (типичный кейс — повторный SUBSCRIBE после реконнекта).
+      // вместо игнорирования вмёрживаем входящее состояние в существующий yjs-документ
+      // (CRDT-merge), сохраняя локальные слушатели и awareness.
+      if (this.debug) {
+        console.log('[CRDT] onDocumentCreate: doc already exists, merging state', { ctx, opts })
+      }
+
+      applyUpdate(existing, new Uint8Array(ctx.data as any), { react: false })
+      this.applyRowJson(opts.storeKey, ctx.entity_id, existing)
+      return
     }
 
+    const doc = new Doc()
+
     const update = new Uint8Array(ctx.data as any)
 
     if (opts?.onBeforeCreate) {
@@ -351,7 +452,8 @@ export class CuboCrdtClient<M> {
         awareness = new Awareness(doc)
 
         awareness.on('update', ({ added, updated, removed }, origin) => {
-          console.log('[CRDT] awarness update', origin)
+          // console.log('[CRDT] awarness update', origin)
+
           if (origin === 'remote') {
             return
           }
@@ -396,17 +498,7 @@ export class CuboCrdtClient<M> {
     applyUpdate(doc, update, { react: false })
 
     // обновляем документ в реактивном хранилище
-    const json: any = doc.getMap().toJSON()
-    const index = this.store[opts.storeKey]?.state.rows.findIndex((r: any) => r.id === ctx.entity_id)
-    if (index !== undefined && index >= 0) {
-      this.store[opts.storeKey]!.state.rows[index] = json
-    } else {
-      if (this.debug) {
-        console.warn('[CRDT] onDocumentUpdate - row not exists: "' + ctx.entity_id + '"', { ctx, opts })
-      }
-
-      this.store[opts.storeKey]!.state.rows.push(json)
-    }
+    this.applyRowJson(opts.storeKey, ctx.entity_id, doc)
 
     if (opts?.onAfterUpdate) {
       await opts.onAfterUpdate(doc, update, ctx, opts)

package/src/server/document/index.ts

@@ -60,7 +60,7 @@ export class CuboCrdtServerDocument {
         const row = this.getJson()
         const body = pick(row, origin.keys ?? Object.keys(row))
 
-        if (Object.keys(body)) {
+        if (Object.keys(body).length) {
           this.debounceStore(body, origin)
         }
       }

package/src/server/index.ts

@@ -1,5 +1,6 @@
 import { cloneDeep } from '@cuboapp/utils'
 import { WsServerSocket } from '@cuboapp/ws'
+import { applyAwarenessUpdate, encodeAwarenessUpdate, removeAwarenessStates } from 'y-protocols/awareness'
 
 import { CUBO_CRDT_EVENT } from '../constants'
 import { CuboCrdtAction } from '../types'
@@ -16,7 +17,6 @@ import {
   CuboCrdtServerUnsubscribeDto,
   CuboCrdtSocketClient
 } from './types'
-import { applyAwarenessUpdate, encodeAwarenessUpdate, removeAwarenessStates } from 'y-protocols/awareness'
 
 export * from './document'
 export * from './types'
@@ -99,7 +99,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
         console.log('[CRDT] incoming event', data)
       }
 
-      data.forEach((row: any) => {
+      for (const row of data) {
         const update = new Uint8Array(row.data)
 
         switch (row.action) {
@@ -114,10 +114,9 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
             break
           case 'awareness':
             this.onAwarenessExternalUpdate(update, row)
-
             break
         }
-      })
+      }
     })
 
     this.ws.registerHttpHandler('GET', '/stats', () => {
@@ -170,6 +169,10 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     // удаляем мапу подписок по клиенту
     this.subscribesByClient.delete(client.id)
 
+    // снимаем запланированный флаш очереди (чтобы не слать в закрытый сокет)
+    clearTimeout(this.sendTimeouts.get(client.id))
+    this.sendTimeouts.delete(client.id)
+
     // удаляем очередь под клиента
     this.queue.delete(client.id)
 
@@ -177,14 +180,26 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     this.clients.delete(client.id)
   }
 
+  private get batchMaxSize() {
+    return this.options.batch?.maxSize ?? 50
+  }
+
+  private get batchDebounce() {
+    return this.options.batch?.debounce ?? 100
+  }
+
   private sendQueueToClient(client: CuboCrdtSocketClient<A>) {
+    // снимаем запланированный флаш — мы отправляем прямо сейчас
+    clearTimeout(this.sendTimeouts.get(client.id))
+    this.sendTimeouts.delete(client.id)
+
     const queue = this.queue.get(client.id)
-    if (!queue) {
+    if (!queue || queue.size === 0) {
       return
     }
 
-    // const data = Array.from(queue)
-    const data = [...new Map((Array.from(queue) || []).map((item) => [JSON.stringify(item), item])).values()]
+    // дедупликация одинаковых событий внутри батча
+    const data = [...new Map(Array.from(queue).map((item) => [JSON.stringify(item), item])).values()]
 
     queue.clear()
 
@@ -194,8 +209,6 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
         data
       })
     )
-
-    queue.clear()
   }
 
   public sendToClient(client_id: string, data: any) {
@@ -204,21 +217,26 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
       return
     }
 
-    // сбрасываем таймаут если он есть
-    clearTimeout(this.sendTimeouts.get(client_id))
+    const queue = this.queue.get(client_id)
+    if (!queue) {
+      return
+    }
 
     // добавляем в очередь
-    this.queue.get(client_id).add(data)
+    queue.add(data)
 
-    // если очередь >10 то сразу отправляем
-    if (this.queue.size > 10) {
+    // если у ЭТОГО клиента в очереди накопилось много событий — отправляем сразу
+    if (queue.size >= this.batchMaxSize) {
       this.sendQueueToClient(client)
+      return
     }
-    // если нет - ставим таймаут
-    else {
+
+    // иначе — дебаунсим отправку, но НЕ сбрасываем уже запланированный флаш,
+    // иначе при непрерывном потоке апдейтов очередь никогда не отправится
+    if (!this.sendTimeouts.has(client_id)) {
       this.sendTimeouts.set(
         client_id,
-        setTimeout(() => this.sendQueueToClient(client), 100)
+        setTimeout(() => this.sendQueueToClient(client), this.batchDebounce)
       )
     }
   }
@@ -288,18 +306,19 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
   }
 
   public getSutableSubscribes(entity: string, row: any) {
-    return Array.from(this.subscribesByEntity.get(entity as E) || [])
-      .filter((m) => {
-        const subscribe = this.subscribes.get(m[1])
+    return Array.from(this.subscribesByEntity.get(entity as E) || []).filter((subscribe_id) => {
+      const subscribe = this.subscribes.get(subscribe_id)
+      if (!subscribe) {
+        return false
+      }
 
-        let state = subscribe && checkRowIsSutable(row, subscribe)
-        if (this.options.checkRowIsSutable) {
-          state = this.options.checkRowIsSutable(state, { entity: entity as any, subscribe, row })
-        }
+      let state = checkRowIsSutable(row, subscribe.filters || {})
+      if (this.options.checkRowIsSutable) {
+        state = this.options.checkRowIsSutable(state, { entity: entity as any, subscribe, row })
+      }
 
-        return state
-      })
-      .map((m) => m[1])
+      return state
+    })
   }
 
   public ensureDocument(entity: E, row: any, awareness?: boolean) {
@@ -381,15 +400,16 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
   }
 
   private onDocumentExternalUpdate(update: Uint8Array, action: CuboCrdtServerDocumentIncomingAction) {
-    const document = this.getDocument(action.entity, action.entity_id)
-
-    // console.log('onDocumentExternalUpdate', action)
-
+    let document = this.getDocument(action.entity, action.entity_id)
     if (!document) {
-      console.warn('[CRDT] onDocumentExternalUpdate - document not found:', action.entity, action.entity_id)
-    } else {
-      document.applyUpdate(new Uint8Array(update), action.origin)
+      if (this.debug) {
+        console.warn('[CRDT] onDocumentExternalUpdate - document not found, creating:', action.entity, action.entity_id)
+      }
+
+      document = this.ensureDocument(action.entity as E, action.entity_id, true)
     }
+
+    document.applyUpdate(new Uint8Array(update), action.origin)
   }
 
   private onAwarenessExternalUpdate(update: Uint8Array, action: CuboCrdtServerDocumentIncomingAction) {
@@ -445,7 +465,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     const row = document.getJson()
 
     // берём все подписки по сущности
-    const sutableSubscribes = Array.from(this.subscribesByEntity.get(entity))
+    const sutableSubscribes = Array.from(this.subscribesByEntity.get(entity) || [])
       .map((subscribe_id) => {
         const subscribe = this.subscribes.get(subscribe_id)
 

package/src/server/types/index.ts

@@ -10,6 +10,15 @@ export type CuboCrdtServerOptions<M, A, E extends Extract<keyof M, string>> = {
   ws: WsServer
   entities: E[]
   debug?: boolean
+  /**
+   * Параметры батчинга исходящих событий (защита от перегрузки бэка).
+   * - maxSize: при достижении такого размера очереди клиента батч отправляется сразу
+   * - debounce: задержка перед отправкой неполного батча (мс)
+   */
+  batch?: {
+    maxSize?: number
+    debounce?: number
+  }
   fetchRows?: (client: WsServerSocket, subscribe: CuboCrdtServerSubscribe) => Promise<M[E][]>
   checkRowIsSutable?: (baseState: boolean, ctx: { entity: E; subscribe: CuboCrdtServerSubscribe; row: any }) => boolean
   storeRow?: <K extends E>(

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "trailingComma": "none",
-  "tabWidth": 2,
-  "semi": false,
-  "singleQuote": true,
-  "eslintIntegration": true,
-  "printWidth": 140
-}

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "target": "ES2021",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": "./",
-    "incremental": true,
-    "skipLibCheck": true,
-    "paths": {
-      "@/*": ["src/*"]
-    }
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}