@cuboapp/api-backend 1.0.9 → 1.0.12

package/src/index.ts

@@ -1,57 +1,49 @@
-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 * from './utils'
-
-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')
 
-    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 || ''
+      ...(this.options.api?.headers || {})
     }
 
     if (!headers['Content-Type'] && !opts?.withoutContentType) {
@@ -59,33 +51,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
     }
   }
 
@@ -223,14 +239,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
@@ -263,13 +292,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
@@ -309,4 +347,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"
-}