@cuboapp/crdt 1.0.22 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/crdt",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "CRDT for CUBO",
   "main": "src/index.ts",
   "repository": {

package/src/client/index.ts

@@ -1,19 +1,16 @@
 import { keyBy, pick, uuid } from '@cuboapp/utils'
 import { WsClientEvent } from '@cuboapp/ws'
-import { computed, reactive, shallowReactive } from 'vue'
+import { computed, reactive } from 'vue'
 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,
-  CuboCrdtListSyncData,
-  CuboCrdtSubscriptionStatus
-} from '../types'
+import { CuboCrdtKey, CuboCrdtListSyncData, CuboCrdtSubscriptionStatus } from '../types'
 
 import { AsyncSerialQueue } from './queue'
 import {
+  CuboCrdtClientDoc,
   CuboCrdtClientDocOrigin,
   CuboCrdtClientDocUpdateOptions,
   CuboCrdtClientList,
@@ -28,6 +25,7 @@ export * from './types'
 
 export class CuboCrdtClient<M> {
   public store: CuboCrdtClientStore<M> = {}
+  public docs = new Map<string, CuboCrdtClientDoc>()
 
   private listeners: Map<string, Map<string, (ctx: CuboCrdtClientSubscribeEvent) => void | Promise<void>>> = new Map()
 
@@ -234,8 +232,7 @@ export class CuboCrdtClient<M> {
 
       this.store[storeKey] = {
         state,
-        docs: shallowReactive(new Map()),
-        awarenesses: shallowReactive(new Map())
+        awarenesses: new Map()
       }
     }
 
@@ -260,6 +257,7 @@ export class CuboCrdtClient<M> {
       }
 
       // подписываемся на фронте
+      // console.log('subscribe', opts)
       this.listeners.get(entity)?.set(subscribe_id, async (ctx) => {
         await this.onIncomingUpdate(ctx, {
           subscribe_id,
@@ -330,13 +328,11 @@ export class CuboCrdtClient<M> {
 
       // отписываемся на бэке
       if (this.ws.connected) {
-        void 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)
-            }
-          })
+        void 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)
+          }
+        })
       }
 
       // отписываемся на фронте
@@ -358,8 +354,18 @@ export class CuboCrdtClient<M> {
             a.destroy()
           })
           item.awarenesses?.clear()
-          item.docs?.forEach((d) => d.destroy())
-          item.docs?.clear()
+
+          item.state.rows?.map((row) => {
+            const doc = this.docs.get(`${entity}:${(row as any).id}`)
+            if (doc) {
+              doc.subscribes.delete(subscribe_id)
+
+              if (doc.subscribes?.size === 0) {
+                doc.doc.destroy()
+                this.docs.delete(`${entity}:${(row as any).id}`)
+              }
+            }
+          })
         }
 
         this.store[storeKey] = undefined
@@ -383,7 +389,6 @@ export class CuboCrdtClient<M> {
       subscribe,
       upgrade,
       unsubscribe,
-      docs: computed(() => this.store[storeKey]?.docs),
       awarenesses: opts?.awareness ? computed(() => this.store[storeKey]?.awarenesses) : undefined,
       subscribed: () => computed(() => this.store[storeKey]?.state.subscribed || false),
       loading: () => computed(() => this.store[storeKey]?.state.loading || false),
@@ -404,30 +409,18 @@ export class CuboCrdtClient<M> {
   ): CuboCrdtClientRow<T> {
     // console.log('store key', opts?.storeKey ?? `${entity}:${id}`)
 
-    const {
-      subscribe_id,
-      storeKey,
-      docs,
-      awarenesses,
-      subscribe,
-      upgrade,
-      unsubscribe,
-      subscribed,
-      loading,
-      ready,
-      status,
-      error
-    } = this.useList(entity, {
-      ...opts,
-      filters: opts?.filters ?? { id },
-      storeKey: opts?.storeKey ?? `${entity}:${id}`
-    })
+    const { subscribe_id, storeKey, awarenesses, subscribe, upgrade, unsubscribe, subscribed, loading, ready, status, error } =
+      this.useList(entity, {
+        ...opts,
+        filters: opts?.filters ?? { id },
+        storeKey: opts?.storeKey ?? `${entity}:${id}`
+      })
 
     return {
       subscribe_id,
       storeKey,
-      doc: computed(() => docs.value?.get(id)),
-      awareness: opts?.awareness ? computed(() => awarenesses?.value?.get(id)) : undefined,
+      doc: this.docs.get(`${entity}:${id}`)?.doc,
+      awareness: computed(() => awarenesses?.value?.get(id)),
       subscribe,
       upgrade,
       unsubscribe,
@@ -450,51 +443,47 @@ export class CuboCrdtClient<M> {
     dto: K extends Extract<keyof M, string> ? Partial<M[K]> : object,
     opts?: CuboCrdtClientDocOrigin
   ) {
-    const entityStores = [...new Set(
-      [...this.subscriptions.values()]
-        .filter((subscription) => subscription.entity === entity)
-        .map((subscription) => this.store[subscription.storeKey])
-    )]
-    const fallbackStores = [this.store[entity], this.store[`${entity}:${entity_id}`]]
-    const store = [...entityStores, ...fallbackStores]
-      .find((candidate) => candidate?.docs.has(entity_id))
-    const document = store?.docs.get(entity_id)
-
-    if (!store || !document) {
-      return
-    }
-
-    const map = document.getMap()
-    const toUpdate = Object.fromEntries(
-      Object.entries(dto).filter(([key, value]) => map.get(key) !== value)
-    )
-
-    if (!Object.keys(toUpdate).length) {
-      return
-    }
+    const storeKey = `${entity}:${entity_id}`
+
+    const cardRow = this.store[storeKey]?.state.rows?.[0]
+    const listRow = this.store[entity]?.state?.rows.find((r: any) => r.id === entity_id)
+    const doc = this.docs.get(storeKey)
+
+    // обновляем документ
+    if (doc) {
+      const map = doc.doc.getMap()
+
+      // "или" - потому что они синхронизированы (без разницы какой брать)
+      const row = (cardRow || listRow) as any
+      const toUpdate = Object.fromEntries(Object.entries(dto).filter(([key, value]) => row[key] !== value))
+
+      if (Object.keys(toUpdate).length) {
+        const origin: CuboCrdtClientDocOrigin = {
+          store: opts?.store ?? true,
+          expose: opts?.expose ?? 'other',
+          keys: opts?.keys ?? Object.keys(toUpdate),
+          react: true // отправляем на бэк
+        }
 
-    const origin: CuboCrdtClientDocOrigin = {
-      store: opts?.store ?? true,
-      expose: opts?.expose ?? 'other',
-      keys: opts?.keys ?? Object.keys(toUpdate),
-      react: true
+        doc.doc.transact(() => {
+          Object.entries(toUpdate).forEach(([key, value]) => {
+            map.set(key, value)
+          })
+        }, origin)
+      }
     }
 
-    // Одна сущность может присутствовать в нескольких подписках с разными
-    // storeKey. Мутацию отправляем только из одного документа: остальные
-    // подписки получат подтверждённый update через обычную CRDT-рассылку.
-    document.transact(() => {
-      Object.entries(toUpdate).forEach(([key, value]) => {
-        map.set(key, value)
-      })
-    }, origin)
-
-    const row = store.state.rows.find((item: any) => Number(item.id) === Number(entity_id))
+    // обновляем реактивку
+    for (const row of [cardRow, listRow]) {
+      if (row) {
+        const toUpdate = Object.fromEntries(Object.entries(dto).filter(([key, value]) => row[key as keyof typeof row] !== value))
 
-    if (row) {
-      Object.entries(toUpdate).forEach(([key, value]) => {
-        row[key] = value
-      })
+        if (Object.keys(toUpdate).length) {
+          Object.entries(toUpdate).forEach(([key, value]) => {
+            row[key as keyof typeof row] = value
+          })
+        }
+      }
     }
   }
 
@@ -555,54 +544,13 @@ export class CuboCrdtClient<M> {
     }
   }
 
-  private ensureDocumentAwareness(
-    ctx: CuboCrdtClientSubscribeEvent,
-    opts: CuboCrdtClientDocUpdateOptions,
-    doc: Doc,
-    entity_id: number
-  ) {
-    if (!opts.awareness) {
-      return
-    }
-
-    let awareness = this.store[opts.storeKey]?.awarenesses.get(entity_id)
-
-    if (awareness) {
-      return
-    }
-
-    awareness = new Awareness(doc)
-
-    awareness.on('update', ({ added, updated, removed }, origin) => {
-      if (origin === 'remote') {
-        return
-      }
-
-      const changed = added.concat(updated).concat(removed)
-      const update = encodeAwarenessUpdate(awareness!, changed)
-
-      this.ws.request({
-        method: CUBO_CRDT_EVENT.EVENT,
-        data: {
-          action: 'awareness',
-          entity: ctx.entity,
-          entity_id,
-          data: Array.from(update),
-          origin: { expose: 'other', subscribe_id: opts.subscribe_id }
-        }
-      })
-    })
-
-    this.store[opts.storeKey]?.awarenesses.set(entity_id, awareness)
-  }
-
   private async onDocumentCreate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
     const entity_id = ctx.entity_id
     if (entity_id === undefined) {
       return
     }
 
-    const existing = this.store[opts.storeKey]?.docs.get(entity_id)
+    const existing = this.docs.get(`${ctx.entity}:${ctx.entity_id}`)
     if (existing) {
       // документ уже есть локально (типичный кейс — повторный SUBSCRIBE после реконнекта).
       // вместо игнорирования вмёрживаем входящее состояние в существующий yjs-документ
@@ -611,13 +559,12 @@ export class CuboCrdtClient<M> {
         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, entity_id, existing)
-      this.ensureDocumentAwareness(ctx, opts, existing, entity_id)
+      applyUpdate(existing.doc, new Uint8Array(ctx.data as any), { react: false })
+      this.applyRowJson(opts.storeKey, entity_id, existing.doc)
       return
     }
 
-    const doc = new Doc()
+    const yjsDoc = new Doc()
 
     const update = new Uint8Array(ctx.data as any)
 
@@ -628,10 +575,10 @@ export class CuboCrdtClient<M> {
       }
     }
 
-    applyUpdate(doc, update, { react: false })
+    applyUpdate(yjsDoc, update, { react: false })
 
     // подписываемся на обновления документа
-    doc.on('update', (update, origin: CuboCrdtClientDocOrigin) => {
+    yjsDoc.on('update', (update, origin: CuboCrdtClientDocOrigin) => {
       // react = false, если это апдейт с бэка
       if (origin?.react !== false) {
         const data: CuboCrdtServerDocumentIncomingAction = {
@@ -657,10 +604,11 @@ export class CuboCrdtClient<M> {
     })
 
     // добавляем документ в хранилище документов
-    this.store[opts.storeKey]?.docs.set(entity_id, doc)
+    const doc: CuboCrdtClientDoc = { doc: yjsDoc, subscribes: new Set() }
+    this.docs.set(`${ctx.entity}:${ctx.entity_id}`, doc)
 
     // добавляем документ в реактивное хранилище
-    const json: any = doc.getMap().toJSON()
+    const json: any = yjsDoc.getMap().toJSON()
     const index = this.store[opts.storeKey]?.state.rows.findIndex((r: any) => r.id === entity_id)
     if (index !== undefined && index >= 0) {
       if (this.debug) {
@@ -673,10 +621,41 @@ export class CuboCrdtClient<M> {
     }
 
     if (opts?.onAfterCreate) {
-      await opts.onAfterCreate(doc, update, ctx, opts)
+      await opts.onAfterCreate(yjsDoc, update, ctx, opts)
     }
 
-    this.ensureDocumentAwareness(ctx, opts, doc, entity_id)
+    if (opts?.awareness) {
+      let awareness = this.store[opts.storeKey]?.awarenesses.get(entity_id)
+
+      if (!awareness) {
+        awareness = new Awareness(yjsDoc)
+
+        awareness.on('update', ({ added, updated, removed }, origin) => {
+          // console.log('[CRDT] awarness update', origin)
+
+          if (origin === 'remote') {
+            return
+          }
+
+          const changed = added.concat(updated).concat(removed)
+          const update = encodeAwarenessUpdate(awareness, changed)
+
+          this.ws.request({
+            method: CUBO_CRDT_EVENT.EVENT,
+            data: {
+              action: 'awareness',
+              entity: ctx.entity,
+              entity_id,
+              data: Array.from(update),
+              // 'other' — не шлём свой же курсор обратно исходной подписке
+              origin: { expose: 'other', subscribe_id: opts.subscribe_id }
+            }
+          })
+        })
+
+        this.store[opts.storeKey]?.awarenesses.set(entity_id, awareness)
+      }
+    }
   }
 
   private async onDocumentUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
@@ -685,7 +664,7 @@ export class CuboCrdtClient<M> {
       return
     }
 
-    const doc = this.store[opts.storeKey]?.docs.get(entity_id)
+    const doc = this.docs.get(`${ctx.entity}:${ctx.entity_id}`)
     if (!doc) {
       console.warn('[CRDT] onDocumentUpdate: doc not exists', { ctx, opts })
       return
@@ -694,20 +673,20 @@ export class CuboCrdtClient<M> {
     const update = new Uint8Array(ctx.data as any)
 
     if (opts?.onBeforeUpdate) {
-      const result = await opts.onBeforeUpdate(doc, update, ctx, opts)
+      const result = await opts.onBeforeUpdate(doc.doc, update, ctx, opts)
       if (!result) {
         return
       }
     }
 
     // обновляем yjs-ный документ
-    applyUpdate(doc, update, { react: false })
+    applyUpdate(doc.doc, update, { react: false })
 
     // обновляем документ в реактивном хранилище
-    this.applyRowJson(opts.storeKey, entity_id, doc)
+    this.applyRowJson(opts.storeKey, entity_id, doc.doc)
 
     if (opts?.onAfterUpdate) {
-      await opts.onAfterUpdate(doc, update, ctx, opts)
+      await opts.onAfterUpdate(doc.doc, update, ctx, opts)
     }
   }
 
@@ -717,23 +696,21 @@ export class CuboCrdtClient<M> {
       return
     }
 
-    const doc = this.store[opts.storeKey]?.docs.get(entity_id)
+    const doc = this.docs.get(`${ctx.entity}:${ctx.entity_id}`)
     if (!doc) {
       console.warn('[CRDT] onDocumentDelete: doc not exists', { ctx, opts })
       return
     }
 
     if (opts?.onBeforeDelete) {
-      const result = await opts.onBeforeDelete(doc, ctx, opts)
+      const result = await opts.onBeforeDelete(doc.doc, ctx, opts)
       if (!result) {
         return
       }
     }
 
-    // console.log('onDocumentDelete', ctx, opts)
-
-    doc.destroy()
-    this.store[opts.storeKey]?.docs.delete(entity_id)
+    doc.doc.destroy()
+    this.docs.delete(`${ctx.entity}:${ctx.entity_id}`)
 
     const index = this.store[opts.storeKey]?.state.rows.findIndex((r: any) => r.id === entity_id)
     if (index !== undefined && index >= 0) {
@@ -753,7 +730,7 @@ export class CuboCrdtClient<M> {
     }
 
     if (opts?.onAfterDelete) {
-      await opts.onAfterDelete(doc, ctx, opts)
+      await opts.onAfterDelete(doc.doc, ctx, opts)
     }
   }
 
@@ -788,7 +765,9 @@ export class CuboCrdtClient<M> {
     const ids = data.ids.filter((id) => Number.isFinite(id))
     const idsSet = new Set(ids)
 
-    for (const [entity_id, doc] of item.docs) {
+    for (const row of item.state.rows) {
+      const entity_id = (row as any).id
+
       if (idsSet.has(entity_id)) {
         continue
       }
@@ -801,14 +780,15 @@ export class CuboCrdtClient<M> {
         item.awarenesses.delete(entity_id)
       }
 
-      doc.destroy()
-      item.docs.delete(entity_id)
+      const doc = this.docs.get(`${ctx.entity}:${entity_id}`)
+      if (doc) {
+        doc.doc.destroy()
+        this.docs.delete(`${ctx.entity}:${entity_id}`)
+      }
     }
 
     const rowsById = new Map(item.state.rows.map((row: any) => [Number(row.id), row]))
-    const orderedRows = ids
-      .map((id) => rowsById.get(id))
-      .filter((row) => row !== undefined)
+    const orderedRows = ids.map((id) => rowsById.get(id)).filter((row) => row !== undefined)
 
     item.state.rows.splice(0, item.state.rows.length, ...orderedRows)
     item.state.totals = data.totals || {}

package/src/client/types/document.ts

@@ -1,8 +1,14 @@
+import { Doc } from 'yjs'
 import { CuboCrdtClientUseOptions } from '..'
 import { CuboCrdtExposeStrategy } from '../../types'
 
 import { CuboCrdtClientBaseOptions } from './utils'
 
+export type CuboCrdtClientDoc = {
+  doc: Doc
+  subscribes: Set<string>
+}
+
 export type CuboCrdtClientDocOrigin = {
   // сохранять ли на бэке в дебаунсе
   store?: boolean

package/src/client/types/index.ts

@@ -1,15 +1,10 @@
 import { type WsClient } from '@cuboapp/ws'
 import { ComputedRef } from 'vue'
 import { Awareness } from 'y-protocols/awareness'
-import { type Doc } from 'yjs'
 
-import {
-  CuboCrdtAction,
-  CuboCrdtListSyncData,
-  CuboCrdtListTotals,
-  CuboCrdtSubscriptionStatus
-} from '../../types'
+import { CuboCrdtAction, CuboCrdtListSyncData, CuboCrdtListTotals, CuboCrdtSubscriptionStatus } from '../../types'
 
+import { Doc } from 'yjs'
 import { CuboCrdtClientBaseOptions } from './utils'
 
 export * from './document'
@@ -45,7 +40,6 @@ export type CuboCrdtClientSubscribeEvent = {
 export type CuboCrdtClientList<T> = {
   subscribe_id: string
   storeKey: string
-  docs: ComputedRef<Map<number, Doc> | undefined>
   awarenesses?: ComputedRef<Map<number, Awareness> | undefined>
   subscribe: (filters?: any) => void
   upgrade: (filters?: any) => void
@@ -64,7 +58,7 @@ export type CuboCrdtClientList<T> = {
 export type CuboCrdtClientRow<T> = {
   subscribe_id: string
   storeKey: string
-  doc: ComputedRef<Doc | undefined>
+  doc: Doc
   awareness?: ComputedRef<Awareness | undefined>
   subscribe: () => void
   upgrade: (filters?: any) => void

package/src/client/types/store.ts

@@ -1,12 +1,7 @@
 import { Reactive } from 'vue'
-import { Doc } from 'yjs'
 import { Awareness } from 'y-protocols/awareness'
 
-import {
-  CuboCrdtKey,
-  CuboCrdtListTotals,
-  CuboCrdtSubscriptionStatus
-} from '../../types'
+import { CuboCrdtKey, CuboCrdtListTotals, CuboCrdtSubscriptionStatus } from '../../types'
 
 export type CuboCrdtClientStoreItem<T> = {
   state: Reactive<{
@@ -18,7 +13,6 @@ export type CuboCrdtClientStoreItem<T> = {
     totals: CuboCrdtListTotals
     revision: number
   }>
-  docs: Map<number, Doc>
   awarenesses: Map<number, Awareness>
 }
 export type CuboCrdtClientStore<M> = Partial<{

package/src/server/document/index.ts

@@ -1,23 +1,12 @@
-import { cloneDeep, pick } from '@cuboapp/utils'
+import { cloneDeep, debounce, pick } from '@cuboapp/utils'
 import { applyUpdate, Doc, encodeStateAsUpdate } from 'yjs'
 import { Awareness, encodeAwarenessUpdate } from 'y-protocols/awareness'
 
-import {
-  CuboCrdtServerDocumentOptions,
-  CuboCrdtServerDocumentOrigin,
-  CuboCrdtServerDocumentPendingStore
-} from '../types'
-import { getCrdtStoreChangeKey } from '../utils'
-
-const STORE_DEBOUNCE_MS = 300
+import { CuboCrdtServerDocumentOptions, CuboCrdtServerDocumentOrigin } from '../types'
 
 export class CuboCrdtServerDocument {
   private ydoc: Doc
   private persistedState: object = {}
-  private observedState: object = {}
-  private storeQueue: Promise<void> = Promise.resolve()
-  private pendingStore?: CuboCrdtServerDocumentPendingStore
-  private storeTimeout?: ReturnType<typeof setTimeout>
   public awareness: Awareness
   public awarenessBySubscribe = new Map<string, Set<number>>()
 
@@ -30,11 +19,31 @@ export class CuboCrdtServerDocument {
     })
 
     if (opts.awareness) {
-      this.enableAwareness()
+      this.awareness = new Awareness(this.ydoc)
+      this.awareness.setLocalState(null)
+
+      this.awareness.on('update', ({ added, updated, removed }, origin: CuboCrdtServerDocumentOrigin) => {
+        const subId = origin?.subscribe_id
+
+        if (subId) {
+          let set = this.awarenessBySubscribe.get(subId)
+          if (!set) {
+            set = new Set()
+            this.awarenessBySubscribe.set(subId, set)
+          }
+
+          added.concat(updated).forEach((id) => set!.add(id))
+          removed.forEach((id) => set!.delete(id))
+        }
+
+        const changed = added.concat(updated).concat(removed)
+        const update = encodeAwarenessUpdate(this.awareness!, changed)
+
+        this.opts?.onAwarenessUpdate?.(update, origin)
+      })
     }
 
     this.persistedState = cloneDeep(opts.initialState ?? {})
-    this.observedState = cloneDeep(opts.initialState ?? {})
 
     // записываем исходное состояние
     this.write(opts.initialState ?? {})
@@ -49,8 +58,7 @@ export class CuboCrdtServerDocument {
       this.opts?.onUpdate?.(data, origin)
       // }
 
-      // Состояние отслеживается синхронно с Y.Doc. Для клиентских изменений
-      // debounceStore сам обновит observedState после вычисления leaf-diff.
+      // если нужно сохранять стейт документа - вызываем store по дебаунсу
       if (origin?.store) {
         const row = this.getJson()
         const body = pick(row, origin.keys ?? Object.keys(row))
@@ -60,41 +68,10 @@ export class CuboCrdtServerDocument {
             console.error('[CRDT] store document', this.name, error)
           })
         }
-      } else {
-        this.observedState = cloneDeep(this.getJson())
       }
     })
   }
 
-  public enableAwareness() {
-    if (this.awareness) {
-      return
-    }
-
-    this.awareness = new Awareness(this.ydoc)
-    this.awareness.setLocalState(null)
-
-    this.awareness.on('update', ({ added, updated, removed }, origin: CuboCrdtServerDocumentOrigin) => {
-      const subId = origin?.subscribe_id
-
-      if (subId) {
-        let set = this.awarenessBySubscribe.get(subId)
-        if (!set) {
-          set = new Set()
-          this.awarenessBySubscribe.set(subId, set)
-        }
-
-        added.concat(updated).forEach((id) => set!.add(id))
-        removed.forEach((id) => set!.delete(id))
-      }
-
-      const changed = added.concat(updated).concat(removed)
-      const update = encodeAwarenessUpdate(this.awareness!, changed)
-
-      this.opts?.onAwarenessUpdate?.(update, origin)
-    })
-  }
-
   public get name() {
     return this.opts.name
   }
@@ -152,117 +129,17 @@ export class CuboCrdtServerDocument {
   }
 
   destroy() {
-    this.flushPendingStore()
     this.awareness?.destroy()
     this.ydoc.destroy()
   }
 
-  public store(body: object, origin: CuboCrdtServerDocumentOrigin, row = this.getJson()) {
-    const queuedBody = cloneDeep(body)
-    const queuedRow = cloneDeep(row)
-
-    // debounce ограничивает частоту вызовов, но не сериализует async store.
-    // Без очереди следующий PATCH мог завершиться раньше предыдущего и затем
-    // быть затёрт старым полным снимком составного поля (например case.extra).
-    const current = this.storeQueue
-      .catch(() => undefined)
-      .then(async () => {
-        const previousRow = this.getPersistedState()
-
-        await this.opts?.onStore?.(queuedBody, origin, {
-          previousRow,
-          row: queuedRow
-        })
-        this.setPersistedState(queuedRow)
-      })
-
-    this.storeQueue = current
-    return current
-  }
-
-  /**
-   * Схлопывает только соседние изменения одного origin и одного набора
-   * leaf-путей. Смена пользователя или поля немедленно фиксирует предыдущий
-   * пакет, сохраняя фактический порядок collaborative-обновлений.
-   */
-  public debounceStore(body: object, origin: CuboCrdtServerDocumentOrigin) {
-    const row = cloneDeep(this.getJson())
-    const bodyKeys = Object.keys(body)
-    const previousBody = pick(this.observedState, bodyKeys)
-    const changeKey = getCrdtStoreChangeKey(previousBody, body)
-    const originKey = `${origin.client_id || ''}:${origin.subscribe_id || ''}`
-
-    this.observedState = cloneDeep(row)
-
-    if (!changeKey) {
-      return Promise.resolve()
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      const sameBatch = this.pendingStore?.originKey === originKey &&
-        this.pendingStore.changeKey === changeKey
-
-      if (this.pendingStore && !sameBatch) {
-        this.flushPendingStore()
-      }
-
-      if (!this.pendingStore) {
-        this.pendingStore = {
-          body: cloneDeep(body),
-          changeKey,
-          origin: cloneDeep(origin),
-          originKey,
-          row,
-          waiters: []
-        }
-      } else {
-        const keys = new Set([
-          ...(this.pendingStore.origin.keys || []),
-          ...(origin.keys || [])
-        ])
-
-        this.pendingStore.body = {
-          ...this.pendingStore.body,
-          ...cloneDeep(body)
-        }
-        this.pendingStore.origin = {
-          ...cloneDeep(origin),
-          keys: [...keys]
-        }
-        this.pendingStore.row = row
-      }
+  public async store(body: object, origin: CuboCrdtServerDocumentOrigin) {
+    const previousRow = this.getPersistedState()
+    const row = this.getJson()
 
-      this.pendingStore.waiters.push({ resolve, reject })
-      this.schedulePendingStore()
-    })
+    await this.opts?.onStore?.(body, origin, { previousRow, row })
+    this.setPersistedState(row)
   }
 
-  /** Перезапускает trailing debounce для текущего однородного пакета. */
-  private schedulePendingStore() {
-    if (this.storeTimeout) {
-      clearTimeout(this.storeTimeout)
-    }
-
-    this.storeTimeout = setTimeout(() => this.flushPendingStore(), STORE_DEBOUNCE_MS)
-  }
-
-  /** Передаёт накопленный пакет в общую последовательную очередь записи. */
-  private flushPendingStore() {
-    if (!this.pendingStore) {
-      return
-    }
-
-    if (this.storeTimeout) {
-      clearTimeout(this.storeTimeout)
-      this.storeTimeout = undefined
-    }
-
-    const pending = this.pendingStore
-    this.pendingStore = undefined
-
-    this.store(pending.body, pending.origin, pending.row).then(
-      () => pending.waiters.forEach(({ resolve }) => resolve()),
-      (error) => pending.waiters.forEach(({ reject }) => reject(error))
-    )
-  }
+  public debounceStore = debounce(this.store.bind(this), 300)
 }

package/src/server/index.ts

@@ -4,11 +4,7 @@ import { applyAwarenessUpdate, encodeAwarenessUpdate, removeAwarenessStates } fr
 
 import { CUBO_CRDT_EVENT } from '../constants'
 import { CuboCrdtAction, CuboCrdtListSyncData, CuboCrdtMutation } from '../types'
-import {
-  areCrdtListIdsEqual,
-  areCrdtListTotalsEqual,
-  checkRowIsSutable
-} from '../utils'
+import { areCrdtListIdsEqual, areCrdtListTotalsEqual, checkRowIsSutable } from '../utils'
 
 import { CuboCrdtClientDocOrigin } from '../client'
 import { CuboCrdtServerDocument } from './document'
@@ -437,12 +433,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
         const generation = this.subscribeGenerations.get(subscribe_id) || 0
         const forceSync = state.forceSync
         state.forceSync = false
-        const reconciled = await this.reconcileSubscribe(
-          client,
-          subscribe,
-          generation,
-          forceSync
-        )
+        const reconciled = await this.reconcileSubscribe(client, subscribe, generation, forceSync)
         if (!reconciled && forceSync) {
           state.forceSync = true
         }
@@ -454,11 +445,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     return state.running
   }
 
-  private requestSubscribeRefresh(
-    subscribe_id: string,
-    immediate = false,
-    forceSync = immediate
-  ) {
+  private requestSubscribeRefresh(subscribe_id: string, immediate = false, forceSync = immediate) {
     const state = this.getSubscribeRefreshState(subscribe_id)
     state.dirty = true
     state.forceSync ||= forceSync
@@ -544,16 +531,8 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     }
 
     if (mutation.previousRow) {
-      const previousSuitable = this.checkRowIsSutable(
-        mutation.previousRow,
-        subscribe,
-        entity
-      )
-      const currentSuitable = this.checkRowIsSutable(
-        mutation.row,
-        subscribe,
-        entity
-      )
+      const previousSuitable = this.checkRowIsSutable(mutation.previousRow, subscribe, entity)
+      const currentSuitable = this.checkRowIsSutable(mutation.row, subscribe, entity)
 
       if (previousSuitable !== currentSuitable) {
         return true
@@ -605,10 +584,6 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
 
     let document = this.documents.get(documentName)
     if (document) {
-      if (awareness) {
-        document.enableAwareness()
-      }
-
       // Освежаем существующий документ строкой из БД.
       //
       // Раньше документ возвращался как есть, а подписка отправляла клиенту его
@@ -840,13 +815,9 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
 
         const subscribeSutable = this.checkSubscribeIsSutable(origin, subscribe)
         const documentExistsInSubscribe = this.subscribesByDocument.get(document.name)?.has(subscribe.id)
-        const rowSutable = subscribe.paginated
-          ? documentExistsInSubscribe
-          : this.checkRowIsSutable(row, subscribe, entity)
+        const rowSutable = subscribe.paginated ? documentExistsInSubscribe : this.checkRowIsSutable(row, subscribe, entity)
 
-        const sutable = subscribeSutable && (subscribe.paginated
-          ? documentExistsInSubscribe
-          : rowSutable || documentExistsInSubscribe)
+        const sutable = subscribeSutable && (subscribe.paginated ? documentExistsInSubscribe : rowSutable || documentExistsInSubscribe)
 
         if (sutable) {
           if (this.debug && !rowSutable) {
@@ -947,21 +918,13 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     }
   }
 
-  private async reconcileSubscribe(
-    client: WsServerSocket,
-    subscribe: CuboCrdtServerSubscribe,
-    generation: number,
-    forceSync: boolean
-  ) {
+  private async reconcileSubscribe(client: WsServerSocket, subscribe: CuboCrdtServerSubscribe, generation: number, forceSync: boolean) {
     const fetched = await this.options.fetchRows?.(client, subscribe)
     const result = Array.isArray(fetched)
       ? { rows: fetched, totals: subscribe.totals }
       : { rows: fetched?.rows || [], totals: fetched?.totals || subscribe.totals }
 
-    if (
-      this.subscribes.get(subscribe.id) !== subscribe ||
-      this.subscribeGenerations.get(subscribe.id) !== generation
-    ) {
+    if (this.subscribes.get(subscribe.id) !== subscribe || this.subscribeGenerations.get(subscribe.id) !== generation) {
       return false
     }
 
@@ -1034,10 +997,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     }
 
     const idsChanged = !areCrdtListIdsEqual(subscribe.row_ids, nextIds)
-    const totalsChanged = !areCrdtListTotalsEqual(
-      subscribe.totals,
-      result.totals
-    )
+    const totalsChanged = !areCrdtListTotalsEqual(subscribe.totals, result.totals)
 
     subscribe.row_ids = nextIds
     subscribe.totals = result.totals
@@ -1076,10 +1036,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     if (upgrade.filters !== undefined) {
       subscribe.filters = cloneDeep(upgrade.filters || {})
     }
-    subscribe.paginated = this.resolvePaginated(
-      subscribe.filters,
-      upgrade.paginated
-    )
+    subscribe.paginated = this.resolvePaginated(subscribe.filters, upgrade.paginated)
 
     return this.requestSubscribeRefresh(subscribe.id, true)
   }

package/src/server/types/document.ts

@@ -5,20 +5,6 @@ export type CuboCrdtServerDocumentStoreContext = {
   row: object
 }
 
-export type CuboCrdtServerDocumentStoreWaiter = {
-  resolve: () => void
-  reject: (reason?: unknown) => void
-}
-
-export type CuboCrdtServerDocumentPendingStore = {
-  body: object
-  changeKey: string
-  origin: CuboCrdtServerDocumentOrigin
-  originKey: string
-  row: object
-  waiters: CuboCrdtServerDocumentStoreWaiter[]
-}
-
 export type CuboCrdtServerDocumentOptions = {
   name: string
   onStore?: (

package/src/server/utils/index.ts

@@ -1,41 +0,0 @@
-const isObject = (value: unknown): value is Record<string, unknown> => {
-  return value !== null && typeof value === 'object'
-}
-
-const collectChangedPaths = (
-  previous: unknown,
-  current: unknown,
-  path: string,
-  result: string[]
-) => {
-  if (Object.is(previous, current)) {
-    return
-  }
-
-  if (!isObject(previous) || !isObject(current)) {
-    result.push(path || '$')
-    return
-  }
-
-  const keys = new Set([
-    ...Object.keys(previous),
-    ...Object.keys(current)
-  ])
-
-  for (const key of [...keys].sort()) {
-    const nextPath = Array.isArray(previous) || Array.isArray(current)
-      ? `${path}[${key}]`
-      : path ? `${path}.${key}` : key
-
-    collectChangedPaths(previous[key], current[key], nextPath, result)
-  }
-}
-
-/** Возвращает стабильный ключ фактически изменённых leaf-путей объекта. */
-export const getCrdtStoreChangeKey = (previous: object, current: object) => {
-  const paths: string[] = []
-
-  collectChangedPaths(previous, current, '', paths)
-
-  return paths.join('|')
-}