@cuboapp/crdt 1.0.5 → 1.0.6

package/src/client/old.ts

@@ -0,0 +1,249 @@
+import { uuid } from '@cuboapp/utils'
+import { WsClient } from '@cuboapp/ws'
+import { computed, ComputedRef, Reactive, reactive } from 'vue'
+import { applyUpdate, Doc } from 'yjs'
+
+export type CuboCrdtClientStoreElement<M, K> = {
+  rows: Reactive<Map<number, K extends keyof M ? M[K] : unknown>>
+  docs: Map<number, Doc>
+  flags: Reactive<{
+    inited: boolean
+  }>
+}
+
+export type CuboCrdtClientSubscribeOptions<S, F> = {
+  entity_id?: number
+  storeKey?: S
+  filters?: F
+  autoInit?: boolean
+  onUpdate?: () => void
+  onInit?: () => void
+  debug?: boolean
+}
+
+export type CuboCrdtClientSubscribe<M = {}, K = {}, S = {}, F = {}> = {
+  id: string
+  storeKey: S
+  store: CuboCrdtClientStoreElement<M, K>
+  init: (filters?: F) => void
+  destroy: (opts?: { clear?: boolean }) => void
+}
+
+export type CuboCrdtClientOptions = {
+  ws: WsClient
+  debug?: boolean
+}
+
+export class CuboCrdtClient<M> {
+  constructor(private opts: CuboCrdtClientOptions) {}
+
+  public store: Partial<{ [K in Extract<keyof M, string>]: CuboCrdtClientStoreElement<M, K> }> = {}
+
+  private get ws() {
+    return this.opts.ws
+  }
+
+  private getFilters<F>(filters: F) {
+    if (Array.isArray(filters)) {
+      return filters.map(this.getFilters).filter(Boolean)
+    } else if (typeof filters === 'object' && filters !== null) {
+      const newObj: any = {}
+
+      for (const key in filters) {
+        const value = this.getFilters(filters[key])
+
+        if (value !== undefined && value !== null && value !== '' && !(typeof value === 'object' && Object.keys(value).length === 0)) {
+          newObj[key] = value
+        }
+      }
+
+      return newObj
+    }
+
+    return filters
+  }
+
+  subscribe<K extends Extract<keyof M, string>, S extends string, F extends Record<string, any>>(
+    entity: K,
+    opts?: CuboCrdtClientSubscribeOptions<S, F>
+  ): CuboCrdtClientSubscribe<M, K, S, F> {
+    const subscribe_id = uuid()
+    const storeKey = opts?.storeKey ?? (entity as any)
+
+    if (opts?.debug) {
+      console.trace('subscribe tasks', subscribe_id, opts)
+    }
+
+    if (this.store[storeKey] === undefined) {
+      this.store[storeKey] = {
+        flags: reactive({
+          inited: false
+        }),
+        rows: reactive(new Map()),
+        docs: new Map()
+      }
+    }
+
+    const onUpdateDocument = (id: number, data: Uint8Array, fireOnUpdate?: boolean) => {
+      let item: any
+
+      // обновляем документ
+
+      let exDoc = this.store[storeKey].docs.get(id)
+      if (!exDoc) {
+        const doc = new Doc()
+        applyUpdate(doc, data)
+
+        doc.on('update', (update, origin) => {
+          if (!origin?.no_push) {
+            this.ws.request({
+              method: 'crdt:update',
+              data: {
+                subscribe_id,
+                name: `${entity}:${id}`,
+                update: Array.from(update),
+                origin
+              }
+            })
+          }
+        })
+
+        this.store[storeKey].docs.set(id, doc)
+        exDoc = doc
+      } else {
+        applyUpdate(exDoc, data, { no_push: true })
+      }
+
+      item = exDoc.getMap().toJSON()
+
+      // обновляем строку
+      this.store[storeKey].rows.set(id, item as any)
+
+      if (opts?.debug) {
+        console.log('fire onUpdate', { fireOnUpdate })
+      }
+
+      if (fireOnUpdate !== false) {
+        opts?.onUpdate?.()
+      }
+    }
+
+    const init = (filters?: F) => {
+      filters = filters !== undefined ? filters : opts?.filters
+
+      if (this.store[storeKey].flags.inited) {
+        return
+      }
+
+      // подписываемся на обновления
+      this.ws.registerHandler('crdt:action:' + subscribe_id, (ctx) => {
+        const { action, entity_id, data } = ctx.message.data as any
+
+        switch (action) {
+          case 'update':
+            onUpdateDocument(entity_id, new Uint8Array(data), true)
+            break
+        }
+      })
+
+      this.ws
+        .request(
+          {
+            method: 'crdt:subscribe',
+            data: this.getFilters({
+              id: subscribe_id,
+              entity,
+              entity_id: opts?.entity_id,
+              filters
+            })
+          },
+          true
+        )
+        .then((data: any) => {
+          if (opts?.entity_id) {
+            onUpdateDocument(data.id, new Uint8Array(data.row), false)
+          } else {
+            data.map(({ id, row }: { id: number; row: number[] }) => onUpdateDocument(id, new Uint8Array(row), false))
+          }
+
+          this.store[storeKey].flags.inited = true
+          opts?.onInit?.()
+        })
+    }
+
+    const destroy = ({ clear }: { clear?: boolean } = {}) => {
+      if (!this.store[storeKey].flags.inited) {
+        return
+      }
+
+      this.ws.request(
+        {
+          method: 'crdt:unsubscribe',
+          data: this.getFilters({
+            id: subscribe_id,
+            entity,
+            entity_id: opts?.entity_id,
+            filters: opts?.filters
+          })
+        },
+        true
+      )
+
+      this.ws.deleteHandler('crdt:update:' + subscribe_id)
+
+      if (clear !== false) {
+        this.store[storeKey] = undefined
+      }
+    }
+
+    if (opts?.autoInit !== false) {
+      init()
+    }
+
+    return {
+      id: subscribe_id,
+      storeKey,
+      store: this.store[storeKey] as any,
+      init,
+      destroy
+    }
+  }
+
+  useList<K extends string, T = K extends keyof M ? M[K] : unknown>(key: K): ComputedRef<T[]> {
+    return computed(() => {
+      return Array.from(this.store[key as any].rows || []).map((m) => m[1] as T)
+    })
+  }
+
+  change<K extends string = Extract<keyof M, string>, T = K extends keyof M ? M[K] : unknown>(
+    entity: K,
+    entity_id: number,
+    dto: Partial<T> & Record<string, any>,
+    opts?: { strategy?: 'other' | 'all' }
+  ) {
+    const row = this.store[entity as any].rows.get(entity_id)
+    const doc = this.store[entity as any].docs.get(entity_id)
+
+    if (doc) {
+      const map = doc.getMap()
+
+      const toUpdate = Object.fromEntries(Object.entries(dto).filter(([key, value]) => row[key] !== value))
+
+      if (Object.keys(toUpdate).length) {
+        doc.transact(
+          () => {
+            Object.entries(toUpdate).forEach(([key, value]) => {
+              map.set(key, value)
+              row[key] = value
+            })
+          },
+          { with_save: true, strategy: opts?.strategy ?? 'other', keys: Object.keys(toUpdate) }
+        )
+      }
+    }
+  }
+
+  useRow<K extends Extract<keyof M, string>, T = K extends keyof M ? M[K] : unknown>(entity: K, entity_id: number): ComputedRef<T> {
+    return computed(() => this.store[entity].rows.get(entity_id)) as ComputedRef<T>
+  }
+}

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,51 @@
+import { WsClient } from '@cuboapp/ws'
+import { ComputedRef } from 'vue'
+import { 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
+  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
+  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,5 @@
+export const CUBO_CRDT_EVENT = {
+  EVENT: 'crdt:event',
+  SUBSCRIBE: 'crdt:subscribe',
+  UNSUBSCRIBE: 'crdt:unsubscribe'
+}

package/src/index.ts

@@ -1,132 +1,4 @@
-import { type CuboApiEntitiesMap } from '@cuboapp/types'
-import { EventEmitter } from '@cuboapp/utils'
-
-import { CuboCrdtOptions } from './types'
-import { CuboCrdtDocument } from './yjs'
-
 export * from './client'
+export * from './server'
 export * from './types'
 export * from './utils'
-export * from './yjs'
-
-export const CUBO_CRDT_EVENT = {
-  DOCUMENT_UPDATED: 'document:updated',
-  DOCUMENT_DELETED: 'document:deleted',
-  DOCUMENT_CREATED: 'document:created'
-}
-
-export class CuboCrdt<
-  T extends CuboApiEntitiesMap<T>,
-  A = {},
-  K extends string = Extract<keyof T, string>,
-  ID extends string = `${K}:${number | string}`
-> {
-  public documents = new Map<ID, CuboCrdtDocument>()
-  private loading = new Map<ID, Promise<CuboCrdtDocument>>()
-
-  public ee = new EventEmitter()
-
-  constructor(private options: CuboCrdtOptions<A>) {}
-
-  public async start() {
-    // setInterval(() => {
-    // console.log('documents', this.documents.size)
-    // }, 1000)
-    // const doc = new Doc()
-    // const map = doc.getMap('store')
-    // doc.on('update', (upd) => {
-    //   const map1 = doc.getMap('store')
-    //   console.log('new state', map1.toJSON())
-    // })
-    // doc.transact(() => {
-    //   map.set('key', 'value')
-    // })
-  }
-
-  public async stop() {}
-
-  public async getDocument(name: ID, autoCreate = true) {
-    // существующий документ
-    if (!this.documents.has(name)) {
-      if (!this.loading.has(name) && autoCreate) {
-        if (this.options.debug) {
-          console.log('CRDT create document load start', name)
-        }
-
-        this.loading.set(
-          name,
-          new Promise(async (resolve) => {
-            const document = new CuboCrdtDocument({
-              name,
-              autoRemove: true,
-              debug: this.options.debug,
-              initialState: () => {
-                return this.options.beforeLoadDocument?.(name)
-              },
-              onUpdate: ({ data, document }) => {
-                this.ee.emit(CUBO_CRDT_EVENT.DOCUMENT_UPDATED, { name, data, document })
-              }
-            })
-
-            await document.init()
-
-            resolve(document)
-          })
-        )
-      }
-
-      const document = await this.loading.get(name)
-
-      this.loading.delete(name)
-
-      if (document) {
-        this.documents.set(name, document)
-      }
-    }
-
-    if (this.options.debug) {
-      console.log('CRDT create document load completed', name, this.documents.size)
-    }
-
-    return this.documents.get(name)
-  }
-
-  public async removeDocument(name: ID) {
-    if (this.options.debug) {
-      console.log('CRDT remove document', name)
-    }
-
-    if (this.loading.has(name)) {
-      try {
-        Promise.reject(this.loading.get(name))
-        this.loading.delete(name)
-      } catch {}
-    }
-
-    if (this.documents.has(name)) {
-      this.documents.delete(name)
-    }
-  }
-
-  public async updateDocument(name: ID, dto: object) {
-    const document = await this.getDocument(name)
-
-    if (document) {
-      await document.write(dto)
-    }
-
-    await this.checkDocumentUnload(name)
-  }
-
-  public async checkDocumentUnload(name: ID) {
-    const doc = this.documents.get(name)
-
-    if (doc?.opts?.autoRemove && doc.clients.size === 0) {
-      if (this.options.debug) {
-        console.log('CRDT destroy document', name)
-      }
-
-      this.documents.delete(name)
-    }
-  }
-}

package/src/server/document/index.ts

@@ -0,0 +1,91 @@
+import { debounce, pick } from '@cuboapp/utils'
+import { applyUpdate, Doc, encodeStateAsUpdate } from 'yjs'
+
+import { CuboCrdtExposeStrategy } from '../../types'
+
+import { CuboCrdtServerDocumentOptions, CuboCrdtServerDocumentOrigin } from '../types'
+
+export class CuboCrdtServerDocument {
+  private ydoc: Doc
+
+  private firstUpdate = true
+
+  constructor(public opts: CuboCrdtServerDocumentOptions) {
+    this.ydoc = new Doc({
+      ...(this.opts.yjsOptions || {}),
+      autoLoad: false
+    })
+
+    this.ydoc.on('update', (data, origin: CuboCrdtServerDocumentOrigin) => {
+      if (this.firstUpdate) {
+        this.firstUpdate = true
+        this.opts?.onCreate?.(data, origin)
+      } else {
+        this.opts?.onUpdate?.(data, origin)
+      }
+
+      if (origin?.store) {
+        const row = this.getJson()
+        const body = pick(row, origin.keys ?? Object.keys(row))
+
+        if (Object.keys(body)) {
+          this.debounceStore(body, origin)
+        }
+      }
+    })
+  }
+
+  public get name() {
+    return this.opts.name
+  }
+
+  public get stateAsUpdate() {
+    return encodeStateAsUpdate(this.ydoc)
+  }
+
+  applyUpdate(update: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) {
+    return applyUpdate(this.ydoc, update, origin)
+  }
+
+  getMap() {
+    return this.ydoc.getMap()
+  }
+
+  getJson() {
+    return this.getMap().toJSON()
+  }
+
+  async write(dto: object, origin?: CuboCrdtServerDocumentOrigin) {
+    const map = this.getMap()
+
+    this.ydoc.transact(() => {
+      Object.entries(dto).forEach(([key, value]) => {
+        map.set(key, value)
+      })
+    }, origin)
+  }
+
+  get id() {
+    return this.ydoc.guid
+  }
+
+  destroy() {
+    this.ydoc.destroy()
+  }
+
+  private _inited = false
+  public init(state?: object, expose: CuboCrdtExposeStrategy = 'all') {
+    if (this._inited) {
+      return
+    }
+
+    this._inited = true
+
+    this.write(state ?? {}, { expose })
+  }
+
+  public store(body: object, origin: CuboCrdtServerDocumentOrigin) {
+    this.opts?.onStore?.(body, origin)
+  }
+  public debounceStore = debounce(this.store.bind(this), 300)
+}