@cuboapp/api-backend 1.0.25 → 1.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/api-backend",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "Backend Api for CuboApp",
   "main": "src/index.ts",
   "repository": "git@github.com:cuboapp/api-backend.git",
@@ -8,15 +8,13 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@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",
+    "@cuboapp/constants": "2.0.7",
+    "@cuboapp/crdt": "1.0.6",
+    "@cuboapp/database": "1.0.4",
+    "@cuboapp/types": "2.0.11",
+    "@cuboapp/utils": "1.0.10",
+    "@cuboapp/ws": "1.0.5",
+    "pg": "^8.17.2",
     "yjs": "^13.6.29"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,22 +1,11 @@
-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 { cloneDeep } from '@cuboapp/utils'
 
 import { ApiHelpers } from './helpers'
-import {
-  CuboBackendApiAuth,
-  CuboBackendApiOptions,
-  CuboCrudAction,
-  CuboCrudGetManyResponse,
-  CuboCrudMethodOptions,
-  CuboCrudRequest
-} from './types'
+import { CuboBackendApiAuth, CuboBackendApiOptions, CuboCrudGetManyResponse, CuboCrudMethodOptions, CuboCrudRequest } from './types'
 
 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
@@ -42,241 +31,6 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown>
           }
         }
       }
-
-      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)
     }
@@ -295,6 +49,8 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown>
     }
   }
 
+  private debounces = new Map<`${string}:${number}`, { started: number; promise: Promise<any> }>()
+
   public async request<T>(url: string, opts?: RequestInit & { debug?: boolean; withAuth?: boolean; withoutContentType?: boolean }) {
     const baseUrl = this.options?.api?.base_url || 'https://api.cubo.sh'
 
@@ -511,8 +267,8 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown>
       response = await augmentation.afterCreate(response, req, opts)
     }
 
-    if (this.crdt) {
-      this.crdt.ee.emit(CUBO_CRDT_EVENT.DOCUMENT_CREATED, { name: `${entityAlias}:${(response as any).id}` })
+    if (this.options.hooks?.onAfterCreate && !opts?.excludeHooks?.includes('baseHooks')) {
+      await this.options.hooks.onAfterCreate(entity, response, opts)
     }
 
     return response
@@ -523,6 +279,32 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown>
     req: CuboCrudRequest,
     opts?: CuboCrudMethodOptions
   ): Promise<T[K] | undefined> {
+    if (opts?.debounce) {
+      if (!req.query?.id) {
+        throw 'Debounce "updateOne" allowed only with "id"'
+      }
+      console.log('call debounced updateOne')
+
+      const key = `${entityAlias}:${+req.query.id}` as `${string}:${number}`
+      let ex = this.debounces.get(key)
+      if (ex) {
+        if (ex.started > +new Date() - opts.debounce) {
+          console.log('clear execution')
+          Promise.reject(ex.promise)
+        } else {
+          return ex.promise
+        }
+      }
+
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          this.updateOne(entityAlias, req, { ...(opts || {}), debounce: undefined })
+            .then(resolve)
+            .catch(reject)
+        }, opts.debounce)
+      })
+    }
+
     opts = opts || {}
     const entity = await this.helpers.getEntityByAlias(entityAlias)
     const augmentation = this.options?.augmentations?.[entityAlias]
@@ -537,6 +319,8 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown>
       throw { status: 404, text: 'Entity not found' }
     }
 
+    const initialEntity = cloneDeep(item)
+
     try {
       if (!!augmentation?.can) {
         await augmentation.can('update', { entity, row: item, auth: opts?.extra?.auth, req })
@@ -562,8 +346,8 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown>
       response = await augmentation.afterUpdate(response, req, opts)
     }
 
-    if (this.crdt) {
-      await this.crdt.updateDocument(`${entityAlias}:${item.id}`, dto)
+    if (this.options.hooks?.onAfterUpdate && !opts?.excludeHooks?.includes('baseHooks')) {
+      await this.options.hooks.onAfterUpdate(entity, response, initialEntity, opts)
     }
 
     return response
@@ -595,18 +379,19 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown>
     const db = await this.helpers.getConnection('write')
     await db.update(entity.alias, 'id = :id', { id: item.id }, dto, { transaction: opts?.transaction, log: opts?.log })
 
-    if (augmentation?.afterDelete && !opts?.excludeHooks?.includes('afterDelete')) {
-      return augmentation.afterDelete(item, req, opts)
+    if (this.options.hooks?.onAfterDelete && !opts?.excludeHooks?.includes('baseHooks')) {
+      await this.options.hooks.onAfterDelete(entity, item, opts)
     }
 
-    if (this.crdt) {
-      this.crdt.ee.emit(CUBO_CRDT_EVENT.DOCUMENT_DELETED, { name: `${entityAlias}:${item.id}` })
+    // console.log(entityAlias, augmentation, opts)
+
+    if (augmentation?.afterDelete && !opts?.excludeHooks?.includes('afterDelete')) {
+      return augmentation.afterDelete(item, req, opts)
     }
 
     return true
   }
 }
 
-// export * from './crdt'
 export * from './helpers'
 export * from './types'