@cuboapp/crdt 1.0.6 → 1.0.8

package/src/utils/index.ts

@@ -1,9 +1,18 @@
 import { CuboApiEntitiesMap } from '@cuboapp/types'
 
-import { CuboCrdtClient, CuboCrdtClientOptions, CuboCrdtServer, CuboCrdtServerOptions } from '..'
+import {
+  CuboCrdtClient,
+  CuboCrdtClientOptions,
+  CuboCrdtServer,
+  CuboCrdtServerDocumentOrigin,
+  CuboCrdtServerOptions,
+  CuboCrdtServerSubscribe
+} from '..'
 
-export function createCrdtServer<M extends CuboApiEntitiesMap<M>, A = {}>(opts: CuboCrdtServerOptions<M, A>) {
-  return new CuboCrdtServer<M, A>(opts)
+export function createCrdtServer<M extends CuboApiEntitiesMap<M>, A = {}, E extends Extract<keyof M, string> = Extract<keyof M, string>>(
+  opts: CuboCrdtServerOptions<M, A, E>
+) {
+  return new CuboCrdtServer<M, A, E>(opts)
 }
 
 export function createCrdtClient<M extends CuboApiEntitiesMap<M>>(opts: CuboCrdtClientOptions<M>) {
@@ -30,35 +39,43 @@ export function cleanObject<F>(object: F): any {
   return object
 }
 
-export function checkRowIsSutable(row: object, filters?: object) {
+export function checkRowIsSutable(
+  row: any,
+  filters?: object,
+  customKeys?: Record<string, (key: string, row: any, filters?: any) => boolean>
+) {
   let sutable = true
 
   if (Object.keys(filters || {}).length) {
     Object.entries(filters || {}).forEach(([key, value]) => {
       if (!['limit', 'with'].includes(key)) {
-        const [formula, str] = `${value}`.split(':')
+        if (customKeys?.[key]) {
+          sutable = customKeys[key](key, row, filters)
+        } else {
+          const [formula, str] = `${value}`.split(':')
 
-        // console.log({ formula, str, value: row[key] })
+          // console.log({ formula, str, value: row[key] })
 
-        if (!str) {
-          if (row[key as keyof typeof row] !== value) {
-            sutable = false
-          }
-        } else {
-          switch (formula) {
-            case 'in':
-              if (
-                !str
-                  .split(',')
-                  .map(Number)
-                  .includes(row[key as keyof typeof row] as any)
-              ) {
-                sutable = false
-              }
-              break
-            default:
+          if (!str) {
+            if (row[key as keyof typeof row] !== value) {
               sutable = false
-              break
+            }
+          } else {
+            switch (formula) {
+              case 'in':
+                if (
+                  !str
+                    .split(',')
+                    .map(Number)
+                    .includes(row[key as keyof typeof row] as any)
+                ) {
+                  sutable = false
+                }
+                break
+              default:
+                sutable = false
+                break
+            }
           }
         }
       }
@@ -67,3 +84,16 @@ export function checkRowIsSutable(row: object, filters?: object) {
 
   return sutable
 }
+
+export function checkSubscribeIsSutable(origin: CuboCrdtServerDocumentOrigin, subscribe?: CuboCrdtServerSubscribe) {
+  if (!subscribe) {
+    return false
+  }
+
+  const noStrategyResolved = !origin?.expose || origin?.expose === 'all'
+  const strategyOtherResolved = (origin?.expose === 'other' && origin.subscribe_id !== subscribe?.id) || false
+  const strategyClientResolved = origin?.expose === 'client' && subscribe?.client_id === origin.client_id
+  const strategySubscribeResolved = origin?.expose === 'subscribe' && subscribe?.id === origin.subscribe_id
+
+  return noStrategyResolved || strategyOtherResolved || strategyClientResolved || strategySubscribeResolved
+}

package/src/client/old.ts

@@ -1,249 +0,0 @@
-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/server/old/document/index.ts

@@ -1,107 +0,0 @@
-import { applyUpdate, Doc, encodeStateAsUpdate } from 'yjs'
-
-export class CuboCrdtDocument {
-  private ydoc: Doc
-  private subs = new Map<string, (data: Uint8Array<ArrayBufferLike>, origin?: any) => void>()
-
-  constructor(
-    public opts: {
-      name: string
-      initialState?: any
-      autoRemove?: boolean
-      onDelete?: () => void
-      yjsOptions?: {
-        guid?: string
-        collectionid?: string
-        gc?: boolean
-        gcFilter?: () => true
-        meta?: any
-      }
-    }
-  ) {}
-
-  get stateAsUpdate() {
-    return encodeStateAsUpdate(this.ydoc)
-  }
-
-  async init() {
-    this.ydoc = new Doc({
-      ...(this.opts.yjsOptions || {}),
-      autoLoad: false
-    })
-
-    const state = this.opts?.initialState ?? {}
-
-    return new Promise<Uint8Array<ArrayBufferLike>>((resolve) => {
-      this.ydoc.once('update', () => {
-        this.ydoc.on('update', (data, origin) => {
-          this.subs.forEach((sub) => sub(data, origin))
-        })
-
-        resolve(this.stateAsUpdate)
-      })
-
-      const map = this.getMap()
-
-      this.ydoc.transact(() => {
-        if (Object.keys(state).length) {
-          Object.entries(state).forEach(([key, value]) => {
-            map.set(key, value)
-          })
-        }
-
-        this.getState().setAttribute('inited', 'Y')
-      })
-    })
-  }
-
-  get inited() {
-    return this.getState().getAttribute('inited') === 'Y'
-  }
-
-  get id() {
-    return this.ydoc.guid
-  }
-
-  applyUpdate(update: Uint8Array, origin?: any) {
-    return applyUpdate(this.ydoc, update, origin)
-  }
-
-  subscribe(id: string, cb: (data: Uint8Array<ArrayBufferLike>, origin?: any) => void) {
-    this.subs.set(id, cb)
-  }
-
-  unsubscribe(id: string) {
-    this.subs.delete(id)
-
-    if (!this.subs.size && this.opts?.autoRemove !== false) {
-      this.opts?.onDelete?.()
-    }
-  }
-
-  getState() {
-    return this.ydoc.getText('state')
-  }
-
-  getMap() {
-    return this.ydoc.getMap()
-  }
-
-  getXmlFragment() {
-    return this.ydoc.getXmlFragment()
-  }
-
-  async writeMap(dto: object, origin?: any) {
-    return new Promise<void>(async (resolve) => {
-      const map = this.getMap()
-
-      this.ydoc.transact(() => {
-        Object.entries(dto).forEach(([key, value]) => {
-          map.set(key, value)
-        })
-
-        resolve()
-      }, origin)
-    })
-  }
-}

package/src/server/old/index.ts

@@ -1,49 +0,0 @@
-import { CuboCrdtDocument } from './document'
-
-export * from './document'
-
-export class CuboCrdtServer<T> {
-  constructor(private options: { debug?: boolean }) {}
-
-  public documents = new Map<string, CuboCrdtDocument>()
-  private loading = new Map<string, Promise<CuboCrdtDocument>>()
-
-  public async getDocument(name: string, opts?: { autoCreate?: boolean; initialState?: any }) {
-    // существующий документ
-    if (!this.documents.has(name)) {
-      if (!this.loading.has(name) && opts?.autoCreate !== false) {
-        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,
-              initialState: opts?.initialState,
-              autoRemove: true,
-              onDelete: () => {
-                this.documents.delete(name)
-              }
-            })
-
-            await document.init()
-
-            resolve(document)
-          })
-        )
-      }
-
-      const document = await this.loading.get(name)
-
-      this.loading.delete(name)
-
-      if (document) {
-        this.documents.set(name, document)
-      }
-    }
-
-    return this.documents.get(name)
-  }
-}