@cuboapp/crdt 1.0.6 → 1.0.8

package/src/server/index.ts

@@ -1,9 +1,11 @@
+import { cloneDeep } from '@cuboapp/utils'
 import { WsServerSocket } from '@cuboapp/ws'
 
 import { CUBO_CRDT_EVENT } from '../constants'
 import { CuboCrdtAction } from '../types'
 import { checkRowIsSutable } from '../utils'
 
+import { CuboCrdtClientDocOrigin } from '../client'
 import { CuboCrdtServerDocument } from './document'
 import {
   CuboCrdtServerDocumentIncomingAction,
@@ -11,27 +13,31 @@ import {
   CuboCrdtServerOptions,
   CuboCrdtServerSubscribe,
   CuboCrdtServerSubscribeDto,
-  CuboCrdtServerUnsubscribeDto
+  CuboCrdtServerUnsubscribeDto,
+  CuboCrdtSocketClient
 } from './types'
 
 export * from './document'
 export * from './types'
 
-export class CuboCrdtServer<M, A = {}> {
-  constructor(private options: CuboCrdtServerOptions<M, A>) {}
+export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extract<keyof M, string>> {
+  constructor(private options: CuboCrdtServerOptions<M, A, E>) {}
 
-  private clients = new Map<string, WsServerSocket<{ auth?: A }>>()
+  private clients = new Map<string, CuboCrdtSocketClient<A>>()
+  private queue = new Map<string, Set<any>>()
+  private sendTimeouts = new Map<string, any>()
 
   private subscribes = new Map<string, CuboCrdtServerSubscribe>()
-  private subscribesByClient = new Map<string, Map<string, CuboCrdtServerSubscribe>>()
-  private subscribesByEntity = new Map<string, Map<string, CuboCrdtServerSubscribe>>()
+  private subscribesByClient = new Map<string, Set<string>>()
+  private subscribesByEntity = new Map<E, Set<string>>()
   private subscribesIniting = new Map<string, Promise<void>>()
+  private subscribesUpgrading = new Map<string, Promise<void>>()
 
   private documents = new Map<string, CuboCrdtServerDocument>()
-  private documentsSubsrcibes = new Map<string, Set<string>>()
+  private subscribesByDocument = new Map<string, Set<string>>()
 
   public async init() {
-    this.entities.forEach((e) => this.subscribesByEntity.set(e, new Map()))
+    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
@@ -50,14 +56,31 @@ export class CuboCrdtServer<M, A = {}> {
       this.subscribes.set(id, subscribe)
 
       // создаём мапу подписок по клиенту
-      this.subscribesByClient.get(client.id)?.set(id, subscribe)
+      this.subscribesByClient.get(client.id)?.add(id)
 
       // создаём мапу подписок по сущности
-      this.subscribesByEntity.get(entity)?.set(id, subscribe)
+      this.subscribesByEntity.get(entity as E)?.add(id)
 
+      // инициализируем подписку
       this.initSubscribe(client, subscribe)
     })
 
+    this.ws.registerHandler(CUBO_CRDT_EVENT.UPGRADE, async ({ client, message }) => {
+      const { subscribe_id: id, entity, filters } = message.data as CuboCrdtServerSubscribeDto
+
+      if (this.debug) {
+        console.log('[CRDT] upgrade', entity, filters)
+      }
+
+      const subscribe = this.subscribes.get(id)
+      if (!subscribe) {
+        return
+      }
+
+      // обновляем подписку
+      this.upgradeSubscribe(client, subscribe, { filters })
+    })
+
     this.ws.registerHandler(CUBO_CRDT_EVENT.UNSUBSCRIBE, async ({ message }) => {
       const { subscribe_id } = message.data as CuboCrdtServerUnsubscribeDto
 
@@ -108,7 +131,7 @@ export class CuboCrdtServer<M, A = {}> {
           size: this.documents.size,
           rows: Array.from(this.documents).map((d) => ({
             id: d[0],
-            subs: Array.from(this.documentsSubsrcibes.get(d[0]) || [])
+            subs: Array.from(this.subscribesByDocument.get(d[0]) || [])
           }))
         }
       }
@@ -128,20 +151,82 @@ export class CuboCrdtServer<M, A = {}> {
     this.clients.set(client.id, client)
 
     // создаем мапу подписок по клиенту
-    this.subscribesByClient.set(client.id, new Map())
+    this.subscribesByClient.set(client.id, new Set())
+
+    // создаём очередь под клиента
+    this.queue.set(client.id, new Set())
   }
 
   public removeClient(client: WsServerSocket) {
     // удаляем все подписки по клиенту
-    this.subscribesByClient.get(client.id)?.forEach((sub) => this.cleanSubscribe(sub.id))
+    this.subscribesByClient.get(client.id)?.forEach((subscribe_id) => this.cleanSubscribe(subscribe_id))
 
     // удаляем мапу подписок по клиенту
     this.subscribesByClient.delete(client.id)
 
+    // удаляем очередь под клиента
+    this.queue.delete(client.id)
+
     // и в принципе клиента
     this.clients.delete(client.id)
   }
 
+  private sendQueueToClient(client: CuboCrdtSocketClient<A>) {
+    const queue = this.queue.get(client.id)
+
+    // const data = Array.from(queue)
+    const data = [...new Map((Array.from(queue) || []).map((item) => [JSON.stringify(item), item])).values()]
+
+    queue.clear()
+
+    client.send(
+      JSON.stringify({
+        method: CUBO_CRDT_EVENT.EVENT,
+        data
+      })
+    )
+
+    queue.clear()
+  }
+
+  public sendToClient(client_id: string, data: any) {
+    const client = this.clients.get(client_id)
+    if (!client) {
+      return
+    }
+
+    // сбрасываем таймаут если он есть
+    clearTimeout(this.sendTimeouts.get(client_id))
+
+    // добавляем в очередь
+    this.queue.get(client_id).add(data)
+
+    // если очередь >10 то сразу отправляем
+    if (this.queue.size > 10) {
+      this.sendQueueToClient(client)
+    }
+    // если нет - ставим таймаут
+    else {
+      this.sendTimeouts.set(
+        client_id,
+        setTimeout(() => this.sendQueueToClient(client), 100)
+      )
+    }
+  }
+
+  // если у документа нет подписок - сносим его
+  private checkDocumentNeedRemove(name: string) {
+    if (!this.subscribesByDocument.get(name)?.size) {
+      if (this.debug) {
+        console.log('[CRDT] delete document', name)
+      }
+
+      this.documents.get(name)?.destroy()
+      this.documents.delete(name)
+    }
+  }
+
+  // очистка подписки (при отписке клиента - через emit-метод или options-хук)
   private cleanSubscribe(subscribe_id: string) {
     const subscribe = this.subscribes.get(subscribe_id)
     if (subscribe) {
@@ -150,26 +235,19 @@ export class CuboCrdtServer<M, A = {}> {
       }
 
       // удаляем подписку по сущности
-      this.subscribesByEntity.get(subscribe.entity)?.delete(subscribe.id)
+      this.subscribesByEntity.get(subscribe.entity as E)?.delete(subscribe.id)
 
-      // отписываем все документы
-      this.documentsSubsrcibes.forEach((subs, docName) => {
-        subs.delete(subscribe_id)
-
-        if (!subs?.size) {
-          if (this.debug) {
-            console.log('[CRDT] delete document', docName)
-          }
+      // отписываем все документы от подписки
+      this.subscribesByDocument.forEach((subscribes, docName) => {
+        subscribes.delete(subscribe_id)
 
-          this.documents.get(docName)?.destroy()
-          this.documents.delete(docName)
-        }
+        this.checkDocumentNeedRemove(docName)
       })
 
       // удаляем подписки
       this.subscribes.delete(subscribe_id)
       this.subscribesByClient.get(subscribe.client_id)?.delete(subscribe_id)
-      this.subscribesByEntity.get(subscribe.entity)?.delete(subscribe_id)
+      this.subscribesByEntity.get(subscribe.entity as E)?.delete(subscribe_id)
     }
   }
 
@@ -178,12 +256,22 @@ export class CuboCrdtServer<M, A = {}> {
   }
 
   public getSutableSubscribes(entity: string, row: any) {
-    return Array.from(this.subscribesByEntity.get(entity) || [])
-      .filter((m) => checkRowIsSutable(row, m[1].filters))
+    return Array.from(this.subscribesByEntity.get(entity as E) || [])
+      .filter((m) => {
+        const subscribe = this.subscribes.get(m[1])
+
+        let state = subscribe && checkRowIsSutable(row, subscribe)
+        if (this.options.checkRowIsSutable) {
+          state = this.options.checkRowIsSutable(state, { entity: entity as any, subscribe, row })
+        }
+
+        return state
+      })
       .map((m) => m[1])
   }
 
-  public ensureDocument(entity: string, row: any, subscribes_ids?: string[]) {
+  public ensureDocument(entity: E, row: any) {
+    // todo: врапнуть всё это в Promise
     const entity_id = row.id
     const documentName = `${entity}:${entity_id}`
 
@@ -192,11 +280,12 @@ export class CuboCrdtServer<M, A = {}> {
     if (!document) {
       document = new CuboCrdtServerDocument({
         name: documentName,
-        onCreate: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => {
-          this.pushDocumentAction('create', document!, data, origin)
-        },
+        initialState: row,
         onUpdate: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => {
-          this.pushDocumentAction('update', document!, data, origin)
+          // пушим обновление документа
+          // console.log('push document update', document.name)
+
+          this.pushDocumentAction('update', entity, document!, data, origin)
         },
         onStore: (item: object, origin: CuboCrdtServerDocumentOrigin) => {
           const subscribe = origin.subscribe_id && this.subscribes.get(origin.subscribe_id)
@@ -208,47 +297,37 @@ export class CuboCrdtServer<M, A = {}> {
         }
       })
 
+      // создаём документ
       this.documents.set(documentName, document)
 
-      this.documentsSubsrcibes.set(documentName, new Set())
-      if (subscribes_ids?.length) {
-        const subs = this.documentsSubsrcibes.get(documentName)
-        subscribes_ids?.forEach((id) => {
-          // добавляем подписку к документу
-          subs?.add(id)
-        })
-      }
+      // создаём пул подписок по документу
+      this.subscribesByDocument.set(documentName, new Set())
 
-      // инициализируем документ
-      document.init(row)
+      // пушим создание документа
+      this.pushDocumentAction('create', entity, document, document.stateAsUpdate)
+
+      // console.log('create document', documentName)
     } else {
-      // добавляем подписки к документу
-      const subs = this.documentsSubsrcibes.get(documentName)
-      subscribes_ids?.forEach((subscribe_id) => {
-        subs?.add(subscribe_id)
+      // console.log('update document', documentName)
 
-        // пушим документ в сокеты (в текущем состоянии)
-        this.pushDocumentAction('update', document!, document!.stateAsUpdate, { subscribe_id, expose: 'subscribe' })
-      })
+      // пушим обновление документа
+      this.pushDocumentAction('upsert', entity, document, document.stateAsUpdate)
     }
 
-    return this.documents.get(documentName)
+    return document
   }
 
-  public deleteDocument(entity: string, row: any) {
+  public deleteDocument(entity: E, row: any, origin?: CuboCrdtClientDocOrigin) {
     if (this.debug) {
-      console.log('[CRDT] delete document', entity, row.id)
+      console.log('[CRDT] delete document', entity, row.id, origin)
     }
 
     const documentName = `${entity}:${row.id}`
     const document = this.documents.get(documentName)
 
     if (document) {
-      // отписываемся от всех подписок на документ
-      this.pushDocumentAction('delete', document, null, { expose: 'subscribe' })
-
-      // удаляем все подписки по документу
-      this.documentsSubsrcibes.delete(documentName)
+      // сначала пушим удаление документа
+      this.pushDocumentAction('delete', entity, document, null, origin)
 
       // удаляем документ
       this.documents.delete(documentName)
@@ -278,127 +357,186 @@ export class CuboCrdtServer<M, A = {}> {
     console.warn('[CRDT] onDocumentExternalDelete not implemented')
   }
 
-  private documentUnsubscribe(docName: string, subscribe_id: string, push = true) {
-    const document = this.documents.get(docName)
+  private checkSubscribeIsSutable(origin: CuboCrdtServerDocumentOrigin, subscribe?: CuboCrdtServerSubscribe) {
+    if (!subscribe) {
+      return false
+    }
 
-    if (document) {
-      // сначала отсылаем, затем удаляем подписки (иначе не будет куда слать)
-      if (push) {
-        this.pushDocumentAction('delete', document, null, { subscribe_id, expose: 'subscribe' })
-      }
+    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
 
-      const documentSubscribes = this.documentsSubsrcibes.get(docName)
-      documentSubscribes?.delete(subscribe_id)
+    return noStrategyResolved || strategyOtherResolved || strategyClientResolved || strategySubscribeResolved
+  }
 
-      // если нет больше подписок - удаляем документ
-      if (!documentSubscribes?.size) {
-        if (this.debug) {
-          console.log('[CRDT] delete document', name)
-        }
+  private checkRowIsSutable(row: any, subscribe: CuboCrdtServerSubscribe, entity: E) {
+    const baseState = checkRowIsSutable(row, subscribe.filters || {})
 
-        document?.destroy()
-        this.documents.delete(document.name)
-      }
+    if (!this.options.checkRowIsSutable) {
+      return baseState
     }
+
+    return this.options.checkRowIsSutable(baseState, { entity, subscribe, row: row as any })
   }
 
   private pushDocumentAction(
     action: CuboCrdtAction,
+    entity: E,
     document: CuboCrdtServerDocument,
     data?: Uint8Array | null,
     origin?: CuboCrdtServerDocumentOrigin
   ) {
     const row = document.getJson()
 
-    if (this.debug) {
-      console.log('[CRDT] pushDocumentAction ' + action, {
-        action,
-        row_id: row.id,
-        subscribes: Array.from(this.documentsSubsrcibes.get(document.name)!)
-      })
-    }
+    // берём все подписки по сущности
+    const sutableSubscribes = Array.from(this.subscribesByEntity.get(entity))
+      .map((subscribe_id) => {
+        const subscribe = this.subscribes.get(subscribe_id)
+
+        const subscribeSutable = this.checkSubscribeIsSutable(origin, subscribe)
+        const documentExistsInSubscribe = this.subscribesByDocument.get(document.name)?.has(subscribe.id)
+        const rowSutable = this.checkRowIsSutable(row, subscribe, entity)
+
+        const sutable = subscribeSutable && (rowSutable || documentExistsInSubscribe)
+
+        if (sutable) {
+          if (this.debug && !rowSutable) {
+            console.warn('row is not sutable for subscribe', {
+              entity,
+              row,
+              subscribe,
+              subscribeSutable,
+              documentExistsInSubscribe,
+              rowSutable
+            })
+          }
 
-    switch (action) {
-      case 'delete': {
-        this.documentsSubsrcibes.get(document.name)?.forEach((subscribe_id) => {
-          const subscribe = this.subscribes.get(subscribe_id)
-          if (subscribe) {
-            const client = this.clients.get(subscribe.client_id)
-
-            if (client) {
-              if (this.debug) {
-                console.log('[CRDT] send action ' + action, subscribe.entity, row.id, subscribe_id)
-              }
-
-              // todo: send сделать через очередь (с группировкой по клиенту)
-              client.send(
-                JSON.stringify({
-                  method: CUBO_CRDT_EVENT.EVENT,
-                  data: {
-                    action,
-                    entity: subscribe.entity,
-                    entity_id: row.id,
-                    subscribe_id: subscribe.id
-                  }
-                })
-              )
+          let sutableAction = action
+          let sutableData: any = data ? Array.from(data as any).slice(0) : undefined
+
+          if (!rowSutable && action === 'update') {
+            if (this.debug) {
+              console.log('switch action', action + ' -> delete', { name: document.name, subscribe: subscribe.id })
             }
-          }
-        })
-        break
-      }
-      case 'update':
-      case 'create': {
-        this.documentsSubsrcibes.get(document.name)?.forEach((subscribe_id) => {
-          const subscribe = this.subscribes.get(subscribe_id)
-
-          if (subscribe) {
-            const client = this.clients.get(subscribe.client_id)
-
-            if (client) {
-              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
-
-              if (noStrategyResolved || strategyOtherResolved || strategyClientResolved || strategySubscribeResolved) {
-                const isSutable = checkRowIsSutable(document.getJson(), subscribe.filters || {})
-
-                // если документ перестал быть доступным в рамках указанных фильтров - удаляем его
-                if (!isSutable) {
-                  this.documentUnsubscribe(document.name, subscribe.id)
-                } else {
-                  if (this.debug) {
-                    console.log('[CRDT] send action ' + action, subscribe.entity, row.id, origin, {
-                      noStrategyResolved,
-                      strategyOtherResolved,
-                      strategyClientResolved,
-                      strategySubscribeResolved
-                    })
-                  }
-
-                  // todo: send сделать через очередь (с группировкой по клиенту)
-                  client.send(
-                    JSON.stringify({
-                      method: CUBO_CRDT_EVENT.EVENT,
-                      data: {
-                        action,
-                        entity: subscribe.entity,
-                        entity_id: row.id,
-                        data: Array.from(data as any),
-                        subscribe_id: subscribe.id
-                      }
-                    })
-                  )
-                }
-              }
+
+            sutableAction = 'delete'
+            sutableData = null
+          } else if (action === 'update' && !documentExistsInSubscribe) {
+            if (this.debug) {
+              console.log('switch action', 'update -> create', { name: document.name, subscribe: subscribe.id })
             }
+
+            sutableAction = 'create'
+            sutableData = Array.from(document.stateAsUpdate)
+          } else if (action === 'upsert' && !documentExistsInSubscribe) {
+            if (this.debug) {
+              console.log('switch action', 'upsert -> create', { name: document.name, subscribe: subscribe.id })
+            }
+
+            sutableAction = 'create'
+            sutableData = Array.from(document.stateAsUpdate)
+          } else if (action === 'delete' && !documentExistsInSubscribe) {
+            if (this.debug) {
+              console.warn('document to delete is not exist', { name: document.name, subscribe: subscribe.id })
+            }
+          } else if (action === 'create' && documentExistsInSubscribe) {
+            if (this.debug) {
+              console.warn('document to create is already exists in subscribe', { name: document.name, subscribe: subscribe.id })
+            }
+            sutableAction = 'update'
           }
+
+          return {
+            subscribe,
+            action: sutableAction,
+            data: sutableData
+          }
+        }
+
+        return null
+      })
+      .filter((i) => !!i) as { subscribe: CuboCrdtServerSubscribe; action: CuboCrdtAction; data: undefined | number[] }[]
+
+    if (sutableSubscribes.length) {
+      const documentSubscribes = this.subscribesByDocument.get(document.name)
+
+      sutableSubscribes.forEach(({ subscribe, action, data }) => {
+        this.sendToClient(subscribe.client_id, {
+          action,
+          entity: subscribe.entity,
+          entity_id: row.id,
+          data,
+          subscribe_id: subscribe.id
         })
-      }
+
+        switch (action) {
+          case 'create':
+          case 'upsert':
+          case 'update':
+            documentSubscribes.add(subscribe.id)
+            break
+          case 'delete':
+            documentSubscribes.delete(subscribe.id)
+            this.checkDocumentNeedRemove(document.name)
+            break
+        }
+      })
     }
   }
 
+  private async pushSubscribeDocuments(client: WsServerSocket, subscribe: CuboCrdtServerSubscribe) {
+    // получаем список всех документов
+    const rows = await this.options.fetchRows?.(client, subscribe)
+
+    // пушим их в сокеты
+    for (const row of rows || []) {
+      // this.ensureDocument(subscribe.entity as E, row, { subscribes_ids: [subscribe.id] })
+      this.ensureDocument(subscribe.entity as E, row)
+    }
+  }
+
+  // апгрейд подписки (фильтры поменялись например)
+  private async upgradeSubscribe(
+    client: WsServerSocket,
+    subscribe: CuboCrdtServerSubscribe,
+    upgrade: Partial<Pick<CuboCrdtServerSubscribe, 'filters'>>
+  ) {
+    if (this.subscribesUpgrading.has(subscribe.id)) {
+      return this.subscribesUpgrading.get(subscribe.id)
+    }
+
+    this.subscribesUpgrading.set(
+      subscribe.id,
+      new Promise<void>(async (resolve, reject) => {
+        try {
+          if (this.debug) {
+            console.log('[CRDT] upgrade subscribe ' + client.id, subscribe)
+          }
+
+          if (upgrade.filters) {
+            subscribe.filters = cloneDeep(upgrade.filters || {})
+          }
+
+          await this.pushSubscribeDocuments(client, subscribe)
+
+          resolve()
+        } catch (e) {
+          if (this.debug) {
+            console.error('[CRDT] upgrade subscribe', e)
+          }
+
+          reject(e)
+        } finally {
+          this.subscribesUpgrading.delete(subscribe.id)
+        }
+      })
+    )
+
+    return this.subscribesUpgrading.get(subscribe.id)
+  }
+
+  // инциализация подписки
   private async initSubscribe(client: WsServerSocket, subscribe: CuboCrdtServerSubscribe) {
     if (this.subscribesIniting.has(subscribe.id)) {
       return this.subscribesIniting.get(subscribe.id)
@@ -409,20 +547,15 @@ export class CuboCrdtServer<M, A = {}> {
       new Promise<void>(async (resolve, reject) => {
         try {
           if (this.debug) {
-            console.log('[CRDT] initSubscribe ' + client.id, subscribe)
+            console.log('[CRDT] init subscribe ' + client.id, subscribe)
           }
 
-          // получаем список всех документов
-          const rows = await this.options.fetchRows?.(client, subscribe)
-
-          for (const row of rows || []) {
-            this.ensureDocument(subscribe.entity, row, [subscribe.id])
-          }
+          await this.pushSubscribeDocuments(client, subscribe)
 
           resolve()
         } catch (e) {
           if (this.debug) {
-            console.error(`[CRDT] initSubscribe`, e)
+            console.error('[CRDT] init subscribe', e)
           }
 
           reject(e)

package/src/server/types/document.ts

@@ -3,10 +3,12 @@ import { CuboCrdtAction, CuboCrdtExposeStrategy } from '../../types'
 export type CuboCrdtServerDocumentOptions = {
   name: string
   onStore?: (body: object, origin: CuboCrdtServerDocumentOrigin) => void
-  onCreate?: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => void
+  // onCreate?: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => void
   onUpdate?: (data: Uint8Array, origin?: CuboCrdtServerDocumentOrigin) => void
   // onInit?: (document: CuboCrdtServerDocument) => void
 
+  initialState?: object
+
   yjsOptions?: {
     guid?: string
     collectionid?: string

package/src/server/types/index.ts

@@ -5,18 +5,21 @@ import { CuboCrdtServerSubscribe } from './subscribe'
 export * from './document'
 export * from './subscribe'
 
-export type CuboCrdtServerOptions<M, A> = {
+export type CuboCrdtServerOptions<M, A, E extends Extract<keyof M, string>> = {
   ws: WsServer
-  entities: Extract<keyof M, string>[]
+  entities: E[]
   debug?: boolean
-  fetchRows?: (client: WsServerSocket, subscribe: CuboCrdtServerSubscribe) => Promise<M[Extract<keyof M, string>][]>
-  storeRow?: <K extends Extract<keyof M, string>>(
+  fetchRows?: (client: WsServerSocket, subscribe: CuboCrdtServerSubscribe) => Promise<M[E][]>
+  checkRowIsSutable?: (baseState: boolean, ctx: { entity: E; subscribe: CuboCrdtServerSubscribe; row: any }) => boolean
+  storeRow?: <K extends E>(
     entity: K,
     entity_id: number,
     row: M[K],
     opts: {
-      client: WsServerSocket<{ auth?: A }>
+      client: CuboCrdtSocketClient<A>
       origin: CuboCrdtServerDocumentOrigin
     }
   ) => Promise<void> | void
 }
+
+export type CuboCrdtSocketClient<A> = WsServerSocket<{ auth?: A }>

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' | 'update' | 'delete'
+export type CuboCrdtAction = 'create' | 'upsert' | 'update' | 'delete'
 
 export type CuboCrdtExposeStrategy = 'all' | 'other' | 'subscribe' | 'client'