@cuboapp/crdt 1.0.23 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/crdt",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "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, encodeStateAsUpdate, encodeStateVector } from 'yjs'
+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,9 @@ export * from './types'
 
 export class CuboCrdtClient<M> {
   public store: CuboCrdtClientStore<M> = {}
+  // Реактивен только реестр: Vue отслеживает set/delete и повторно вычисляет
+  // computed(useDoc). Сами Y.Doc/Awareness остаются исходными объектами без proxy.
+  public docs = new Map<string, CuboCrdtClientDoc>()
 
   private listeners: Map<string, Map<string, (ctx: CuboCrdtClientSubscribeEvent) => void | Promise<void>>> = new Map()
 
@@ -110,6 +110,11 @@ export class CuboCrdtClient<M> {
 
     this.ws.deleteHandler(CUBO_CRDT_EVENT.EVENT)
 
+    for (const document of this.docs.values()) {
+      document.awareness?.destroy()
+      document.doc.destroy()
+    }
+    this.docs.clear()
     this.listeners.clear()
     this.subscriptions.clear()
   }
@@ -233,9 +238,7 @@ export class CuboCrdtClient<M> {
       })
 
       this.store[storeKey] = {
-        state,
-        docs: shallowReactive(new Map()),
-        awarenesses: shallowReactive(new Map())
+        state
       }
     }
 
@@ -260,6 +263,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 +334,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)
+          }
+        })
       }
 
       // отписываемся на фронте
@@ -347,21 +349,13 @@ export class CuboCrdtClient<M> {
       this.store[storeKey]!.state.status = 'idle'
       this.store[storeKey]!.state.error = undefined
 
+      const item = this.store[storeKey]
+      item?.state.rows.forEach((row) => {
+        this.detachDocument(`${entity}`, (row as any).id, subscribe_id, storeKey)
+      })
+
       // очищаем стор
       if (clear !== false) {
-        const item = this.store[storeKey]
-        if (item) {
-          item.awarenesses?.forEach((a) => {
-            removeAwarenessStates(a, [a.doc.clientID], 'unsubscribe')
-
-            a.setLocalState(null)
-            a.destroy()
-          })
-          item.awarenesses?.clear()
-          item.docs?.forEach((d) => d.destroy())
-          item.docs?.clear()
-        }
-
         this.store[storeKey] = undefined
       }
     }
@@ -383,8 +377,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),
       ready: () => computed(() => this.store[storeKey]?.state.status === 'ready'),
@@ -397,6 +389,10 @@ export class CuboCrdtClient<M> {
     }
   }
 
+  public useDoc<K extends Extract<keyof M, string>>(entity: K, id: number) {
+    return this.docs.get(`${entity}:${id}`)
+  }
+
   public useRow<K extends Extract<keyof M, string>, T = CuboCrdtKey<K, M>>(
     entity: K | string,
     id: number,
@@ -404,20 +400,7 @@ 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, {
+    const { subscribe_id, storeKey, subscribe, upgrade, unsubscribe, subscribed, loading, ready, status, error } = this.useList(entity, {
       ...opts,
       filters: opts?.filters ?? { id },
       storeKey: opts?.storeKey ?? `${entity}:${id}`
@@ -426,8 +409,6 @@ export class CuboCrdtClient<M> {
     return {
       subscribe_id,
       storeKey,
-      doc: computed(() => docs.value?.get(id)),
-      awareness: opts?.awareness ? computed(() => awarenesses?.value?.get(id)) : undefined,
       subscribe,
       upgrade,
       unsubscribe,
@@ -450,92 +431,30 @@ export class CuboCrdtClient<M> {
     dto: K extends Extract<keyof M, string> ? Partial<M[K]> : object,
     opts?: CuboCrdtClientDocOrigin
   ) {
-    // Если строка открыта через useRow, mutating API работает только с её
-    // каноническим документом. Списки могут содержать тот же id, но не должны
-    // становиться источником записи для карточки.
-    const rowStore = this.store[`${entity}:${entity_id}`]
-    const store = rowStore?.state.status === 'ready' && rowStore.docs.has(entity_id)
-      ? rowStore
-      : [...this.subscriptions.values()]
-          .filter((subscription) => subscription.entity === entity)
-          .map((subscription) => this.store[subscription.storeKey])
-          .find((candidate) => candidate?.docs.has(entity_id) && candidate.state.status === 'ready')
-    const document = store?.docs.get(entity_id)
-
-    if (!store || !document) {
-      return false
-    }
-
-    const map = document.getMap()
-    const toUpdate = Object.fromEntries(
-      Object.entries(dto).filter(([key, value]) => map.get(key) !== value)
-    )
-
-    if (!Object.keys(toUpdate).length) {
-      // Состояние уже совпадает (например, update успел прийти из другой
-      // вкладки). Это успешный no-op, а не ошибка изменения.
-      return true
-    }
-
-    const origin: CuboCrdtClientDocOrigin = {
-      store: opts?.store ?? true,
-      expose: opts?.expose ?? 'other',
-      keys: opts?.keys ?? Object.keys(toUpdate),
-      // update() сам отправляет ровно один пакет ниже. Общий listener остаётся
-      // для изменений, которые создаются напрямую сторонними Yjs-binding'ами.
-      react: false
-    }
-
-    const stateVector = encodeStateVector(document)
-
-    // Одна сущность может присутствовать в нескольких подписках с разными
-    // storeKey. Мутацию отправляем только из одного документа: остальные
-    // подписки получат подтверждённый update через обычную CRDT-рассылку.
-    document.transact(() => {
-      Object.entries(toUpdate).forEach(([key, value]) => {
-        map.set(key, value)
-      })
-    }, origin)
+    const storeKey = `${entity}:${entity_id}`
 
-    const update = encodeStateAsUpdate(document, stateVector)
-    const receipt = this.ws
-      .request(
-        {
-          method: CUBO_CRDT_EVENT.EVENT,
-          data: {
-            action: 'update',
-            entity,
-            entity_id,
-            data: Array.from(update),
-            origin: {
-              ...pick(origin, ['store', 'keys', 'expose']),
-              subscribe_id: [...this.subscriptions.entries()]
-                .find(([, subscription]) => this.store[subscription.storeKey] === store)?.[0]
-            }
-          }
-        },
-        { wait: true, timeout: 10_000 }
-      )
-      .then(() => true)
-      .catch((error) => {
-        console.error('[CRDT] update request failed', error)
-        return false
-      })
+    const document = this.docs.get(storeKey)
 
-    // Этот документ является каноническим локальным состоянием строки. Обновляем
-    // его реактивную строку сразу, а другие подписки получат тот же Yjs-update
-    // через серверную рассылку.
-    this.applyRowJson(`${entity}:${entity_id}`, entity_id, document)
+    if (document) {
+      const map = document.doc.getMap()
+      const toUpdate = Object.fromEntries(Object.entries(dto).filter(([key, value]) => map.get(key) !== value))
 
-    const row = store.state.rows.find((item: any) => Number(item.id) === Number(entity_id))
+      if (Object.keys(toUpdate).length) {
+        const origin: CuboCrdtClientDocOrigin = {
+          store: opts?.store ?? true,
+          expose: opts?.expose ?? 'other',
+          keys: opts?.keys ?? Object.keys(toUpdate),
+          react: true,
+          subscribe_id: opts?.subscribe_id ?? document.subscribes.values().next().value
+        }
 
-    if (row) {
-      Object.entries(toUpdate).forEach(([key, value]) => {
-        row[key] = value
-      })
+        document.doc.transact(() => {
+          Object.entries(toUpdate).forEach(([key, value]) => {
+            map.set(key, value)
+          })
+        }, origin)
+      }
     }
-
-    return receipt
   }
 
   public upgrade(subscribe_id: string, filters?: Record<string, any>) {
@@ -579,61 +498,94 @@ export class CuboCrdtClient<M> {
       })
   }
 
-  // апсертит строку в реактивное хранилище из текущего состояния 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 {
-      rows.push(json)
+  private applyDocumentRows(entity_id: number, document: CuboCrdtClientDoc) {
+    for (const subscribe_id of document.subscribes) {
+      const subscription = this.subscriptions.get(subscribe_id)
+      if (subscription) {
+        this.applyRowJson(subscription.storeKey, entity_id, document.doc)
+      }
     }
   }
 
-  private ensureDocumentAwareness(
-    ctx: CuboCrdtClientSubscribeEvent,
-    opts: CuboCrdtClientDocUpdateOptions,
-    doc: Doc,
-    entity_id: number
-  ) {
+  private attachDocument(entity: string, entity_id: number, document: CuboCrdtClientDoc, opts: CuboCrdtClientDocUpdateOptions) {
+    document.subscribes.add(opts.subscribe_id)
+
     if (!opts.awareness) {
       return
     }
 
-    let awareness = this.store[opts.storeKey]?.awarenesses.get(entity_id)
+    document.awarenessSubscribes.add(opts.subscribe_id)
 
-    if (awareness) {
+    if (!document.awareness) {
+      const awareness = new Awareness(document.doc)
+
+      awareness.on('update', ({ added, updated, removed }, origin) => {
+        if (origin === 'remote') {
+          return
+        }
+
+        const subscribe_id = document.awarenessSubscribes.values().next().value
+        if (!subscribe_id) {
+          return
+        }
+
+        const changed = added.concat(updated).concat(removed)
+        const update = encodeAwarenessUpdate(awareness, changed)
+
+        void this.ws
+          .request({
+            method: CUBO_CRDT_EVENT.EVENT,
+            data: {
+              action: 'awareness',
+              entity,
+              entity_id,
+              data: Array.from(update),
+              origin: { expose: 'other', subscribe_id }
+            }
+          })
+          .catch((error) => console.error('[CRDT] awareness request failed', error))
+      })
+      document.awareness = awareness
+    }
+  }
+
+  private detachDocument(entity: string, entity_id: number, subscribe_id: string, storeKey: string) {
+    const key = `${entity}:${entity_id}`
+    const document = this.docs.get(key)
+    if (!document) {
       return
     }
 
-    awareness = new Awareness(doc)
+    document.subscribes.delete(subscribe_id)
+    document.awarenessSubscribes.delete(subscribe_id)
 
-    awareness.on('update', ({ added, updated, removed }, origin) => {
-      if (origin === 'remote') {
-        return
-      }
+    if (!document.awarenessSubscribes.size && document.awareness) {
+      removeAwarenessStates(document.awareness, [document.awareness.doc.clientID], 'unsubscribe')
+      document.awareness.setLocalState(null)
+      document.awareness.destroy()
+      document.awareness = undefined
+    }
 
-      const changed = added.concat(updated).concat(removed)
-      const update = encodeAwarenessUpdate(awareness!, changed)
+    if (!document.subscribes.size) {
+      document.doc.destroy()
+      this.docs.delete(key)
+    }
+  }
 
-      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 }
-        }
-      })
-    })
+  // апсертит строку в реактивное хранилище из текущего состояния 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
+    }
 
-    this.store[opts.storeKey]?.awarenesses.set(entity_id, awareness)
+    const index = rows.findIndex((r: any) => r.id === entity_id)
+    if (index >= 0) {
+      rows[index] = json
+    } else {
+      rows.push(json)
+    }
   }
 
   private async onDocumentCreate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
@@ -642,7 +594,7 @@ export class CuboCrdtClient<M> {
       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-документ
@@ -651,13 +603,13 @@ 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)
+      this.attachDocument(ctx.entity, entity_id, existing, opts)
+      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)
 
@@ -668,10 +620,22 @@ export class CuboCrdtClient<M> {
       }
     }
 
-    applyUpdate(doc, update, { react: false })
+    applyUpdate(yjsDoc, update, { react: false })
+
+    const document: CuboCrdtClientDoc = {
+      doc: yjsDoc,
+      subscribes: new Set(),
+      awarenessSubscribes: new Set()
+    }
+    this.attachDocument(ctx.entity, entity_id, document, opts)
+    // Публикуем контейнер реактивному реестру только после полной инициализации.
+    // Тогда первый computed(useDoc) не увидит промежуточный doc без Awareness.
+    this.docs.set(`${ctx.entity}:${ctx.entity_id}`, document)
 
     // подписываемся на обновления документа
-    doc.on('update', (update, origin: CuboCrdtClientDocOrigin) => {
+    yjsDoc.on('update', (update, origin: CuboCrdtClientDocOrigin) => {
+      this.applyDocumentRows(entity_id, document)
+
       // react = false, если это апдейт с бэка
       if (origin?.react !== false) {
         const data: CuboCrdtServerDocumentIncomingAction = {
@@ -685,22 +649,21 @@ export class CuboCrdtClient<M> {
             // приходят без expose и сервер эхом шлёт их обратно самому автору.
             expose: 'other',
             ...pick(origin || {}, ['store', 'keys', 'expose']),
-            subscribe_id: opts?.subscribe_id
+            subscribe_id: origin?.subscribe_id ?? document.subscribes.values().next().value
           }
         }
 
-        void this.ws.request({
-          method: CUBO_CRDT_EVENT.EVENT,
-          data
-        }).catch((error) => console.error('[CRDT] update request failed', error))
+        void this.ws
+          .request({
+            method: CUBO_CRDT_EVENT.EVENT,
+            data
+          })
+          .catch((error) => console.error('[CRDT] update request failed', error))
       }
     })
 
-    // добавляем документ в хранилище документов
-    this.store[opts.storeKey]?.docs.set(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) {
@@ -713,10 +676,8 @@ 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)
   }
 
   private async onDocumentUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
@@ -725,7 +686,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
@@ -734,20 +695,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.applyDocumentRows(entity_id, doc)
 
     if (opts?.onAfterUpdate) {
-      await opts.onAfterUpdate(doc, update, ctx, opts)
+      await opts.onAfterUpdate(doc.doc, update, ctx, opts)
     }
   }
 
@@ -757,43 +718,34 @@ 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)
-
-    const index = this.store[opts.storeKey]?.state.rows.findIndex((r: any) => r.id === entity_id)
-    if (index !== undefined && index >= 0) {
-      this.store[opts.storeKey]?.state.rows.splice(index, 1)
-    } else {
-      if (this.debug) {
-        console.log('[CRDT] row not found', index, ctx, opts)
+    for (const subscribe_id of doc.subscribes) {
+      const subscription = this.subscriptions.get(subscribe_id)
+      const item = subscription && this.store[subscription.storeKey]
+      const index = item?.state.rows.findIndex((row: any) => row.id === entity_id) ?? -1
+      if (item && index >= 0) {
+        item.state.rows.splice(index, 1)
       }
     }
 
-    const awareness = this.store[opts.storeKey]?.awarenesses.get(entity_id)
-    if (awareness) {
-      removeAwarenessStates(awareness, [awareness.doc.clientID], 'unsubscribe')
-
-      awareness.destroy()
-      this.store[opts.storeKey]?.awarenesses?.delete(entity_id)
-    }
+    doc.awareness?.destroy()
+    doc.doc.destroy()
+    this.docs.delete(`${ctx.entity}:${ctx.entity_id}`)
 
     if (opts?.onAfterDelete) {
-      await opts.onAfterDelete(doc, ctx, opts)
+      await opts.onAfterDelete(doc.doc, ctx, opts)
     }
   }
 
@@ -828,27 +780,18 @@ 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
       }
 
-      const awareness = item.awarenesses.get(entity_id)
-      if (awareness) {
-        removeAwarenessStates(awareness, [awareness.doc.clientID], 'sync')
-        awareness.setLocalState(null)
-        awareness.destroy()
-        item.awarenesses.delete(entity_id)
-      }
-
-      doc.destroy()
-      item.docs.delete(entity_id)
+      this.detachDocument(ctx.entity, entity_id, opts.subscribe_id, opts.storeKey)
     }
 
     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 || {}
@@ -865,15 +808,15 @@ export class CuboCrdtClient<M> {
       return
     }
 
-    const awareness = this.store[opts.storeKey]?.awarenesses?.get(entity_id)
-    if (!awareness) {
+    const doc = this.docs.get(`${ctx.entity}:${ctx.entity_id}`)
+    if (!doc?.awareness) {
       return
     }
 
     const update = new Uint8Array(ctx.data as any)
 
     try {
-      applyAwarenessUpdate(awareness, update, 'remote')
+      applyAwarenessUpdate(doc.awareness, update, 'remote')
     } catch (e) {
       console.warn('[CRDT] applyAwarenessUpdate failed ', e)
     }

package/src/client/types/document.ts

@@ -1,8 +1,18 @@
+import { Awareness } from 'y-protocols/awareness'
+import { Doc } from 'yjs'
+
 import { CuboCrdtClientUseOptions } from '..'
 import { CuboCrdtExposeStrategy } from '../../types'
 
 import { CuboCrdtClientBaseOptions } from './utils'
 
+export type CuboCrdtClientDoc = {
+  doc: Doc
+  subscribes: Set<string>
+  awareness?: Awareness
+  awarenessSubscribes: Set<string>
+}
+
 export type CuboCrdtClientDocOrigin = {
   // сохранять ли на бэке в дебаунсе
   store?: boolean
@@ -15,6 +25,9 @@ export type CuboCrdtClientDocOrigin = {
 
   // куда раскатывать обновления - всем или всем кроме себя
   expose?: CuboCrdtExposeStrategy
+
+  // подписка, из которой инициировано локальное изменение
+  subscribe_id?: string
 }
 
 export type CuboCrdtClientDocUpdateOptions = { subscribe_id: string; storeKey: string } & Pick<

package/src/client/types/index.ts

@@ -1,14 +1,8 @@
 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 { CuboCrdtClientBaseOptions } from './utils'
 
@@ -45,7 +39,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,8 +57,6 @@ export type CuboCrdtClientList<T> = {
 export type CuboCrdtClientRow<T> = {
   subscribe_id: string
   storeKey: string
-  doc: ComputedRef<Doc | undefined>
-  awareness?: ComputedRef<Awareness | undefined>
   subscribe: () => void
   upgrade: (filters?: any) => void
   unsubscribe: (clear?: boolean) => void

package/src/client/types/store.ts

@@ -1,12 +1,6 @@
 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,8 +12,6 @@ export type CuboCrdtClientStoreItem<T> = {
     totals: CuboCrdtListTotals
     revision: number
   }>
-  docs: Map<number, Doc>
-  awarenesses: Map<number, Awareness>
 }
 export type CuboCrdtClientStore<M> = Partial<{
   [K in string]: CuboCrdtClientStoreItem<CuboCrdtKey<K, M>>

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'
@@ -129,6 +125,29 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
       }
 
       for (const row of data) {
+        const subscribe_id = row.origin?.subscribe_id
+        const subscribe = subscribe_id && this.subscribes.get(subscribe_id)
+        const documentName = `${row.entity}:${row.entity_id}`
+        const requiresActiveSubscription = row.action === 'update' || row.action === 'awareness'
+
+        if (
+          requiresActiveSubscription &&
+          (!subscribe ||
+            subscribe.client_id !== client.id ||
+            subscribe.entity !== row.entity ||
+            !this.documentsBySubscribe.get(subscribe_id)?.has(documentName))
+        ) {
+          if (this.debug) {
+            console.warn('[CRDT] ignored update from inactive subscription', {
+              action: row.action,
+              entity: row.entity,
+              entity_id: row.entity_id,
+              subscribe_id
+            })
+          }
+          continue
+        }
+
         const update = new Uint8Array(row.data)
         const origin: CuboCrdtServerDocumentOrigin = {
           ...(row.origin || {}),
@@ -197,6 +216,17 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     this.documentEvictions.clear()
 
     this.subscribes.forEach((sub) => this.ws.deleteHandler(sub.id))
+
+    const documents = [...this.documents.values()]
+    const results = await Promise.allSettled(documents.map((document) => document.flushStoreQueue()))
+    results.forEach((result, index) => {
+      if (result.status === 'rejected') {
+        console.error('[CRDT] flush document on destroy', documents[index]?.name, result.reason)
+      }
+    })
+    documents.forEach((document) => document.destroy())
+    this.documents.clear()
+    this.subscribesByDocument.clear()
   }
 
   public addClient(client: WsServerSocket<{ auth?: A }>) {
@@ -501,12 +531,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
         }
@@ -518,11 +543,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
@@ -608,16 +629,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
@@ -901,13 +914,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) {
@@ -1008,21 +1017,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
     }
 
@@ -1095,10 +1096,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
@@ -1137,10 +1135,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)
   }