@cuboapp/crdt 1.0.9 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/crdt",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "CRDT for CUBO",
   "main": "src/index.ts",
   "repository": "git@github.com:cuboapp/crdt.git",
@@ -15,6 +15,7 @@
     "@cuboapp/utils": "1.0.10",
     "@cuboapp/ws": "1.0.6",
     "ws": "^8.19.0",
+    "y-protocols": "^1.0.7",
     "yjs": "^13.6.29"
   },
   "peerDependencies": {

package/src/client/index.ts

@@ -1,6 +1,7 @@
 import { keyBy, pick, uuid } from '@cuboapp/utils'
 import { computed, reactive } from 'vue'
 import { applyUpdate, Doc } from 'yjs'
+import { applyAwarenessUpdate, Awareness, encodeAwarenessUpdate, removeAwarenessStates } from 'y-protocols/awareness'
 
 import { CUBO_CRDT_EVENT } from '../constants'
 import { CuboCrdtServerDocumentIncomingAction } from '../server'
@@ -16,13 +17,19 @@ import {
   CuboCrdtClientSubscribeEvent,
   CuboCrdtClientUseOptions
 } from './types'
+import { AsyncSerialQueue } from './queue'
 
 export * from './types'
 
 export class CuboCrdtClient<M> {
   public store: CuboCrdtClientStore<M> = {}
 
-  private listeners: Map<string, Map<string, (ctx: CuboCrdtClientSubscribeEvent) => void>> = new Map()
+  private listeners: Map<string, Map<string, (ctx: CuboCrdtClientSubscribeEvent) => void | Promise<void>>> = new Map()
+  private eventQueue = new AsyncSerialQueue({
+    errorMode: 'continue',
+    onError: (e) => console.error('[CRDT] inbound queue task failed', e),
+    maxSize: 10_000
+  })
 
   constructor(private opts: CuboCrdtClientOptions<M>) {
     opts.entities.forEach((e) => this.listeners.set(e, new Map()))
@@ -30,30 +37,33 @@ export class CuboCrdtClient<M> {
 
   async start() {
     this.ws.registerHandler(CUBO_CRDT_EVENT.EVENT, ({ message }) => {
-      let events: CuboCrdtClientSubscribeEvent[] = message.data as any
-      if (!Array.isArray(events)) {
-        events = [events as any]
-      }
-
-      // todo: perform events through queue in await mode
-      events.forEach((event) => {
-        const listeners = this.listeners.get(event.entity)
-
-        if (this.debug) {
-          console.log('[CRDT] incoming event', { listeners: listeners?.size, event })
-        }
-
-        if (event.subscribe_id) {
-          const listener = listeners?.get(event.subscribe_id)
-          if (!listener) {
-            console.warn('[CRDT] listener not found:', event.subscribe_id, event)
-          } else {
-            listener(event)
+      this.eventQueue
+        .enqueue(async () => {
+          let events: CuboCrdtClientSubscribeEvent[] = message.data as any
+          if (!Array.isArray(events)) events = [events as any]
+
+          for (const event of events) {
+            const listeners = this.listeners.get(event.entity)
+
+            if (this.debug) {
+              console.log('[CRDT] incoming event', { listeners: listeners?.size, event })
+            }
+
+            if (event.subscribe_id) {
+              const listener = listeners?.get(event.subscribe_id)
+              if (!listener) {
+                console.warn('[CRDT] listener not found:', event.subscribe_id, event)
+                continue
+              }
+              await listener(event)
+            } else {
+              for (const cb of listeners?.values() ?? []) {
+                await cb(event)
+              }
+            }
           }
-        } else {
-          listeners?.forEach((cb) => cb(event))
-        }
-      })
+        })
+        .catch((e) => console.error('[CRDT] enqueue failed', e))
     })
   }
 
@@ -91,7 +101,8 @@ export class CuboCrdtClient<M> {
 
       this.store[storeKey] = {
         state,
-        docs: new Map()
+        docs: new Map(),
+        awarenesses: new Map()
       }
     }
 
@@ -111,17 +122,24 @@ export class CuboCrdtClient<M> {
       }
 
       // подписываемся на фронте
-      this.listeners.get(entity)?.set(subscribe_id, (ctx) => {
-        this.onIncomingUpdate(ctx, {
+      this.listeners.get(entity)?.set(subscribe_id, async (ctx) => {
+        await this.onIncomingUpdate(ctx, {
           subscribe_id,
           storeKey,
-          ...(pick(opts || {}, ['onBeforeCreate', 'onBeforeUpdate', 'onBeforeDelete', 'onAfterCreate', 'onAfterUpdate', 'onAfterDelete']) ||
-            {})
+          ...(pick(opts || {}, [
+            'onBeforeCreate',
+            'onBeforeUpdate',
+            'onBeforeDelete',
+            'onAfterCreate',
+            'onAfterUpdate',
+            'onAfterDelete',
+            'awareness'
+          ]) || {})
         })
       })
 
       // подписываемся на бэке
-      this.ws.request({ method: CUBO_CRDT_EVENT.SUBSCRIBE, data: { subscribe_id, entity, filters } })
+      this.ws.request({ method: CUBO_CRDT_EVENT.SUBSCRIBE, data: { subscribe_id, entity, filters, awareness: opts?.awareness } })
     }
 
     // отписка
@@ -138,6 +156,19 @@ export class CuboCrdtClient<M> {
 
       // очищаем стор
       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
       }
     }
@@ -160,6 +191,7 @@ export class CuboCrdtClient<M> {
       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),
       rows: () => computed(() => this.store[storeKey]?.state.rows as T[]),
       rowsById: () => computed(() => keyBy(this.store[storeKey]?.state.rows as T[], 'id' as keyof T))
@@ -173,7 +205,7 @@ export class CuboCrdtClient<M> {
   ): CuboCrdtClientRow<T> {
     // console.log('store key', opts?.storeKey ?? `${entity}:${id}`)
 
-    const { subscribe_id, storeKey, docs, subscribe, upgrade, unsubscribe, subscribed } = this.useList(entity, {
+    const { subscribe_id, storeKey, docs, awarenesses, subscribe, upgrade, unsubscribe, subscribed } = this.useList(entity, {
       ...opts,
       filters: opts?.filters ?? { id },
       storeKey: opts?.storeKey ?? `${entity}:${id}`
@@ -183,6 +215,7 @@ export class CuboCrdtClient<M> {
       subscribe_id,
       storeKey,
       doc: computed(() => docs.value?.get(id)),
+      awareness: opts?.awareness ? computed(() => awarenesses?.value?.get(id)) : undefined,
       subscribe,
       upgrade,
       unsubscribe,
@@ -310,6 +343,37 @@ export class CuboCrdtClient<M> {
     if (opts?.onAfterCreate) {
       await opts.onAfterCreate(doc, update, ctx, opts)
     }
+
+    if (opts?.awareness) {
+      let awareness = this.store[opts.storeKey]?.awarenesses.get(ctx.entity_id)
+
+      if (!awareness) {
+        awareness = new Awareness(doc)
+
+        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: ctx.entity_id,
+              data: Array.from(update),
+              origin: { subscribe_id: opts.subscribe_id }
+            }
+          })
+        })
+
+        this.store[opts.storeKey]?.awarenesses.set(ctx.entity_id, awareness)
+      }
+    }
   }
 
   private async onDocumentUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
@@ -377,31 +441,49 @@ export class CuboCrdtClient<M> {
       }
     }
 
-    if (opts?.onAfterDelete) {
-      await opts.onAfterDelete(doc, ctx, opts)
-    }
-  }
+    const awareness = this.store[opts.storeKey]?.awarenesses.get(ctx.entity_id)
+    if (awareness) {
+      removeAwarenessStates(awareness, [awareness.doc.clientID], 'unsubscribe')
 
-  private onIncomingUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
-    if (this.debug) {
-      console.log('[CRDT] call event listener', ctx, opts)
+      awareness.destroy()
+      this.store[opts.storeKey]?.awarenesses?.delete(ctx.entity_id)
     }
 
-    if (!this.store[opts.storeKey]) {
-      console.warn('[CRDT] on incoming update, store key not found: "' + opts.storeKey + '"')
+    if (opts?.onAfterDelete) {
+      await opts.onAfterDelete(doc, ctx, opts)
     }
+  }
 
+  private async onIncomingUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
     switch (ctx.action) {
       case 'create':
-        this.onDocumentCreate(ctx, opts)
+        await this.onDocumentCreate(ctx, opts)
         break
       case 'update':
       case 'upsert':
-        this.onDocumentUpdate(ctx, opts)
+        await this.onDocumentUpdate(ctx, opts)
         break
       case 'delete':
-        this.onDocumentDelete(ctx, opts)
+        await this.onDocumentDelete(ctx, opts)
         break
+      case 'awareness':
+        await this.onAwarenessUpdate(ctx, opts)
+        break
+    }
+  }
+
+  private onAwarenessUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
+    const awareness = this.store[opts.storeKey]?.awarenesses?.get(ctx.entity_id)
+    if (!awareness) {
+      return
+    }
+
+    const update = new Uint8Array(ctx.data as any)
+
+    try {
+      applyAwarenessUpdate(awareness, update, 'remote')
+    } catch (e) {
+      console.warn('[CRDT] applyAwarenessUpdate failed ', e)
     }
   }
 

package/src/client/queue/index.ts

@@ -0,0 +1,153 @@
+type QueueErrorMode = 'continue' | 'stop'
+
+export interface AsyncQueueOptions {
+  /**
+   * Что делать, если задача упала:
+   * - continue: логируем/пробрасываем через onError и идём дальше
+   * - stop: останавливаем очередь (следующие задачи не стартуют)
+   */
+  errorMode?: QueueErrorMode
+
+  /**
+   * Хук на ошибки задач (если errorMode=continue — обязательно пригодится)
+   */
+  onError?: (err: unknown) => void
+
+  /**
+   * Максимальный размер очереди (для защиты от утечек, опционально)
+   */
+  maxSize?: number
+}
+
+export class AsyncSerialQueue {
+  private running = false
+  private stopped = false
+
+  private readonly errorMode: QueueErrorMode
+  private readonly onError?: (err: unknown) => void
+  private readonly maxSize?: number
+
+  private tasks: Array<{
+    run: () => Promise<void>
+    resolve: () => void
+    reject: (e: unknown) => void
+  }> = []
+
+  private drainWaiters: Array<() => void> = []
+
+  constructor(opts: AsyncQueueOptions = {}) {
+    this.errorMode = opts.errorMode ?? 'continue'
+    this.onError = opts.onError
+    this.maxSize = opts.maxSize
+  }
+
+  get size() {
+    return this.tasks.length
+  }
+
+  get isRunning() {
+    return this.running
+  }
+
+  get isStopped() {
+    return this.stopped
+  }
+
+  /**
+   * Добавляет задачу в очередь.
+   * Возвращает промис, который резолвится когда задача реально выполнена.
+   */
+  enqueue(fn: () => void | Promise<void>): Promise<void> {
+    if (this.stopped) {
+      return Promise.reject(new Error('Queue is stopped'))
+    }
+
+    if (this.maxSize !== undefined && this.tasks.length >= this.maxSize) {
+      return Promise.reject(new Error(`Queue overflow: maxSize=${this.maxSize}`))
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      this.tasks.push({
+        run: async () => {
+          await fn()
+        },
+        resolve,
+        reject
+      })
+
+      void this.pump()
+    })
+  }
+
+  /**
+   * Ждёт, пока очередь станет пустой и ничего не выполняется.
+   */
+  async drain(): Promise<void> {
+    if (!this.running && this.tasks.length === 0) return
+    await new Promise<void>((res) => this.drainWaiters.push(res))
+  }
+
+  /**
+   * Очищает очередь (не прерывая текущую выполняемую задачу).
+   * Невыполненные задачи получат reject.
+   */
+  clear(reason: unknown = new Error('Queue cleared')): void {
+    const pending = this.tasks
+    this.tasks = []
+    for (const t of pending) t.reject(reason)
+    this.notifyDrainedIfNeeded()
+  }
+
+  /**
+   * Останавливает очередь: новые enqueue будут отвергнуты.
+   * Можно опционально очистить pending.
+   */
+  stop(opts: { clear?: boolean; reason?: unknown } = {}): void {
+    this.stopped = true
+    if (opts.clear) this.clear(opts.reason ?? new Error('Queue stopped'))
+  }
+
+  /**
+   * Разрешает снова enqueue (не запускает автоматически).
+   */
+  resume(): void {
+    this.stopped = false
+    void this.pump()
+  }
+
+  private async pump(): Promise<void> {
+    if (this.running) return
+    this.running = true
+
+    try {
+      while (!this.stopped) {
+        const task = this.tasks.shift()
+        if (!task) break
+
+        try {
+          await task.run()
+          task.resolve()
+        } catch (e) {
+          this.onError?.(e)
+          task.reject(e)
+
+          if (this.errorMode === 'stop') {
+            this.stopped = true
+            break
+          }
+        }
+      }
+    } finally {
+      this.running = false
+      this.notifyDrainedIfNeeded()
+    }
+  }
+
+  private notifyDrainedIfNeeded() {
+    if (!this.running && this.tasks.length === 0 && this.drainWaiters.length) {
+      const waiters = this.drainWaiters
+      this.drainWaiters = []
+      for (const w of waiters) w()
+    }
+  }
+}

package/src/client/types/document.ts

@@ -1,3 +1,4 @@
+import { CuboCrdtClientUseOptions } from '..'
 import { CuboCrdtExposeStrategy } from '../../types'
 
 import { CuboCrdtClientBaseOptions } from './utils'
@@ -19,4 +20,5 @@ export type CuboCrdtClientDocOrigin = {
 export type CuboCrdtClientDocUpdateOptions = { subscribe_id: string; storeKey: string } & Pick<
   CuboCrdtClientBaseOptions,
   'onBeforeCreate' | 'onAfterCreate' | 'onBeforeUpdate' | 'onAfterUpdate' | 'onBeforeDelete' | 'onAfterDelete'
->
+> &
+  Pick<CuboCrdtClientUseOptions, 'awareness'>

package/src/client/types/index.ts

@@ -1,5 +1,6 @@
 import { type WsClient } from '@cuboapp/ws'
 import { ComputedRef } from 'vue'
+import { Awareness } from 'y-protocols/awareness'
 import { type Doc } from 'yjs'
 
 import { CuboCrdtAction } from '../../types'
@@ -19,6 +20,7 @@ export type CuboCrdtClientOptions<M> = {
 export type CuboCrdtClientUseOptions = CuboCrdtClientBaseOptions & {
   storeKey?: string
   filters?: Record<string, any>
+  awareness?: boolean
 }
 
 export type CuboCrdtClientSubscribeEvent = {
@@ -33,6 +35,7 @@ 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
   unsubscribe: (clear?: boolean) => void
@@ -45,6 +48,7 @@ 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,5 +1,6 @@
 import { Reactive } from 'vue'
 import { Doc } from 'yjs'
+import { Awareness } from 'y-protocols/awareness'
 
 import { CuboCrdtKey } from '../../types'
 
@@ -9,6 +10,7 @@ export type CuboCrdtClientStoreItem<T> = {
     subscribed: boolean
   }>
   docs: Map<number, Doc>
+  awarenesses: Map<number, Awareness>
 }
 export type CuboCrdtClientStore<M> = Partial<{
   [K in string]: CuboCrdtClientStoreItem<CuboCrdtKey<K, M>>

package/src/server/document/index.ts

@@ -1,10 +1,13 @@
 import { debounce, pick } from '@cuboapp/utils'
 import { applyUpdate, Doc, encodeStateAsUpdate } from 'yjs'
+import { Awareness, encodeAwarenessUpdate } from 'y-protocols/awareness'
 
 import { CuboCrdtServerDocumentOptions, CuboCrdtServerDocumentOrigin } from '../types'
 
 export class CuboCrdtServerDocument {
   private ydoc: Doc
+  public awareness: Awareness
+  public awarenessBySubscribe = new Map<string, Set<number>>()
 
   // private firstUpdate = false
 
@@ -14,6 +17,31 @@ export class CuboCrdtServerDocument {
       autoLoad: false
     })
 
+    if (opts.awareness) {
+      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.write(opts.initialState ?? {})
 
@@ -78,6 +106,7 @@ export class CuboCrdtServerDocument {
   }
 
   destroy() {
+    this.awareness?.destroy()
     this.ydoc.destroy()
   }
 

package/src/server/index.ts

@@ -16,6 +16,7 @@ import {
   CuboCrdtServerUnsubscribeDto,
   CuboCrdtSocketClient
 } from './types'
+import { applyAwarenessUpdate, encodeAwarenessUpdate, removeAwarenessStates } from 'y-protocols/awareness'
 
 export * from './document'
 export * from './types'
@@ -40,7 +41,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     this.entities.forEach((e) => this.subscribesByEntity.set(e, new Set()))
 
     this.ws.registerHandler(CUBO_CRDT_EVENT.SUBSCRIBE, async ({ client, message }) => {
-      const { subscribe_id: id, entity, filters } = message.data as CuboCrdtServerSubscribeDto
+      const { subscribe_id: id, entity, filters, awareness = false } = message.data as CuboCrdtServerSubscribeDto
 
       if (this.debug) {
         console.log('[CRDT] subscribe', entity, filters)
@@ -50,7 +51,8 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
         id,
         client_id: client.id,
         entity,
-        filters
+        filters,
+        awareness
       }
 
       this.subscribes.set(id, subscribe)
@@ -109,6 +111,10 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
             break
           case 'delete':
             this.onDocumentExternalDelete(update, row)
+            break
+          case 'awareness':
+            this.onAwarenessExternalUpdate(update, row)
+
             break
         }
       })
@@ -173,6 +179,9 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
 
   private sendQueueToClient(client: CuboCrdtSocketClient<A>) {
     const queue = this.queue.get(client.id)
+    if (!queue) {
+      return
+    }
 
     // const data = Array.from(queue)
     const data = [...new Map((Array.from(queue) || []).map((item) => [JSON.stringify(item), item])).values()]
@@ -234,6 +243,29 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
         console.log('[CRDT] unsubscribe', subscribe.entity, subscribe.filters)
       }
 
+      if (subscribe.awareness) {
+        //убираем аварнесс стейт при отписке
+        this.subscribesByDocument.forEach((subs, docName) => {
+          if (!subs.has(subscribe_id)) {
+            return
+          }
+
+          const doc = this.documents.get(docName)
+          if (!doc?.awareness) {
+            return
+          }
+
+          const ids = Array.from(doc.awarenessBySubscribe.get(subscribe_id) || [])
+          if (!ids.length) {
+            return
+          }
+
+          removeAwarenessStates(doc.awareness, ids, { subscribe_id, expose: 'all' })
+
+          doc.awarenessBySubscribe.delete(subscribe_id)
+        })
+      }
+
       // удаляем подписку по сущности
       this.subscribesByEntity.get(subscribe.entity as E)?.delete(subscribe.id)
 
@@ -270,7 +302,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
       .map((m) => m[1])
   }
 
-  public ensureDocument(entity: E, row: any) {
+  public ensureDocument(entity: E, row: any, awareness?: boolean) {
     // todo: врапнуть всё это в Promise
     const entity_id = row.id
     const documentName = `${entity}:${entity_id}`
@@ -281,12 +313,19 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
       document = new CuboCrdtServerDocument({
         name: documentName,
         initialState: row,
+        awareness: awareness,
         onUpdate: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => {
           // пушим обновление документа
           // console.log('push document update', document.name)
 
           this.pushDocumentAction('update', entity, document!, data, origin)
         },
+        onAwarenessUpdate: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => {
+          // пушим обновление документа
+          // console.log('push document update', document.name)
+
+          this.pushDocumentAction('awareness', entity, document!, data, origin)
+        },
         onStore: (item: object, origin: CuboCrdtServerDocumentOrigin) => {
           const subscribe = origin.subscribe_id && this.subscribes.get(origin.subscribe_id)
           const client = subscribe && this.clients.get(subscribe.client_id)
@@ -353,6 +392,22 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     }
   }
 
+  private onAwarenessExternalUpdate(update: Uint8Array, action: CuboCrdtServerDocumentIncomingAction) {
+    const document = this.getDocument(action.entity, action.entity_id)
+
+    if (!document?.awareness) {
+      return
+    }
+
+    try {
+      applyAwarenessUpdate(document.awareness, update, action.origin)
+    } catch (e) {
+      if (this.debug) {
+        console.warn('[CRDT] applyAwarenessUpdate failed', e)
+      }
+    }
+  }
+
   private onDocumentExternalDelete(update: Uint8Array, action: CuboCrdtServerDocumentIncomingAction) {
     console.warn('[CRDT] onDocumentExternalDelete not implemented')
   }
@@ -481,6 +536,22 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
             this.checkDocumentNeedRemove(document.name)
             break
         }
+
+        if (action === 'create' && subscribe.awareness && document.awareness) {
+          const ids = Array.from(document.awareness.getStates().keys())
+
+          if (ids.length) {
+            const aUpdate = encodeAwarenessUpdate(document.awareness, ids)
+
+            this.sendToClient(subscribe.client_id, {
+              action: 'awareness',
+              entity: subscribe.entity,
+              entity_id: row.id,
+              data: Array.from(aUpdate),
+              subscribe_id: subscribe.id
+            })
+          }
+        }
       })
     }
   }
@@ -492,7 +563,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     // пушим их в сокеты
     for (const row of rows || []) {
       // this.ensureDocument(subscribe.entity as E, row, { subscribes_ids: [subscribe.id] })
-      this.ensureDocument(subscribe.entity as E, row)
+      this.ensureDocument(subscribe.entity as E, row, subscribe.awareness)
     }
   }
 

package/src/server/types/document.ts

@@ -5,10 +5,11 @@ export type CuboCrdtServerDocumentOptions = {
   onStore?: (body: object, origin: CuboCrdtServerDocumentOrigin) => void
   // onCreate?: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => void
   onUpdate?: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => void
+  onAwarenessUpdate?: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => void
   // onInit?: (document: CuboCrdtServerDocument) => void
 
   initialState?: object
-
+  awareness?: boolean
   yjsOptions?: {
     guid?: string
     collectionid?: string

package/src/server/types/subscribe.ts

@@ -7,9 +7,10 @@ export type CuboCrdtServerSubscribeDto = {
   filters: {
     [K in 'id' | string]: any
   }
+  awareness: boolean
 }
 
 export type CuboCrdtServerSubscribe = {
   id: string
   client_id: string
-} & Pick<CuboCrdtServerSubscribeDto, 'entity' | 'filters'>
+} & Pick<CuboCrdtServerSubscribeDto, 'entity' | 'filters' | 'awareness'>

package/src/types/index.ts

@@ -1,5 +1,5 @@
 export type CuboCrdtKey<K, M> = K extends Extract<keyof M, string> ? M[K] : any
 
-export type CuboCrdtAction = 'create' | 'upsert' | 'update' | 'delete'
+export type CuboCrdtAction = 'create' | 'upsert' | 'update' | 'delete' | 'awareness'
 
 export type CuboCrdtExposeStrategy = 'all' | 'other' | 'subscribe' | 'client'

package/src/utils/index.ts

@@ -54,9 +54,12 @@ export function checkRowIsSutable(
         } else {
           const [formula, str] = `${value}`.split(':')
 
-          // console.log({ formula, str, value: row[key] })
-
           if (!str) {
+            const maybeNum = Number(value)
+            if (!isNaN(maybeNum)) {
+              value = maybeNum
+            }
+
             if (row[key as keyof typeof row] !== value) {
               sutable = false
             }