@cuboapp/api-backend 1.0.23 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/api-backend",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "Backend Api for CuboApp",
   "main": "src/index.ts",
   "repository": "git@github.com:cuboapp/api-backend.git",
@@ -8,14 +8,16 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@cuboapp/constants": "^2.0.5",
-    "@cuboapp/database": "^1.0.2",
-    "@cuboapp/types": "^2.0.6",
-    "@cuboapp/utils": "1.0.4",
-    "@hocuspocus/extension-database": "^3.2.3",
-    "@hocuspocus/server": "^3.2.3",
+    "@cuboapp/constants": "^2.0.6",
+    "@cuboapp/crdt": "1.0.5",
+    "@cuboapp/database": "^1.0.3",
+    "@cuboapp/types": "^2.0.11",
+    "@cuboapp/utils": "1.0.9",
+    "@cuboapp/ws": "1.0.4",
+    "@hocuspocus/extension-database": "^3.4.3",
+    "@hocuspocus/server": "^3.4.3",
     "pg": "^8.16.3",
-    "yjs": "^13.6.27"
+    "yjs": "^13.6.29"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",

package/src/constants/index.ts

@@ -8,6 +8,8 @@ export const CUBO_CRUD_QUERY_SYMBOL_NOT = 'not'
 export const CUBO_CRUD_DEFAULT_PAGE_LIMIT = 25
 export const CUBO_CRUD_MAX_PAGE_LIMIT = 500
 
+export const CUBO_CRUD_ACTION = ['create', 'read', 'update', 'delete'] as const
+
 export const CUBO_CRUD_QUERY_CONDITION = {
   EQ: 'eq',
   EX: 'ex',

package/src/crdt/index.ts

@@ -123,21 +123,25 @@ export class CuboCrdt<T extends CuboApiEntitiesMap<T>> {
 
             body.modified_at = new Date().toISOString()
 
-            await this.api.updateOne(
-              entityAlias as Extract<keyof T, string>,
-              {
-                query: { id },
-                body
-              },
-              {
-                crdt: false,
-                extra: {
-                  auth: context.auth
+            await this.api
+              .updateOne(
+                entityAlias as Extract<keyof T, string>,
+                {
+                  query: { id },
+                  body
                 },
-                excludeHooks: [],
-                queryOptions: { withDeleted: true, withCrdt: true }
-              }
-            )
+                {
+                  crdt: false,
+                  extra: {
+                    auth: context.auth
+                  },
+                  excludeHooks: [],
+                  queryOptions: { withDeleted: true, withCrdt: true }
+                }
+              )
+              .catch((e) => {
+                console.log('crdt on store error', { body })
+              })
           }
         })
       ],

package/src/helpers/index.ts

@@ -18,8 +18,8 @@ import { ApiHelpersData } from './data'
 
 import { ApiHelpersWithes } from './withes'
 
-export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
-  constructor(public api: CuboBackendApi<T>) {}
+export class ApiHelpers<T extends CuboApiEntitiesMap<T>, A> {
+  constructor(public api: CuboBackendApi<T, A>) {}
 
   public withes = new ApiHelpersWithes<T>(this)
   public convert = new ApiHelpersConvert<T>(this)
@@ -450,11 +450,11 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
 
     let entityFields = entity.fields
 
-    if (this.api.crdt?.isCrdtSupported(entity) && !withCrdt) {
-      const crdtKey = this.api.crdt?.getCrdtField(entity)
+    // if (this.api.crdt?.isCrdtSupported(entity) && !withCrdt) {
+    //   const crdtKey = this.api.crdt?.getCrdtField(entity)
 
-      entityFields = entityFields.filter((f) => f.alias !== crdtKey?.alias)
-    }
+    //   entityFields = entityFields.filter((f) => f.alias !== crdtKey?.alias)
+    // }
 
     selects.push(...entityFields.map((f) => `t1.${f.alias}`))
 

package/src/index.ts

@@ -1,21 +1,26 @@
+import { CUBO_CRDT_EVENT, CuboCrdt } from '@cuboapp/crdt'
 import { QueryTypes } from '@cuboapp/database'
 import { CuboApiEntitiesMap } from '@cuboapp/types'
+import { createWsServer, WsServer } from '@cuboapp/ws'
 
-import { CuboCrdt } from './crdt'
 import { ApiHelpers } from './helpers'
-import { CuboBackendApiAuth, CuboBackendApiOptions, CuboCrudGetManyResponse, CuboCrudMethodOptions, CuboCrudRequest } from './types'
+import {
+  CuboBackendApiAuth,
+  CuboBackendApiOptions,
+  CuboCrudAction,
+  CuboCrudGetManyResponse,
+  CuboCrudMethodOptions,
+  CuboCrudRequest
+} from './types'
 
-export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
-  constructor(public options: CuboBackendApiOptions<T>) {
-    if (options.crdt) {
-      this.crdt = new CuboCrdt<T>(this)
-      this.crdt.listen()
-    }
-  }
+export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown> {
+  public crdt?: CuboCrdt<T, A>
+  public ws?: WsServer<{ auth: A; subscribes: Map<string, any[]> }>
+
+  constructor(public options: CuboBackendApiOptions<T, A>) {}
 
   public auth: CuboBackendApiAuth
-  public crdt?: CuboCrdt<T>
-  public helpers = new ApiHelpers<T>(this)
+  public helpers = new ApiHelpers<T, A>(this)
 
   async init() {
     try {
@@ -37,6 +42,241 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
           }
         }
       }
+
+      if (this.options.crdt !== undefined) {
+        type ID = `${Extract<keyof T, string>}:${number | string}`
+
+        this.crdt = new CuboCrdt<T, A>({
+          ...this.options.crdt,
+          beforeLoadDocument: async (name: ID) => {
+            const [entityAlias, id] = name.split(':') as [Extract<keyof T, string>, string]
+
+            // console.log('beforeLoadDocument', { entityAlias, id })
+
+            return this.getOne(entityAlias, { query: { id: +id } })
+          }
+        })
+
+        this.ws = createWsServer<{ auth: A; subscribes: Map<string, any[]> }>({
+          host: this.options.crdt.host,
+          port: this.options.crdt.port,
+          debug: this.options.crdt.debug,
+          auth:
+            this.options.crdt.authHandler !== undefined
+              ? {
+                  default: true,
+                  handler: async (ctx) => {
+                    ctx.request.auth = await this.options.crdt.authHandler!(ctx)
+                  }
+                }
+              : undefined,
+
+          onDisconnect: (socket) => {
+            this.crdt.documents.forEach((doc) => {
+              doc.removeClient(socket)
+
+              this.crdt.checkDocumentUnload(doc.opts.name as any)
+            })
+          }
+        })
+
+        await this.ws.start()
+        await this.crdt.start()
+
+        this.ws.registerHandler<{ name: ID }>('crdt:open', async ({ client, message }) => {
+          const { name } = message.data || {}
+          if (!name) {
+            throw 'Имя документа обязательно: "name"'
+          }
+
+          if (this.options.crdt.debug) {
+            console.log('open document', name)
+          }
+
+          try {
+            const document = await this.crdt.getDocument(name)
+            document.addClient(client)
+
+            if (this.options.crdt.debug) {
+              console.log('document', name, 'subscribed', document.stat)
+            }
+
+            return Array.from(document.stateAsUpdate)
+          } catch (e) {
+            console.error('CRDT open document', e)
+            throw e
+          }
+        })
+
+        this.ws.registerHandler<{ name: ID }>('crdt:close', async ({ client, message }) => {
+          const { name } = message.data || {}
+          if (!name) {
+            throw 'Имя документа обязательно: "name"'
+          }
+
+          const document = await this.crdt.getDocument(name)
+          document.removeClient(client)
+
+          if (this.options.crdt.debug) {
+            console.log('document', name, 'unsubscribed', document.stat)
+          }
+
+          await this.crdt.checkDocumentUnload(name)
+
+          return true
+        })
+
+        this.ws.registerHandler<string>('crdt:subscribe', async ({ client, message }) => {
+          let { crdt, event, filters } = message.data as any
+          filters = filters || {}
+
+          if (crdt) {
+            event = `crdt:update:${crdt.entity}:${crdt.id}`
+            filters = { id: crdt.id }
+
+            // console.log('subscribe to crdt', event, filters)
+          }
+
+          client.subscribes = client.subscribes || new Map()
+          const subs = client.subscribes.get(event) || []
+          const ex = subs.find((s) => JSON.stringify(s) === JSON.stringify(filters))
+          if (!ex) {
+            subs.push(filters)
+          }
+          client.subscribes.set(event, subs)
+
+          if (this.options.crdt.debug) {
+            console.log(
+              'crdt:subscribe',
+              client.id,
+              JSON.stringify({ event, filters }),
+              Array.from(client.subscribes).map((s) => [s[0], JSON.stringify(s[1])])
+            )
+          }
+        })
+
+        this.ws.registerHandler<string>('crdt:unsubscribe', async ({ client, message }) => {
+          let { event, filters } = message.data as any
+          filters = filters || {}
+
+          client.subscribes = client.subscribes || new Map()
+          const subs = client.subscribes.get(event) || []
+          const exIndex = subs.findIndex((s) => JSON.stringify(s) === JSON.stringify(filters))
+          if (exIndex >= 0) {
+            subs.splice(exIndex)
+          }
+          if (!subs.length) {
+            client.subscribes.delete(event)
+          } else {
+            client.subscribes.set(event, subs)
+          }
+
+          if (this.options.crdt.debug) {
+            console.log('crdt:unsubscribe', client.id, { event, filters }, Array.from(client.subscribes))
+          }
+        })
+
+        const subFilterCheck = (row: any, filters: any) => {
+          let sutable = true
+
+          Object.entries(filters).forEach(([key, value]) => {
+            if (!['limit', 'with'].includes(key)) {
+              const [formula, str] = `${value}`.split(':')
+
+              // console.log({ formula, str, value: row[key] })
+
+              if (!str) {
+                if (row[key] !== value) {
+                  sutable = false
+                }
+              } else {
+                switch (formula) {
+                  case 'in':
+                    if (
+                      !str
+                        .split(',')
+                        .map(Number)
+                        .includes(row[key] as number)
+                    ) {
+                      sutable = false
+                    }
+                    break
+                  default:
+                    sutable = false
+                    break
+                }
+              }
+            }
+          })
+
+          return sutable
+        }
+
+        const onDocumentEvent = async (name: string, action: CuboCrudAction, data?: Uint8Array) => {
+          const [entityAlias, id] = name.split(':') as [Extract<keyof T, string>, string]
+
+          const entity = await this.helpers.getEntityByAlias(entityAlias)
+
+          const row = await this.getOne(entityAlias, { query: { id: +id } }, { queryOptions: { withDeleted: true } })
+
+          const a = this.options?.augmentations?.[entityAlias]
+          const filterCheck = a?.filterRowForCrdtEvent ?? subFilterCheck
+
+          try {
+            for (const client of Array.from(this.ws?.clients)) {
+              const hasCardSub = client.subscribes?.get(`crdt:${entityAlias}:${id}`)
+              const hasEntitySub = client.subscribes?.get(`crdt:${entityAlias}`)
+              const hasCrdtSub = client.subscribes?.get(`crdt:update:${entityAlias}:${id}`)
+
+              const needCardPush = !hasCardSub?.length || !!hasCardSub.find((f) => !!filterCheck(row, f)) || false
+              const needEntityPush = !hasEntitySub?.length || !!hasEntitySub.find((f) => !!filterCheck(row, f)) || false
+              const needCrdtPush = !hasCrdtSub?.length || !!hasCrdtSub.find((f) => !!filterCheck(row, f)) || false
+
+              // console.log(id, name, action, {
+              //   hasCardSub,
+              //   hasEntitySub,
+              //   hasCrdtSub,
+              //   needCardPush,
+              //   needEntityPush,
+              //   needCrdtPush,
+              //   filterCheck
+              // })
+
+              if (needCrdtPush && data?.length) {
+                client.send(JSON.stringify({ method: 'message', event: `crdt:update:${entityAlias}:${id}`, data: Array.from(data) }))
+              }
+
+              if (needCardPush || needEntityPush) {
+                if (!a?.can || (await a.can<A>(action, { auth: client.auth, entity, row }))) {
+                  const dto = {
+                    event: `crdt:${entityAlias}`,
+                    action,
+                    id: id ? +id : null,
+                    row
+                  }
+
+                  if (a?.sendCrdtEvent) {
+                    await a.sendCrdtEvent({ client, auth: client.auth, entity, dto })
+                  } else {
+                    client.send(JSON.stringify({ method: 'message', ...dto }))
+                  }
+                } else {
+                  console.log('sutable pushes cannot', name)
+                }
+              } else {
+                console.log('no sutable pushes', name)
+              }
+            }
+          } catch (e) {
+            console.log(e)
+          }
+        }
+
+        // document events
+        this.crdt.ee.addListener(CUBO_CRDT_EVENT.DOCUMENT_UPDATED, (ctx) => onDocumentEvent(ctx.name, 'update', ctx.data))
+        this.crdt.ee.addListener(CUBO_CRDT_EVENT.DOCUMENT_CREATED, (ctx) => onDocumentEvent(ctx.name, 'create', ctx.data))
+        this.crdt.ee.addListener(CUBO_CRDT_EVENT.DOCUMENT_DELETED, (ctx) => onDocumentEvent(ctx.name, 'delete', ctx.data))
+      }
     } catch (e) {
       console.error('[API-BACKEND] startup error', e)
     }
@@ -151,7 +391,7 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
     // get all joins
     const queryDto = await this.helpers.withes.prepare(req, entity, opts)
     queryDto.withDeleted = opts.queryOptions?.withDeleted
-    queryDto.withCrdt = opts.queryOptions?.withCrdt
+    // queryDto.withCrdt = opts.queryOptions?.withCrdt
 
     // create find query
     const regularQuery = await this.helpers.createFindQuery(req, entity, queryDto)
@@ -271,17 +511,8 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
       response = await augmentation.afterCreate(response, req, opts)
     }
 
-    if (opts.crdt !== false && this.crdt?.isCrdtSupported(entity)) {
-      const state = await this.crdt.createState({ entityAlias, id: created_id, entity }, response)
-
-      const fieldKey = entity.fields.find((f) => f.type === 'binary').alias
-
-      const db = await this.helpers.getConnection('read')
-      await db.update(entity!.alias, 'id=:id', { id: created_id }, { [fieldKey]: state }, opts)
-
-      if (augmentation?.afterCrdtCreate && !opts?.excludeHooks?.includes('afterCrdtCreate')) {
-        augmentation.afterCrdtCreate(response, req, opts)
-      }
+    if (this.crdt) {
+      this.crdt.ee.emit(CUBO_CRDT_EVENT.DOCUMENT_CREATED, { name: `${entityAlias}:${(response as any).id}` })
     }
 
     return response
@@ -306,6 +537,14 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
       throw { status: 404, text: 'Entity not found' }
     }
 
+    try {
+      if (!!augmentation?.can) {
+        await augmentation.can('update', { entity, row: item, auth: opts?.extra?.auth, req })
+      }
+    } catch {
+      throw { status: 403, text: 'Updating entity forbidden' }
+    }
+
     const dto = await this.helpers.data.prepare('update', entity!.fields, req.body, opts?.performer_id || 0)
     if (!Object.keys(dto)) {
       throw { status: 400, text: 'No keys to update' }
@@ -323,13 +562,8 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
       response = await augmentation.afterUpdate(response, req, opts)
     }
 
-    if (opts.crdt !== false && this.crdt?.isCrdtSupported(entity)) {
-      const context = { auth: opts?.extra?.auth }
-      await this.crdt.updateDocument({ entityAlias, id: item.id, entity }, response, context)
-
-      if (augmentation?.afterCrdtUpdate && !opts?.excludeHooks?.includes('afterCrdtUpdate')) {
-        augmentation.afterCrdtUpdate(response, req, opts)
-      }
+    if (this.crdt) {
+      await this.crdt.updateDocument(`${entityAlias}:${item.id}`, dto)
     }
 
     return response
@@ -365,10 +599,14 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
       return augmentation.afterDelete(item, req, opts)
     }
 
+    if (this.crdt) {
+      this.crdt.ee.emit(CUBO_CRDT_EVENT.DOCUMENT_DELETED, { name: `${entityAlias}:${item.id}` })
+    }
+
     return true
   }
 }
 
-export * from './crdt'
+// export * from './crdt'
 export * from './helpers'
 export * from './types'

package/src/types/augmentation.ts

@@ -1,14 +1,28 @@
-import { CuboApiEntitiesMap } from '@cuboapp/types'
+import { CuboApiEntitiesMap, CuboEntity } from '@cuboapp/types'
 
-import { CuboCrudGetManyResponse, CuboCrudRequest } from './basic'
+import { WsServerSocket } from '@cuboapp/ws'
+import { CuboCrudAction, CuboCrudGetManyResponse, CuboCrudRequest } from './basic'
 import { CuboCrudMethodOptions, CuboCrudQueryOptions } from './db'
-import { onChangePayload, onLoadDocumentPayload, onStoreDocumentPayload } from '@hocuspocus/server'
 
 export type CuboCrudAugmentationsStore<T extends CuboApiEntitiesMap<T>> = {
   [K in Extract<keyof T, string>]?: CuboCrudAugmentationInstance<T[K]>
 }
 
-export interface CuboCrudAugmentationInstance<T = unknown> {
+export type CuboCrudCrdtEvent<A, T> = {
+  client: WsServerSocket
+  auth: A
+  entity: CuboEntity
+  req?: CuboCrudRequest
+  dto: {
+    // type: string
+    event: string
+    action: CuboCrudAction
+    row: T
+    id: number
+  }
+}
+
+export interface CuboCrudAugmentationInstance<T> {
   beforeGetMany?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
   afterGetMany?: (
     result: CuboCrudGetManyResponse<T>,
@@ -30,7 +44,8 @@ export interface CuboCrudAugmentationInstance<T = unknown> {
   beforeDelete?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
   afterDelete?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<boolean>
 
-  onLoadDocument?: (data: onLoadDocumentPayload) => Promise<void>
-  onChangeDocument?: (data: onChangePayload) => Promise<void>
-  onStoreDocument?: (data: onStoreDocumentPayload) => Promise<void>
+  filterRowForCrdtEvent?: (row: T, filters: any) => boolean
+  sendCrdtEvent?: <A>(context: CuboCrudCrdtEvent<A, T>) => void | Promise<void>
+
+  can?: <A>(action: CuboCrudAction, context: { auth: A; entity: CuboEntity; row: T; req?: CuboCrudRequest }) => boolean | Promise<boolean>
 }

package/src/types/basic.ts

@@ -1,6 +1,10 @@
 import { type Transaction } from '@cuboapp/database'
 import { CuboEntity, CuboEntityField } from '@cuboapp/types'
 
+import { CUBO_CRUD_ACTION } from '@/constants'
+
+export type CuboCrudAction = (typeof CUBO_CRUD_ACTION)[number]
+
 export type CuboCrudWith = {
   entity: CuboEntity | { id: undefined; alias: string; fields: CuboEntityField[] }
   key: string

package/src/types/index.ts

@@ -1,15 +1,14 @@
+import { CuboCrdtOptions } from '@cuboapp/crdt'
 import { Database, DatabaseOptions, Options } from '@cuboapp/database'
 import { CuboApiEntitiesMap, CuboAuthTokenType, CuboEntity } from '@cuboapp/types'
 
-import { CuboCrdtConfiguration } from '../crdt'
-
 import { CuboCrudAugmentationsStore } from './augmentation'
 
 export * from './augmentation'
 export * from './basic'
 export * from './db'
 
-export type CuboBackendApiOptions<T extends CuboApiEntitiesMap<T>> = {
+export type CuboBackendApiOptions<T extends CuboApiEntitiesMap<T>, A> = {
   api?: {
     base_url?: string
     headers: Partial<Record<`cubo-${CuboAuthTokenType}`, string>> & Record<string, any>
@@ -22,7 +21,7 @@ export type CuboBackendApiOptions<T extends CuboApiEntitiesMap<T>> = {
     options?: Options & DatabaseOptions
   }
 
-  crdt?: CuboCrdtConfiguration<T>
+  crdt?: Omit<CuboCrdtOptions<A>, 'beforeLoadDocument'>
 
   augmentations?: Partial<CuboCrudAugmentationsStore<T>>
 }