@cuboapp/api-backend 1.0.25 → 1.0.26

package/src/types/db.ts

@@ -1,3 +1,4 @@
+import { CuboCrdtServerDocumentOrigin } from '@cuboapp/crdt'
 import { type Transaction } from '@cuboapp/database'
 
 export type CuboCrudQueryOptions = {
@@ -11,7 +12,7 @@ export type CuboCrudQueryOptions = {
   groupBy?: string
   withDeleted?: boolean
   withCrdt?: boolean
-  
+
   extra?: any
 }
 
@@ -19,6 +20,7 @@ export type CuboCrudMethodOptions<E extends object = {}> = {
   transaction?: Transaction
   performer_id?: number
   extra?: any
+  debounce?: number
   excludeHooks?: (
     | 'beforeGetMany'
     | 'beforeGetOne'
@@ -30,11 +32,12 @@ export type CuboCrudMethodOptions<E extends object = {}> = {
     | 'beforeUpdate'
     | 'afterCrdtCreate'
     | 'afterCrdtUpdate'
+    | 'baseHooks'
   )[]
 
   log?: boolean
   replace?: boolean
-  crdt?: boolean
+  crdt?: CuboCrdtServerDocumentOrigin
 
   queryOptions?: CuboCrudQueryOptions
 } & E

package/src/types/index.ts

@@ -1,8 +1,8 @@
-import { CuboCrdtOptions } from '@cuboapp/crdt'
 import { Database, DatabaseOptions, Options } from '@cuboapp/database'
 import { CuboApiEntitiesMap, CuboAuthTokenType, CuboEntity } from '@cuboapp/types'
 
 import { CuboCrudAugmentationsStore } from './augmentation'
+import { CuboCrudMethodOptions } from './db'
 
 export * from './augmentation'
 export * from './basic'
@@ -21,7 +21,16 @@ export type CuboBackendApiOptions<T extends CuboApiEntitiesMap<T>, A> = {
     options?: Options & DatabaseOptions
   }
 
-  crdt?: Omit<CuboCrdtOptions<A>, 'beforeLoadDocument'>
+  hooks?: {
+    onAfterCreate?: <A extends Extract<keyof T, string>>(entity: CuboEntity, row: T[A], opts: CuboCrudMethodOptions) => void | Promise<void>
+    onAfterUpdate?: <A extends Extract<keyof T, string>>(
+      entity: CuboEntity,
+      row: T[A],
+      oldRow: T[A],
+      opts: CuboCrudMethodOptions
+    ) => void | Promise<void>
+    onAfterDelete?: <A extends Extract<keyof T, string>>(entity: CuboEntity, row: T[A], opts: CuboCrudMethodOptions) => void | Promise<void>
+  }
 
   augmentations?: Partial<CuboCrudAugmentationsStore<T>>
 }

package/src/crdt/index.ts

@@ -1,413 +0,0 @@
-import { QueryTypes } from '@cuboapp/database'
-import { CuboApiEntitiesMap, CuboEntity } from '@cuboapp/types'
-import { Database } from '@hocuspocus/extension-database'
-import { Server } from '@hocuspocus/server'
-import { IncomingHttpHeaders } from 'http'
-import * as Y from 'yjs'
-
-import { CuboBackendApi } from '..'
-import { CuboDirectConnection } from './types'
-
-export * from './types'
-
-export * from '@hocuspocus/server'
-
-export class CuboCrdt<T extends CuboApiEntitiesMap<T>> {
-  public server: Server
-  private documentPrefix = 'cubo'
-  private defaultCrdtFieldAlias = 'crdt_data'
-
-  constructor(public api: CuboBackendApi<T>) {
-    this.init()
-  }
-
-  private init() {
-    const { onAuthenticate, onLoadDocument, onChange, onStoreDocument, afterLoadDocument, connected, ...config } = this.api.options.crdt
-
-    this.server = new Server({
-      port: config.port,
-      extensions: [
-        new Database({
-          fetch: async ({ documentName, context, document, instance, requestHeaders, requestParameters, socketId, connectionConfig }) => {
-            try {
-              const [prefix] = documentName.split('.')
-              if (prefix !== this.documentPrefix) {
-                return null
-              }
-
-              const { entityAlias, id } = this.parseDocumentName(documentName)
-
-              // console.log('fetch', entityAlias, id)
-              if (id <= 0) {
-                return null
-              }
-
-              const entity = await this.api.helpers.getEntityByAlias(entityAlias as keyof T)
-              if (!entity) {
-                throw new Error(`Entity not found: "${entityAlias}"`)
-              }
-
-              const isSupported = this.isCrdtSupported(entity)
-              if (!isSupported) {
-                throw new Error(`Entity "${entityAlias}" does not support CRDT`)
-              }
-
-              const fieldKey = this.getCrdtField(entity)?.alias
-
-              if (!fieldKey) {
-                return null
-              }
-
-              const db = await this.api.helpers.getConnection('write')
-
-              const [data] = await db.connection.query(`SELECT ${fieldKey} from ${entityAlias} where id = :id`, {
-                type: QueryTypes.SELECT,
-                replacements: {
-                  id
-                }
-              })
-
-              if (!data) {
-                throw new Error(`Entity "${entityAlias}" with id=${id} not found`)
-              }
-
-              const raw = (data as any)[fieldKey]
-
-              if (!raw) {
-                return null
-              }
-
-              return raw
-            } catch (error) {
-              console.log('error', error)
-            }
-          },
-          store: async ({ documentName, document, state, context }) => {
-            const [prefix] = documentName.split('.')
-            if (prefix !== this.documentPrefix) {
-              return null
-            }
-
-            const { entityAlias, id } = this.parseDocumentName(documentName)
-
-            if (id <= 0) {
-              return
-            }
-
-            const entity = await this.api.helpers.getEntityByAlias(entityAlias as keyof T)
-            if (!entity) {
-              throw new Error(`Entity not found: "${entityAlias}"`)
-            }
-
-            const isSupported = this.isCrdtSupported(entity)
-            if (!isSupported) {
-              throw new Error(`Entity "${entityAlias}" does not support CRDT`)
-            }
-
-            const entityMap = document.getMap(entityAlias)
-            const body: Record<string, any> = {}
-
-            const fieldKey = this.getCrdtField(entity)?.alias
-
-            for (const [key, value] of entityMap.entries()) {
-              if (key === fieldKey) {
-                continue
-              }
-
-              body[key] = value
-            }
-
-            // console.log('state', state)
-
-            body[fieldKey] = state
-
-            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
-                  },
-                  excludeHooks: [],
-                  queryOptions: { withDeleted: true, withCrdt: true }
-                }
-              )
-              .catch((e) => {
-                console.log('crdt on store error', { body })
-              })
-          }
-        })
-      ],
-      onAuthenticate: async (data) => {
-        try {
-          return await onAuthenticate?.(this.api, data)
-        } catch (err) {
-          throw new Error('Ошибка авторизации: ' + err)
-        }
-      },
-      onLoadDocument: async (data) => {
-        const { documentName } = data
-
-        const [prefix] = documentName.split('.')
-        if (prefix === this.documentPrefix) {
-          const { entityAlias, id } = this.parseDocumentName(documentName)
-
-          if (entityAlias) {
-            const augmentation = this.api.options.augmentations?.[entityAlias]
-
-            if (augmentation?.onLoadDocument) {
-              await augmentation.onLoadDocument(data)
-            }
-          }
-        }
-
-        return onLoadDocument?.(this.api, data)
-      },
-      afterLoadDocument: async (data) => {
-        const { documentName, document, instance } = data
-
-        return afterLoadDocument?.(this.api, data)
-      },
-      connected: async (data) => {
-        const { documentName, instance } = data
-
-        const [prefix] = documentName?.split('.')
-        if (prefix === this.documentPrefix) {
-          const document = instance.documents.get(documentName)
-
-          const { entityAlias, id } = this.parseDocumentName(documentName)
-
-          if (entityAlias && document) {
-            const entityMap = document.getMap(entityAlias)
-            const id = entityMap.get('id')
-
-            if (id === undefined) {
-              document.connections.forEach(({ connection }) => {
-                connection.close({
-                  reason: 'Document not loaded',
-                  code: 500
-                })
-              })
-              instance.unloadDocument(document)
-            }
-          }
-        }
-
-        return connected?.(this.api, data)
-      },
-      onChange: async (data) => {
-        const { documentName } = data
-
-        const [prefix] = documentName.split('.')
-        if (prefix === this.documentPrefix) {
-          const { entityAlias, id } = this.parseDocumentName(documentName)
-
-          if (entityAlias) {
-            const augmentation = this.api.options.augmentations?.[entityAlias]
-
-            if (augmentation?.onChangeDocument) {
-              await augmentation.onChangeDocument(data)
-            }
-          }
-        }
-
-        return onChange?.(this.api, data)
-      },
-      onStoreDocument: async (data) => {
-        const { documentName } = data
-
-        const [prefix] = documentName.split('.')
-        if (prefix === this.documentPrefix) {
-          const { entityAlias, id } = this.parseDocumentName(documentName)
-
-          if (entityAlias) {
-            const augmentation = this.api.options.augmentations?.[entityAlias]
-
-            if (augmentation?.onStoreDocument) {
-              await augmentation.onStoreDocument(data)
-            }
-          }
-        }
-
-        return onStoreDocument?.(this.api, data)
-      },
-
-      ...config
-    })
-  }
-
-  public async listen() {
-    await this.server.listen()
-  }
-
-  private parseDocumentName(documentName: string) {
-    const parts = documentName.split('.')
-
-    const [prefix, entityAlias, idRaw] = parts
-
-    if (prefix !== this.documentPrefix) {
-      throw new Error(`Invalid prefix: "${prefix}", expected "${this.documentPrefix}"`)
-    }
-
-    if (!entityAlias) {
-      throw new Error(`Missing entity alias in documentName: "${documentName}"`)
-    }
-
-    const id = Number(idRaw)
-    if (Number.isNaN(id)) {
-      throw new Error(`Invalid id in documentName: "${documentName}"`)
-    }
-
-    return { entityAlias: entityAlias as Extract<keyof T, string>, id }
-  }
-
-  public createDocumentName(entityAlias: string, id: number | string, prefix?: string) {
-    const parts = [prefix || this.documentPrefix, entityAlias, id]
-
-    return parts.join('.')
-  }
-
-  public isCrdtSupported(entity: CuboEntity) {
-    const hasCrdtField = entity.fields.some((f) => f.alias === (this.api.options.crdt?.fieldAlias || this.defaultCrdtFieldAlias))
-
-    return hasCrdtField
-  }
-
-  public getCrdtField(entity: CuboEntity) {
-    const crdtField = entity.fields.find((f) => f.alias === (this.api.options.crdt?.fieldAlias || this.defaultCrdtFieldAlias))
-
-    return crdtField
-  }
-
-  public getDocumentByEntity(entityAlias: string, id: number, requestHeaders: IncomingHttpHeaders) {
-    const documentName = this.createDocumentName(entityAlias, id)
-    const fakeSocketId = 'api-' + crypto.randomUUID()
-
-    return this.server.hocuspocus.createDocument(documentName, { headers: requestHeaders, url: '/collaboration' }, fakeSocketId, {
-      readOnly: false,
-      isAuthenticated: false
-    })
-  }
-
-  public async openDirectConnection(entityAlias: string, id: number, context?: any) {
-    const documentName = this.createDocumentName(entityAlias, id)
-    if (!documentName) {
-      return
-    }
-
-    return this.server.hocuspocus.openDirectConnection(documentName, context)
-  }
-
-  public async connectionDisconnect(connection: CuboDirectConnection) {
-    const { document, instance, context } = connection
-
-    if (document) {
-      document.removeDirectConnection()
-
-      await instance.storeDocumentHooks(document, {
-        clientsCount: document.getConnectionsCount(),
-        context: context,
-        document: document,
-        documentName: document.name,
-        instance: instance,
-        requestHeaders: {},
-        requestParameters: new URLSearchParams(),
-        socketId: 'server'
-      })
-
-      // // If the direct connection was the only connection to the document
-      // // then we should trigger the onDisconnect hook for
-      // // this doc and unload the document
-      // if (document.getConnectionsCount() === 0) {
-      //   await instance.hooks('onDisconnect', {
-      //     instance: instance,
-      //     clientsCount: document.getConnectionsCount(),
-      //     context: context,
-      //     document: document,
-      //     socketId: 'server',
-      //     documentName: document.name,
-      //     requestHeaders: {},
-      //     requestParameters: new URLSearchParams()
-      //   })
-
-      //   await instance.unloadDocument(document)
-      // }
-
-      connection.document = null
-    }
-  }
-
-  public async updateDocument(params: { entityAlias: string; id: number; entity: CuboEntity }, dto: Record<string, any>, context?: any) {
-    const { entityAlias, id, entity } = params
-
-    const connection = await this.openDirectConnection(entityAlias, id, context)
-    if (!connection) {
-      return
-    }
-
-    const { document } = connection
-    if (!document) {
-      return
-    }
-
-    const entityMap = document.getMap(entityAlias)
-
-    const fieldKey = this.getCrdtField(entity)?.alias
-
-    document.transact(() => {
-      for (const [key, value] of Object.entries(dto)) {
-        if (key === fieldKey) {
-          continue
-        }
-
-        let preparedValue = value
-
-        if (value instanceof Date) {
-          preparedValue = value.toISOString()
-        }
-
-        entityMap.set(key, preparedValue)
-      }
-    })
-
-    return this.connectionDisconnect(connection)
-  }
-
-  public async createState(params: { entityAlias: string; id: number; entity: CuboEntity }, dto: Record<string, any>) {
-    const { entityAlias, id, entity } = params
-
-    const document = new Y.Doc()
-    if (!document) {
-      return
-    }
-
-    const entityMap = document.getMap(entityAlias)
-
-    const fieldKey = this.getCrdtField(entity)?.alias
-
-    document.transact(() => {
-      for (const [key, value] of Object.entries(dto)) {
-        if (key === fieldKey) {
-          continue
-        }
-
-        let preparedValue = value
-
-        if (value instanceof Date) {
-          preparedValue = value.toISOString()
-        }
-
-        entityMap.set(key, preparedValue)
-      }
-    })
-
-    return Buffer.from(Y.encodeStateAsUpdate(document))
-  }
-}

package/src/crdt/types.ts

@@ -1,34 +0,0 @@
-import { CuboApiEntitiesMap } from '@cuboapp/types'
-import {
-  DirectConnection as DirectConnectionInterface,
-  Document,
-  Hocuspocus,
-  ServerConfiguration,
-  afterLoadDocumentPayload,
-  connectedPayload,
-  onAuthenticatePayload,
-  onChangePayload,
-  onLoadDocumentPayload,
-  onStoreDocumentPayload
-} from '@hocuspocus/server'
-
-import { CuboBackendApi } from '..'
-
-export type CuboCrdtConfiguration<T extends CuboApiEntitiesMap<T>> = Omit<
-  Partial<ServerConfiguration>,
-  'onAuthenticate' | 'onLoadDocument' | 'onChange' | 'onStoreDocument' | 'afterLoadDocument' | 'connected'
-> & {
-  onAuthenticate?: (api: CuboBackendApi<T>, data: onAuthenticatePayload) => Promise<any>
-  onLoadDocument?: (api: CuboBackendApi<T>, data: onLoadDocumentPayload) => Promise<any>
-  onChange?: (api: CuboBackendApi<T>, data: onChangePayload) => Promise<any>
-  onStoreDocument?: (api: CuboBackendApi<T>, data: onStoreDocumentPayload) => Promise<any>
-  afterLoadDocument?: (api: CuboBackendApi<T>, data: afterLoadDocumentPayload) => Promise<any>
-  connected?: (api: CuboBackendApi<T>, data: connectedPayload) => Promise<any>
-  fieldAlias?: string
-}
-
-export type CuboDirectConnection = {
-  document: Document | null
-  instance: Hocuspocus
-  context: any
-} & DirectConnectionInterface