@cuboapp/api-backend 1.0.11 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/api-backend",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Backend Api for CuboApp",
   "main": "src/index.ts",
   "repository": "git@github.com:cuboapp/api-backend.git",
@@ -8,10 +8,14 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@cuboapp/constants": "2.0.4",
-    "@cuboapp/database": "1.0.1",
-    "@cuboapp/types": "2.0.5",
-    "@cuboapp/utils": "1.0.4"
+    "@cuboapp/constants": "^2.0.5",
+    "@cuboapp/database": "^1.0.1",
+    "@cuboapp/types": "^2.0.6",
+    "@cuboapp/utils": "1.0.4",
+    "@hocuspocus/extension-database": "^3.2.3",
+    "@hocuspocus/server": "^3.2.3",
+    "pg": "^8.16.3",
+    "yjs": "^13.6.27"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",

package/src/constants/index.ts

@@ -18,7 +18,8 @@ export const CUBO_CRUD_QUERY_CONDITION = {
   GT: 'gt',
   LT: 'lt',
   GTE: 'gte',
-  LTE: 'lte'
+  LTE: 'lte',
+  BTW: 'btw'
 }
 
 export const CUBO_CRUD_DEFAULT_FIELDS: Pick<CuboEntityField, 'type' | 'alias' | 'extra'>[] = [

package/src/crdt/index.ts

@@ -0,0 +1,418 @@
+import { QueryTypes } from '@cuboapp/database'
+import { CuboApiEntitiesMap, CuboEntity } from '@cuboapp/types'
+import { Database } from '@hocuspocus/extension-database'
+import {
+  beforeSyncPayload,
+  Document,
+  Hocuspocus,
+  onChangePayload,
+  onLoadDocumentPayload,
+  onStoreDocumentPayload,
+  Server
+} from '@hocuspocus/server'
+import { IncomingHttpHeaders } from 'http'
+import * as Y from 'yjs'
+
+import { CuboBackendApi } from '..'
+import { DirectConnection } from './types'
+
+export * from './types'
+
+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]
+              // console.log('raw', raw)
+
+              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 }
+              }
+            )
+          }
+        })
+      ],
+      onAuthenticate: async (data) => {
+        try {
+          return 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) {
+              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: DirectConnection) {
+    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))
+  }
+}
+
+export { beforeSyncPayload, DirectConnection, Document, Hocuspocus, onChangePayload, onLoadDocumentPayload, onStoreDocumentPayload }

package/src/crdt/types.ts

@@ -0,0 +1,34 @@
+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 DirectConnection = {
+  document: Document | null
+  instance: Hocuspocus
+  context: any
+} & DirectConnectionInterface

package/src/helpers/convert.ts

@@ -1,10 +1,10 @@
 import { CuboApiEntitiesMap, CuboEntity, CuboEntityField } from '@cuboapp/types'
 import { get, set, unset } from '@cuboapp/utils'
+import { CUBO_ENTITY_FIELD_TYPE } from '@cuboapp/constants'
 
 import { CUBO_CRUD_DEFAULT_FIELDS } from '../constants'
 import { CuboCrudFindQuery, CuboCrudRequest } from '../types'
 
-import { CUBO_ENTITY_FIELD_TYPE } from '@cuboapp/constants'
 import { ApiHelpers } from '.'
 
 export class ApiHelpersConvert<T extends CuboApiEntitiesMap<T>> {
@@ -98,6 +98,7 @@ export class ApiHelpersConvert<T extends CuboApiEntitiesMap<T>> {
         console.warn('field type "file" is not implemented yet')
         return undefined
       case CUBO_ENTITY_FIELD_TYPE.JSON:
+      case CUBO_ENTITY_FIELD_TYPE.BINARY:
         return value
       case CUBO_ENTITY_FIELD_TYPE.NUMBER:
         return ![undefined, null].includes(value) ? parseFloat(value) : null

package/src/helpers/data.ts

@@ -128,6 +128,7 @@ export class ApiHelpersData<T extends CuboApiEntitiesMap<T>> {
             errors.push(`"${key}": file field type is not already implemented`)
             break
           case CUBO_ENTITY_FIELD_TYPE.JSON:
+          case CUBO_ENTITY_FIELD_TYPE.BINARY:
             if (value === null) {
               prepared[key] = value
             } else if (Buffer.byteLength(JSON.stringify(value)) >= 65535 * 50) {

package/src/helpers/index.ts

@@ -1,8 +1,8 @@
 import { CUBO_ENTITY_FIELD_TYPE } from '@cuboapp/constants'
-import { Database, createDatabase, type Options } from '@cuboapp/database'
+import { Database, createDatabase } from '@cuboapp/database'
 import { CuboApiEntitiesMap, CuboEntity, CuboEntityField, CuboEntityFieldExtra, CuboEntityFieldType } from '@cuboapp/types'
 
-import { CuboBackendApi, CuboBackendApiDbConnectionType, CuboCrudFindQuery, CuboCrudRequest } from '../..'
+import { CuboBackendApi } from '../..'
 import {
   CUBO_CRUD_DEFAULT_FIELDS,
   CUBO_CRUD_DEFAULT_PAGE_LIMIT,
@@ -11,6 +11,7 @@ import {
   CUBO_CRUD_QUERY_KEY_REGEX,
   CUBO_CRUD_QUERY_SYMBOL_NOT
 } from '../constants'
+import { CuboBackendApiDbConnectionType, CuboCrudFindQuery, CuboCrudRequest } from '../types'
 
 import { ApiHelpersConvert } from './convert'
 import { ApiHelpersData } from './data'
@@ -65,7 +66,10 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
     // condition parts
     switch (parts.length) {
       case 3:
-        if (parts[0] !== CUBO_CRUD_QUERY_SYMBOL_NOT) {
+        if (parts[0] === 'btw') {
+          condition = parts[0]
+          value = `${parts[1]}:${parts[2]}`
+        } else if (parts[0] !== CUBO_CRUD_QUERY_SYMBOL_NOT) {
           throw new Error(`"${field.alias}": three-level value allow only "not" condition at first level (${value})`)
         } else if (!Object.values(CUBO_CRUD_QUERY_CONDITION).includes(parts[1])) {
           throw new Error(`"${field.alias}": incorrect condition "${parts[1]}" in second level (${value})`)
@@ -140,9 +144,18 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
             } else {
               if ([CUBO_CRUD_QUERY_CONDITION.IN, CUBO_CRUD_QUERY_CONDITION.NIN].includes(condition)) {
                 value = value.split(',').map(Number)
+              } else if (condition === CUBO_CRUD_QUERY_CONDITION.BTW) {
+                const [fromStr, toStr] = value.split(':')
+                const from = precision === 0 ? parseInt(fromStr) : parseFloat(fromStr)
+                const to = precision === 0 ? parseInt(toStr) : parseFloat(toStr)
+
+                if (isNaN(from) || isNaN(to)) {
+                  throw new Error(`"${field.alias}": both values for "btw" must be valid numbers`)
+                }
+
+                value = precision > 0 ? `${from.toFixed(precision)}:${to.toFixed(precision)}` : `${from}:${to}`
               } else {
                 const potentialValue = precision === 0 ? parseInt(value) : parseFloat(value)
-
                 if (isNaN(potentialValue)) {
                   throw new Error('"' + field.alias + '" must be number')
                 } else {
@@ -211,7 +224,7 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
   ): { conditions: string[]; replacements: Record<string, any> } {
     const conditions: string[] = []
     const replacements: Record<string, any> = {}
-
+    // console.log(field, condition, value)
     switch (condition) {
       case CUBO_CRUD_QUERY_CONDITION.ILIKE:
         conditions.push(`${field} ${is_not ? 'not ilike' : 'ilike'} :${replacement}`)
@@ -253,6 +266,22 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
         conditions.push(`${field} ${is_not ? '>=' : '<='} :${replacement}`)
         replacements[replacement] = value
         break
+      case CUBO_CRUD_QUERY_CONDITION.BTW: {
+        const [from, to] = String(value).split(':')
+        const fromKey = `${replacement}_from`
+        const toKey = `${replacement}_to`
+
+        if (!from || !to) {
+          throw new Error(`Invalid "btw" value: "${value}"`)
+        }
+
+        const expr = `${field} >= :${fromKey} AND ${field} <= :${toKey}`
+        conditions.push(is_not ? `NOT (${expr})` : `(${expr})`)
+
+        replacements[fromKey] = from
+        replacements[toKey] = to
+        break
+      }
       case CUBO_CRUD_QUERY_CONDITION.EQ:
       default:
         if (value === null) {
@@ -287,75 +316,13 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
     }
 
     this.connecting[type] = new Promise(async (success) => {
-      let database: string = ''
-      let host: string = ''
-      let port: number = 0
-      let username: string = ''
-      let password: string = ''
-      let schema: string = ''
-      let dialect: string = ''
-      let dialectModule: any = undefined
-
-      if (!this.api.options.db.options) {
-        throw 'DB connection is not configured'
-      }
-
-      const dbConfig = this.api.options.db.options
-
-      let cfg: Options = {}
-      if (dbConfig) {
-        if (dbConfig[type]) {
-          cfg = dbConfig[type]
-        } else {
-          cfg = dbConfig as Options
-        }
-      }
-
-      database = cfg.database as string
-      dialectModule = cfg.dialectModule
-      host = cfg.host as string
-      port = cfg.port as number
-      username = cfg.username as string
-      password = cfg.password as string
-      schema = cfg.schema as string
-      dialect = cfg.dialect as string
-
-      const config: Options = {
-        host,
-        port,
-        username,
-        password,
-        database,
-        dialect: dialect as any,
-        timezone: '+03:00',
-        logging: false,
-        schema
-      }
-
-      if (dialectModule) {
-        config.dialectModule = dialectModule
-      }
-
-      // cert for yandex cloud
-      if (/yandexcloud/.test(config.host!)) {
-        config.dialectOptions = {
-          ...(config.dialectOptions || {}),
-          ...{
-            ssl: {
-              ca: await fetch('https://storage.yandexcloud.net/cloud-certs/CA.pem').then((res) => res.text()),
-              rejectUnauthorized: true,
-              target_session_attrs: 'read-write',
-              require: true
-            }
-          }
-        }
-      }
+      const { iaas, pk_key, pk_type, ...config } = this.api.options.db.options
 
-      this.connections[type] = createDatabase(config)
+      this.connections[type] = createDatabase(config, JSON.parse(JSON.stringify({ iaas, pk_key, pk_type })))
       await this.connections[type].connect()
 
-      if (dialect === 'postgres') {
-        await this.connections[type].connection.query(`SET schema '${schema}';`)
+      if (config.dialect === 'postgres' && config.schema) {
+        await this.connections[type].connection.query(`SET schema '${config.schema}';`)
       }
 
       success(this.connections[type])

package/src/index.ts

@@ -1,56 +1,50 @@
-import { Database, Options, QueryTypes } from '@cuboapp/database'
-import { CuboApiEntitiesMap, CuboEntity } from '@cuboapp/types'
+import { QueryTypes } from '@cuboapp/database'
+import { CuboApiEntitiesMap } from '@cuboapp/types'
 
+import { CuboCrdt } from './crdt'
 import { ApiHelpers } from './helpers'
-import { CuboCrudAugmentationsStore, CuboCrudGetManyResponse, CuboCrudMethodOptions, CuboCrudRequest } from './types'
-
-export * from './types'
-
-export type CuboBackendApiOptions<T extends CuboApiEntitiesMap<T>> = {
-  api: {
-    base_url: string
-    token: string
-  }
-
-  db: {
-    connection?: Database
-    options?: Options
-  }
-
-  entities: CuboEntity[]
-
-  auth?: {
-    base_url?: string
-  }
-
-  augmentations?: Partial<CuboCrudAugmentationsStore<T>>
-}
+import { CuboBackendApiAuth, CuboBackendApiOptions, CuboCrudGetManyResponse, CuboCrudMethodOptions, CuboCrudRequest } from './types'
 
 export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
-  constructor(public options: CuboBackendApiOptions<T>) {}
+  constructor(public options: CuboBackendApiOptions<T>) {
+    if (options.crdt) {
+      this.crdt = new CuboCrdt<T>(this)
+      this.crdt.listen()
+    }
+  }
 
+  public auth: CuboBackendApiAuth
+  public crdt?: CuboCrdt<T>
   public helpers = new ApiHelpers<T>(this)
 
   async init() {
-    const auth = await this.authRequest('/me')
+    try {
+      this.auth = await this.request<{ variables: Record<string, any> }>('/auth/me?with=variables', {
+        headers: this.options.api?.headers || {}
+      })
 
-    if (!auth) {
-      throw { code: 403, text: 'Авторизация Cubo-Backend не пройдена' }
-    }
-  }
+      if (!this.auth) {
+        throw { code: 403, text: 'Авторизация Cubo-Backend не пройдена' }
+      }
 
-  async apiRequest<T>(url: string, opts?: RequestInit) {
-    return this.request<T>(`https://${this.options.api.base_url}`, url, opts)
-  }
+      if (this.auth.variables.db !== undefined) {
+        this.options.db = this.options.db || {}
 
-  async authRequest<T>(url: string, opts?: RequestInit) {
-    return this.request<T>(this.options?.auth?.base_url || 'https://auth.cubo.sh', url, opts)
+        this.options.db.options = {
+          ...(this.options.db.options || {}),
+          ...(this.auth.variables.db || {})
+        }
+      }
+    } catch (e) {
+      console.error('[API-BACKEND] startup error', e)
+    }
   }
 
-  private async request<T>(baseUrl: string, url: string, opts?: RequestInit & { withoutContentType?: boolean }) {
+  public async request<T>(url: string, opts?: RequestInit & { debug?: boolean; withoutContentType?: boolean }) {
+    const baseUrl = this.options?.api?.base_url || 'https://api.cubo.sh'
+
     const headers: Record<string, any> = {
-      ...(opts?.headers || {}),
-      Authorization: this.options.api.token || ''
+      ...(opts?.headers || {})
     }
 
     if (!headers['Content-Type'] && !opts?.withoutContentType) {
@@ -58,33 +52,57 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
       headers['Content-Type'] = 'application/json'
     }
 
-    const response = await fetch(baseUrl.replace(/\/$/, '') + '/' + url.replace(/^\//, ''), {
+    const requestUrl = baseUrl.replace(/\/$/, '') + '/' + url.replace(/^\//, '')
+    const requestOpts = {
       ...(opts || {}),
       headers
-    })
-
-    if ([201, 200].includes(response.status)) {
-      try {
-        const json = await response.json()
+    }
 
-        return json as Promise<T>
-      } catch (e) {
-        const text = await response.text()
+    try {
+      const response = await fetch(requestUrl, requestOpts)
 
+      if ([201, 200].includes(response.status)) {
         try {
-          const json = text ? JSON.parse(text) : null
+          const json = await response.json()
 
           return json as Promise<T>
-        } catch {
-          throw { status: 500, error: 'Invalid response', text }
+        } catch (e) {
+          const text = await response.text()
+
+          try {
+            const json = text ? JSON.parse(text) : null
+
+            return json as Promise<T>
+          } catch {
+            throw { status: 500, error: 'Invalid response', text }
+          }
+        }
+      } else {
+        throw {
+          status: response.status,
+          error: response.statusText,
+          text: await response.text()
         }
       }
-    } else {
-      throw {
-        status: response.status,
-        error: response.statusText,
-        text: await response.text()
+    } catch (e) {
+      if (opts?.debug) {
+        console.log(
+          '[API BACKEND]',
+          JSON.stringify(
+            {
+              request: {
+                url: requestUrl,
+                opts: requestOpts
+              },
+              error: e
+            },
+            null,
+            2
+          )
+        )
       }
+
+      throw e
     }
   }
 
@@ -222,14 +240,27 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
       throw { status: 400, text: 'Unable to create entity' }
     }
 
-    const response = await this.getOne<K>(entityAlias, { query: { id: created_id } }, opts)
+    let response = await this.getOne<K>(entityAlias, { query: { id: created_id } }, opts)
 
     if (!response) {
       throw { status: 400, text: 'Unable to find entity after create' }
     }
 
     if (augmentation?.afterCreate && !opts?.excludeHooks?.includes('afterCreate')) {
-      return augmentation.afterCreate(response, req, opts)
+      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)
+      }
     }
 
     return response
@@ -262,13 +293,22 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
     const db = await this.helpers.getConnection('write')
     await db.update(entity.alias, 'id = :id', { id: item.id }, dto, { transaction: opts?.transaction, log: opts?.log })
 
-    const response = await this.getOne<K>(entityAlias, req, opts)
+    let response = await this.getOne<K>(entityAlias, req, opts)
     if (!response) {
       throw { status: 400, text: 'Unable to find entity after update' }
     }
 
     if (augmentation?.afterUpdate && !opts?.excludeHooks?.includes('afterUpdate')) {
-      return augmentation.afterUpdate(response, req, opts)
+      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)
+      }
     }
 
     return response
@@ -308,4 +348,6 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
   }
 }
 
+export * from './crdt'
 export * from './helpers'
+export * from './types'

package/src/types/augmentation.ts

@@ -2,6 +2,7 @@ import { CuboApiEntitiesMap } from '@cuboapp/types'
 
 import { 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]>
@@ -20,10 +21,16 @@ export interface CuboCrudAugmentationInstance<T = unknown> {
 
   beforeCreate?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
   afterCreate?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<T>
+  afterCrdtCreate?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<void>
 
   beforeUpdate?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
   afterUpdate?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<T>
+  afterCrdtUpdate?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<void>
 
   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>
 }

package/src/types/db.ts

@@ -27,9 +27,13 @@ export type CuboCrudMethodOptions<E extends object = {}> = {
     | 'afterGetMany'
     | 'afterGetOne'
     | 'beforeUpdate'
+    | 'afterCrdtCreate'
+    | 'afterCrdtUpdate'
   )[]
 
   log?: boolean
+  replace?: boolean
+  crdt?: boolean
 
   queryOptions?: CuboCrudQueryOptions
 } & E

package/src/types/index.ts

@@ -1,3 +1,31 @@
+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>> = {
+  api: {
+    base_url?: string
+    headers: Partial<Record<`cubo-${CuboAuthTokenType}`, string>> & Record<string, any>
+  }
+
+  entities?: CuboEntity[]
+
+  db?: {
+    connection?: Database
+    options?: Options & DatabaseOptions
+  }
+
+  crdt?: CuboCrdtConfiguration<T>
+  augmentations?: Partial<CuboCrudAugmentationsStore<T>>
+}
+
+export type CuboBackendApiAuth = {
+  variables: Record<string, any>
+}

package/.vscode/settings.json

@@ -1,18 +0,0 @@
-{
-  "editor.minimap.enabled": false,
-  "editor.formatOnSave": true,
-  "editor.codeActionsOnSave": {
-    "source.fixAll.eslint": "explicit",
-    "source.fixAll.stylelint": "explicit",
-    "source.organizeImports": "explicit",
-    "source.organizeExports": "explicit"
-  },
-  "emmet.includeLanguages": {
-    "javascriptreact": "html",
-    "typescriptreact": "html"
-  },
-  "files.exclude": {
-    "node_modules/": true
-  },
-  "typescript.tsdk": "node_modules/typescript/lib"
-}

package/package-lock.json

@@ -1,104 +0,0 @@
-{
-  "name": "@cuboapp/api-backend",
-  "version": "1.0.10",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "@cuboapp/api-backend",
-      "version": "1.0.10",
-      "license": "MIT",
-      "dependencies": {
-        "@cuboapp/constants": "2.0.4",
-        "@cuboapp/database": "1.0.1",
-        "@cuboapp/types": "2.0.5",
-        "@cuboapp/utils": "1.0.4"
-      },
-      "devDependencies": {
-        "@types/node": "^24.10.1",
-        "typescript": "^5.9.3"
-      }
-    },
-    "../constants": {
-      "name": "@cuboapp/constants",
-      "version": "2.0.4",
-      "license": "MIT",
-      "dependencies": {
-        "@cuboapp/types": "2.0.5"
-      }
-    },
-    "../database": {
-      "name": "@cuboapp/database",
-      "version": "1.0.1",
-      "license": "MIT",
-      "dependencies": {
-        "sequelize": "^6.37.7"
-      },
-      "devDependencies": {
-        "@types/node": "^24.0.0",
-        "typescript": "^5.9.3"
-      }
-    },
-    "../types": {
-      "name": "@cuboapp/types",
-      "version": "2.0.5",
-      "license": "MIT"
-    },
-    "../utils": {
-      "name": "@cuboapp/utils",
-      "version": "1.0.4",
-      "license": "MIT",
-      "devDependencies": {
-        "@types/node": "^24.9.1",
-        "typescript": "^5.9.3"
-      }
-    },
-    "node_modules/@cuboapp/constants": {
-      "resolved": "../constants",
-      "link": true
-    },
-    "node_modules/@cuboapp/database": {
-      "resolved": "../database",
-      "link": true
-    },
-    "node_modules/@cuboapp/types": {
-      "resolved": "../types",
-      "link": true
-    },
-    "node_modules/@cuboapp/utils": {
-      "resolved": "../utils",
-      "link": true
-    },
-    "node_modules/@types/node": {
-      "version": "24.10.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.1.tgz",
-      "integrity": "sha512-GNWcUTRBgIRJD5zj+Tq0fKOJ5XZajIiBroOF0yvj2bSU1WvNdYS/dn9UxwsujGW4JX06dnHyjV2y9rRaybH0iQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "undici-types": "~7.16.0"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
-      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/undici-types": {
-      "version": "7.16.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
-      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
-      "dev": true,
-      "license": "MIT"
-    }
-  }
-}