@cuboapp/crdt 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/crdt",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "CRDT for CUBO",
   "main": "src/index.ts",
   "repository": "git@github.com:cuboapp/crdt.git",
@@ -11,12 +11,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@cuboapp/types": "^2.0.11",
-    "@cuboapp/utils": "1.0.9",
-    "@cuboapp/ws": "1.0.4",
+    "@cuboapp/types": "^2.0.12",
+    "@cuboapp/utils": "1.0.10",
+    "@cuboapp/ws": "1.0.5",
     "ws": "^8.19.0",
     "yjs": "^13.6.29"
   },
+  "peerDependencies": {
+    "vue": "^3.5.26",
+    "vue-router": "^4.6.3"
+  },
   "devDependencies": {
     "@types/node": "^24.10.1",
     "@types/ws": "^8.18.1",

package/src/client/index.ts

@@ -1,106 +1,415 @@
-import { EventEmitter } from '@cuboapp/utils'
-import { createWsClient, WsClient } from '@cuboapp/ws'
+import { keyBy, pick, uuid } from '@cuboapp/utils'
+import { computed, reactive } from 'vue'
 import { applyUpdate, Doc } from 'yjs'
 
-export type CuboCrdtClientOptions = {
-  host?: string
-  port?: number
-  protocol?: 'wss' | 'ws' | string
-  authToken?: () => Promise<string>
-  debug?: boolean
-}
+import { CUBO_CRDT_EVENT } from '../constants'
+import { CuboCrdtServerDocumentIncomingAction } from '../server'
+import { CuboCrdtKey } from '../types'
 
-export class CuboCrdtClient {
-  private ws: WsClient
+import {
+  CuboCrdtClientDocOrigin,
+  CuboCrdtClientDocUpdateOptions,
+  CuboCrdtClientList,
+  CuboCrdtClientOptions,
+  CuboCrdtClientRow,
+  CuboCrdtClientStore,
+  CuboCrdtClientSubscribeEvent,
+  CuboCrdtClientUseOptions
+} from './types'
 
-  constructor(
-    private opts: CuboCrdtClientOptions,
-    private ee = new EventEmitter()
-  ) {
-    this.ws = createWsClient({
-      host: this.opts.host,
-      port: this.opts.port,
-      protocol: this.opts.protocol,
-      autoReconnect: true,
-      pingInterval: 5000,
-      authToken: this.opts.authToken ? () => this.opts.authToken!() : () => ''
+export * from './types'
+
+export class CuboCrdtClient<M> {
+  public store: CuboCrdtClientStore<M> = {}
+
+  private listeners: Map<string, Map<string, (ctx: CuboCrdtClientSubscribeEvent) => void>> = new Map()
+
+  constructor(private opts: CuboCrdtClientOptions<M>) {
+    opts.entities.forEach((e) => this.listeners.set(e, new Map()))
+  }
+
+  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)
+          }
+        } else {
+          listeners?.forEach((cb) => cb(event))
+        }
+      })
     })
   }
 
-  public async start() {
-    await this.ws.connect()
+  async stop() {
+    this.ws.deleteHandler(CUBO_CRDT_EVENT.EVENT)
 
-    this.ws.registerHandler('message', this.onMessage.bind(this))
+    this.listeners.clear()
   }
 
-  public async stop() {
-    try {
-      await this.ws.disconnect()
-    } catch {}
+  public useComputedList<K extends Extract<keyof M, string>>(entity: K) {
+    return computed(() => (this.store[entity]?.state.rows || []) as M[K][])
   }
 
-  private onMessage({ message }: any) {
-    if (message.event) {
-      this.ee.emit(message.event, message)
-    }
+  public useComputedRow<K extends Extract<keyof M, string>>(entity: K, entity_id: number) {
+    return computed(() => {
+      return ((this.store[entity]?.state.rows || []) as M[K][]).find((row: any) => row.id === entity_id)
+    })
   }
 
-  async subscribe({ entity, id, filters }: { entity: string; id?: number; filters?: any }, cb: any) {
-    if (this.opts.debug) {
-      console.log('subscribeEntity', { entity, id })
+  public useList<K extends Extract<keyof M, string>, T = CuboCrdtKey<K, M>>(
+    entity: K | string,
+    opts?: CuboCrdtClientUseOptions
+  ): CuboCrdtClientList<T> {
+    const storeKey = opts?.storeKey ?? `${entity}`
+    const filters = opts?.filters || {}
+
+    const subscribe_id = uuid()
+
+    // создаём хранилище
+    if (this.store[storeKey] === undefined) {
+      const state = reactive({
+        rows: [],
+        subscribed: false
+      })
+
+      this.store[storeKey] = {
+        state,
+        docs: new Map()
+      }
     }
 
-    filters = filters || {}
-    if (id) {
-      filters.id = id
+    // подписка
+    const subscribe = (filters?: Record<string, any>) => {
+      if (this.store[storeKey]?.state.subscribed) {
+        return
+      }
+
+      // ставим сразу флаг, потому что не может быть ошибок (считаем так)
+      this.store[storeKey]!.state.subscribed = true
+
+      filters = filters !== undefined ? filters : opts?.filters
+
+      if (this.debug) {
+        console.log('[CRDT] subscribe', { entity, opts, filters })
+      }
+
+      // подписываемся на фронте
+      this.listeners.get(entity)?.set(subscribe_id, (ctx) => {
+        this.onIncomingUpdate(ctx, {
+          subscribe_id,
+          storeKey,
+          ...(pick(opts || {}, ['onBeforeCreate', 'onBeforeUpdate', 'onBeforeDelete', 'onAfterCreate', 'onAfterUpdate', 'onAfterDelete']) ||
+            {})
+        })
+      })
+
+      // подписываемся на бэке
+      this.ws.request({ method: CUBO_CRDT_EVENT.SUBSCRIBE, data: { subscribe_id, entity, filters } })
     }
 
-    const event = `crdt:${entity}`
-    // const event = id ? `crdt:${entity}:${id}` : `crdt:${entity}`
+    // отписка
+    const unsubscribe = (clear?: boolean) => {
+      if (this.debug) {
+        console.log('[CRDT] unsubscribe', { entity, opts, filters })
+      }
+
+      // отписываемся на бэке
+      this.ws.request({ method: CUBO_CRDT_EVENT.UNSUBSCRIBE, data: { subscribe_id } })
+
+      // отписываемся на фронте
+      this.listeners.get(entity)?.delete(subscribe_id)
 
-    this.ee.addListener(event, cb)
-    this.ws.request({ method: 'crdt:subscribe', data: { event, filters } })
+      // очищаем стор
+      if (clear !== false) {
+        this.store[storeKey] = undefined
+      }
+    }
+
+    // апгрейд
+    const upgrade = (filters?: Record<string, any>) => {
+      // подписываемся на бэке
+      this.upgrade(subscribe_id, filters)
+    }
+
+    // авто-подписка
+    if (opts?.autoSubscribe !== false) {
+      subscribe()
+    }
+
+    return {
+      subscribe_id,
+      storeKey,
+      subscribe,
+      upgrade,
+      unsubscribe,
+      docs: computed(() => this.store[storeKey]?.docs),
+      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))
+    }
   }
 
-  async unsubscribe({ entity, id, filters }: { entity: string; id?: number; filters?: any }, cb: any) {
-    if (this.opts.debug) {
-      console.log('subscribeEntity', { entity, id })
+  public useRow<K extends Extract<keyof M, string>, T = CuboCrdtKey<K, M>>(
+    entity: K | string,
+    id: number,
+    opts?: CuboCrdtClientUseOptions
+  ): CuboCrdtClientRow<T> {
+    // console.log('store key', opts?.storeKey ?? `${entity}:${id}`)
+
+    const { subscribe_id, storeKey, docs, subscribe, upgrade, unsubscribe, subscribed } = this.useList(entity, {
+      ...opts,
+      filters: opts?.filters ?? { id },
+      storeKey: opts?.storeKey ?? `${entity}:${id}`
+    })
+
+    return {
+      subscribe_id,
+      storeKey,
+      doc: computed(() => docs.value?.get(id)),
+      subscribe,
+      upgrade,
+      unsubscribe,
+      subscribed,
+      row: () => {
+        return computed(() => {
+          return (this.store[storeKey]?.state.rows?.[0] ?? null) as T
+        })
+      }
     }
+  }
 
-    const event = `crdt:${entity}`
-    // const event = id ? `crdt:${entity}:${id}` : `crdt:${entity}`
+  public update<K extends string>(
+    entity: K,
+    entity_id: number,
+    dto: K extends Extract<keyof M, string> ? Partial<M[K]> : object,
+    opts?: CuboCrdtClientDocOrigin
+  ) {
+    const cardRow = this.store[`${entity}:${entity_id}`]?.state.rows?.[0]
+    const listRow = this.store[entity]?.state?.rows.find((r: any) => r.id === entity_id)
+    const cardDoc = this.store[`${entity}:${entity_id}`]?.docs.get(entity_id)
+    const listDoc = this.store[entity]?.docs.get(entity_id)
+
+    // обновляем документы
+    for (const doc of [cardDoc, listDoc]) {
+      if (doc) {
+        const map = 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 // отправляем на бэк
+          }
+
+          doc.transact(() => {
+            Object.entries(toUpdate).forEach(([key, value]) => {
+              map.set(key, value)
+            })
+          }, origin)
+        }
+      }
+    }
+
+    // обновляем реактивку
+    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 (Object.keys(toUpdate).length) {
+          Object.entries(toUpdate).forEach(([key, value]) => {
+            row[key as keyof typeof row] = value
+          })
+        }
+      }
+    }
+  }
 
-    this.ee.removeListener(event, cb)
-    this.ws.request({ method: 'crdt:unsubscribe', data: { event, filters } })
+  public upgrade(subscribe_id: string, filters?: Record<string, any>) {
+    this.ws.request({ method: CUBO_CRDT_EVENT.UPGRADE, data: { subscribe_id, filters } })
   }
 
-  async openDocument(entity: string, id: number, doc: Doc): Promise<void> {
-    const state: any = await this.ws.request(
-      {
-        method: 'crdt:open',
-        data: { name: `${entity}:${id}` }
-      },
-      { wait: true }
-    )
-
-    this.ee.addListener(`crdt:update:${entity}:${id}`, (ctx) => {
-      applyUpdate(doc, new Uint8Array(ctx.data))
+  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 })
+      return
+    } else {
+      doc = new Doc()
+    }
+
+    const update = new Uint8Array(ctx.data as any)
+
+    if (opts?.onBeforeCreate) {
+      const result = await opts.onBeforeCreate(update, ctx, opts)
+      if (!result) {
+        return
+      }
+    }
+
+    applyUpdate(doc, update, { react: false })
+
+    // подписываемся на обновления документа
+    doc.on('update', (update, origin: CuboCrdtClientDocOrigin) => {
+      // react = false, если это апдейт с бэка
+      if (origin?.react !== false) {
+        const data: CuboCrdtServerDocumentIncomingAction = {
+          action: 'update',
+          entity: ctx.entity,
+          entity_id: ctx.entity_id,
+          data: Array.from(update),
+          origin: {
+            ...pick(origin || {}, ['store', 'keys', 'expose']),
+            subscribe_id: opts?.subscribe_id
+          }
+        }
+
+        this.ws.request({
+          method: CUBO_CRDT_EVENT.EVENT,
+          data
+        })
+      }
     })
 
-    this.ws.request({ method: 'crdt:subscribe', data: { crdt: { entity, id } } })
+    // добавляем документ в хранилище документов
+    this.store[opts.storeKey]?.docs.set(ctx.entity_id, doc)
+
+    // добавляем документ в реактивное хранилище
+    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) {
+      if (this.debug) {
+        console.warn('[CRDT] onDocumentCreate - row already exists: "' + ctx.entity_id + '"', { ctx, opts })
+      }
+
+      this.store[opts.storeKey]!.state.rows[index] = json
+    } else {
+      this.store[opts.storeKey]?.state.rows.push(json)
+    }
+
+    if (opts?.onAfterCreate) {
+      await opts.onAfterCreate(doc, update, ctx, opts)
+    }
+  }
+
+  private async onDocumentUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
+    const doc = this.store[opts.storeKey]?.docs.get(ctx.entity_id)
+    if (!doc) {
+      console.warn('[CRDT] onDocumentUpdate: doc not exists', { ctx, opts })
+      return
+    }
+
+    const update = new Uint8Array(ctx.data as any)
+
+    if (opts?.onBeforeUpdate) {
+      const result = await opts.onBeforeUpdate(doc, update, ctx, opts)
+      if (!result) {
+        return
+      }
+    }
+
+    // обновляем yjs-ный документ
+    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)
+    }
 
-    applyUpdate(doc, new Uint8Array(state))
+    if (opts?.onAfterUpdate) {
+      await opts.onAfterUpdate(doc, update, ctx, opts)
+    }
   }
 
-  async closeDocument(entity: string, id: number) {
-    await this.ws.request(
-      {
-        method: 'crdt:close',
-        data: { name: `${entity}:${id}` }
-      },
-      { wait: true }
-    )
+  private async onDocumentDelete(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
+    const doc = this.store[opts.storeKey]?.docs.get(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)
+      if (!result) {
+        return
+      }
+    }
+
+    // console.log('onDocumentDelete', ctx, opts)
+
+    doc.destroy()
+    this.store[opts.storeKey]?.docs.delete(ctx.entity_id)
+
+    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.splice(index, 1)
+    } else {
+      if (this.debug) {
+        console.log('[CRDT] row not found', index, ctx, opts)
+      }
+    }
+
+    if (opts?.onAfterDelete) {
+      await opts.onAfterDelete(doc, ctx, opts)
+    }
+  }
+
+  private onIncomingUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
+    if (this.debug) {
+      console.log('[CRDT] call event listener', ctx, opts)
+    }
+
+    if (!this.store[opts.storeKey]) {
+      console.warn('[CRDT] on incoming update, store key not found: "' + opts.storeKey + '"')
+    }
+
+    switch (ctx.action) {
+      case 'create':
+        this.onDocumentCreate(ctx, opts)
+        break
+      case 'update':
+      case 'upsert':
+        this.onDocumentUpdate(ctx, opts)
+        break
+      case 'delete':
+        this.onDocumentDelete(ctx, opts)
+        break
+    }
+  }
+
+  private get ws() {
+    return this.opts.ws
+  }
 
-    this.ee.removeAllListeners(`crdt:document:${entity}:${id}:update`)
+  private get debug() {
+    return this.opts.debug
   }
 }

package/src/client/types/document.ts

@@ -0,0 +1,22 @@
+import { CuboCrdtExposeStrategy } from '../../types'
+
+import { CuboCrdtClientBaseOptions } from './utils'
+
+export type CuboCrdtClientDocOrigin = {
+  // сохранять ли на бэке в дебаунсе
+  store?: boolean
+
+  // реагировать ли в onUpdate (на фронте)
+  react?: boolean
+
+  // обновлённые ключи
+  keys?: string[]
+
+  // куда раскатывать обновления - всем или всем кроме себя
+  expose?: CuboCrdtExposeStrategy
+}
+
+export type CuboCrdtClientDocUpdateOptions = { subscribe_id: string; storeKey: string } & Pick<
+  CuboCrdtClientBaseOptions,
+  'onBeforeCreate' | 'onAfterCreate' | 'onBeforeUpdate' | 'onAfterUpdate' | 'onBeforeDelete' | 'onAfterDelete'
+>

package/src/client/types/index.ts

@@ -0,0 +1,53 @@
+import { type WsClient } from '@cuboapp/ws'
+import { ComputedRef } from 'vue'
+import { type Doc } from 'yjs'
+
+import { CuboCrdtAction } from '../../types'
+
+import { CuboCrdtClientBaseOptions } from './utils'
+
+export * from './document'
+export * from './store'
+export * from './utils'
+
+export type CuboCrdtClientOptions<M> = {
+  ws: WsClient
+  entities: Extract<keyof M, string>[]
+  debug?: boolean
+}
+
+export type CuboCrdtClientUseOptions = CuboCrdtClientBaseOptions & {
+  storeKey?: string
+  filters?: Record<string, any>
+}
+
+export type CuboCrdtClientSubscribeEvent = {
+  action: CuboCrdtAction
+  entity: string
+  entity_id: number
+  subscribe_id?: string
+  data?: number[]
+}
+
+export type CuboCrdtClientList<T> = {
+  subscribe_id: string
+  storeKey: string
+  docs: ComputedRef<Map<number, Doc> | undefined>
+  subscribe: (filters?: any) => void
+  upgrade: (filters?: any) => void
+  unsubscribe: (clear?: boolean) => void
+  subscribed: () => ComputedRef<boolean>
+  rows: () => ComputedRef<T[]>
+  rowsById: () => ComputedRef<Record<string, T>>
+}
+
+export type CuboCrdtClientRow<T> = {
+  subscribe_id: string
+  storeKey: string
+  doc: ComputedRef<Doc | undefined>
+  subscribe: () => void
+  upgrade: (filters?: any) => void
+  unsubscribe: (clear?: boolean) => void
+  subscribed: () => ComputedRef<boolean>
+  row: () => ComputedRef<T>
+}

package/src/client/types/store.ts

@@ -0,0 +1,15 @@
+import { Reactive } from 'vue'
+import { Doc } from 'yjs'
+
+import { CuboCrdtKey } from '../../types'
+
+export type CuboCrdtClientStoreItem<T> = {
+  state: Reactive<{
+    rows: T[]
+    subscribed: boolean
+  }>
+  docs: Map<number, Doc>
+}
+export type CuboCrdtClientStore<M> = Partial<{
+  [K in string]: CuboCrdtClientStoreItem<CuboCrdtKey<K, M>>
+}>

package/src/client/types/utils.ts

@@ -0,0 +1,35 @@
+import { Doc } from 'yjs'
+import { CuboCrdtClientSubscribeEvent } from '.'
+import { CuboCrdtClientDocUpdateOptions } from './document'
+
+export type CuboCrdtClientBaseOptions = {
+  autoSubscribe?: boolean
+
+  onBeforeCreate?: (
+    update: Uint8Array,
+    ctx: CuboCrdtClientSubscribeEvent,
+    opts: CuboCrdtClientDocUpdateOptions
+  ) => Promise<boolean> | boolean
+  onAfterCreate?: (
+    doc: Doc,
+    update: Uint8Array,
+    ctx: CuboCrdtClientSubscribeEvent,
+    opts: CuboCrdtClientDocUpdateOptions
+  ) => Promise<void> | void
+
+  onBeforeUpdate?: (
+    doc: Doc,
+    update: Uint8Array,
+    ctx: CuboCrdtClientSubscribeEvent,
+    opts: CuboCrdtClientDocUpdateOptions
+  ) => Promise<boolean> | boolean
+  onAfterUpdate?: (
+    doc: Doc,
+    update: Uint8Array,
+    ctx: CuboCrdtClientSubscribeEvent,
+    opts: CuboCrdtClientDocUpdateOptions
+  ) => Promise<void> | void
+
+  onBeforeDelete?: (doc: Doc, ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) => Promise<boolean> | boolean
+  onAfterDelete?: (doc: Doc, ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) => Promise<void> | void
+}

package/src/constants/index.ts

@@ -0,0 +1,6 @@
+export const CUBO_CRDT_EVENT = {
+  EVENT: 'crdt:event',
+  SUBSCRIBE: 'crdt:subscribe',
+  UPGRADE: 'crdt:upgrade',
+  UNSUBSCRIBE: 'crdt:unsubscribe'
+}