@cuboapp/api-backend 1.0.25 → 1.0.26

package/src/old.ts

@@ -0,0 +1,744 @@
+import { CuboCrdtDocument, CuboCrdtServer, CuboCrdtSubescribe } from '@cuboapp/crdt'
+import { QueryTypes } from '@cuboapp/database'
+import { CuboApiEntitiesMap } from '@cuboapp/types'
+import { cloneDeep, pick } from '@cuboapp/utils'
+import { createWsServer, WsServer, WsServerSocket } from '@cuboapp/ws'
+
+import { CuboCrdtServerSubscribe } from '@cuboapp/crdt/src/server/types'
+import { ApiHelpers } from './helpers'
+import { CuboBackendApiAuth, CuboBackendApiOptions, CuboCrudGetManyResponse, CuboCrudMethodOptions, CuboCrudRequest } from './types'
+
+type CuboBackendWsServer<A> = { auth: A }
+
+type CuboBackendApiSubscribes<A, T> = Map<
+  string,
+  Map<WsServerSocket<{ auth: A }>, Map<string, CuboCrdtSubescribe<T> & { docs: Set<CuboCrdtDocument> }>>
+>
+
+export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown> {
+  public crdt?: CuboCrdtServer<T>
+  public ws?: WsServer<CuboBackendWsServer<A>>
+
+  public subscribes: CuboBackendApiSubscribes<A, T> = new Map()
+
+  constructor(public options: CuboBackendApiOptions<T, A>) {}
+
+  public auth: CuboBackendApiAuth
+  public helpers = new ApiHelpers<T, A>(this)
+
+  async init() {
+    try {
+      if (this.options.api !== undefined) {
+        this.auth = await this.request<{ variables: Record<string, any> }>('/auth/me?with=variables', {
+          withAuth: true
+        })
+
+        if (!this.auth) {
+          throw { code: 403, text: 'Авторизация Cubo-Backend не пройдена' }
+        }
+
+        if (this.auth.variables?.db !== undefined) {
+          this.options.db = this.options.db || {}
+
+          this.options.db.options = {
+            ...(this.options.db.options || {}),
+            ...(this.auth.variables?.db || {})
+          }
+        }
+      }
+
+      if (this.options.crdt !== undefined) {
+        this.ws = createWsServer<CuboBackendWsServer<A>>({
+          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,
+
+          onConnect: (client) => this.crdt.addClient(client),
+          onDisconnect: (client) => this.crdt.removeClient(client)
+        })
+
+        this.crdt = new CuboCrdtServer<T>({
+          debug: this.options.crdt.debug,
+          ws: this.ws,
+          entities: (this.options.entities?.map((e) => e.alias) || []) as any[],
+          fetchRows: async (client: WsServerSocket, sub: CuboCrdtServerSubscribe) => {
+            return this.getMany(
+              sub.entity as Extract<keyof T, string>,
+              { query: sub.filters },
+              { queryOptions: { extra: { auth: client.auth } } }
+            ).then((res) => res.rows)
+          }
+        })
+
+        const getSub = async (client: WsServerSocket<CuboBackendWsServer<A>>, dto: CuboCrdtSubescribe<T>, opts?: { create?: boolean }) => {
+          const subKey = `${dto.entity}`
+
+          let baseSub = this.subscribes.get(subKey)
+          if (!baseSub) {
+            if (opts?.create !== false) {
+              baseSub = this.subscribes.set(subKey, new Map()).get(subKey)
+            } else {
+              return { subKey }
+            }
+          }
+
+          let clientSub = baseSub.get(client)
+          if (!clientSub) {
+            if (opts?.create !== false) {
+              clientSub = baseSub.set(client, new Map()).get(client)
+            } else {
+              return { baseSub, subKey }
+            }
+          }
+
+          const sub = clientSub.get(dto.id)
+          if (!sub) {
+            if (opts?.create !== false) {
+              return {
+                sub: clientSub.set(dto.id, { ...dto, docs: new Set() }).get(dto.id),
+                clientSub,
+                baseSub,
+                subKey
+              }
+            } else {
+              return {
+                clientSub,
+                baseSub,
+                subKey
+              }
+            }
+          }
+
+          return { sub, clientSub, baseSub, subKey }
+        }
+
+        this.ws.registerHandler<{ subscribe_id: string; name: string; update: Uint8Array; origin?: any }>(
+          'crdt:update',
+          async ({ client, message }) => {
+            const { name, update, origin, subscribe_id } = message.data
+            // const { sub, subKey } = await getSub(client, message.data)
+
+            const doc = await this.crdt.getDocument(name, { autoCreate: false })
+            // console.log('[crdt:update] - received', message)
+
+            if (doc) {
+              doc.applyUpdate(
+                new Uint8Array(update),
+                JSON.parse(
+                  JSON.stringify({
+                    ...(origin || {}),
+                    subscribe_id
+                  })
+                )
+              )
+            }
+          }
+        )
+
+        const crdtSubscribe = async (
+          entity: T[Extract<keyof T, string>],
+          sub: CuboCrdtSubescribe<T> & {
+            docs: Set<CuboCrdtDocument>
+          },
+          client: WsServerSocket
+        ) => {
+          const entity_id = (entity as any).id
+
+          const doc = await this.crdt.getDocument(`${sub.entity}:${entity_id}`, { initialState: JSON.parse(JSON.stringify(entity)) })
+          doc.subscribe(sub.id, (data, origin) => {
+            const noStrategyResolved = !origin?.strategy || origin?.strategy === 'all'
+            const strategyExcludedResolved = (origin?.strategy === 'other' && origin.subscribe_id !== sub.id) || false
+
+            const row = doc.getMap().toJSON()
+
+            // console.log(
+            //   '[crdt:update] - push to client',
+            //   { subscribe_id: sub.id, origin, data: data.length },
+            //   { noStrategyResolved, strategyExcludedResolved }
+            // )
+
+            if (noStrategyResolved || strategyExcludedResolved) {
+              const isSutable = subFilterCheck(row, sub.filters || {})
+
+              let action = 'update'
+              if (!isSutable) {
+                action = !sub.docs?.has(doc) ? 'create' : 'delete'
+              }
+
+              client.send(
+                JSON.stringify({
+                  method: 'crdt:action:' + sub.id,
+                  data: {
+                    action,
+                    entity_id,
+                    entity: sub.entity,
+                    data: Array.from(data)
+                  }
+                })
+              )
+            }
+
+            if (origin?.with_save) {
+              const body = pick(doc.getMap().toJSON(), origin.keys || [])
+
+              if (Object.keys(body)) {
+                console.log('call updateOne', sub.entity, entity_id)
+                // todo: debounce update
+                this.updateOne(
+                  sub.entity,
+                  {
+                    query: { id: entity_id },
+                    body
+                  },
+                  { debounce: 300, log: false, extra: { auth: client.auth } }
+                ).catch((e) => {
+                  console.log(e)
+                })
+              }
+            }
+          })
+          sub.docs.add(doc)
+
+          return {
+            id: entity_id,
+            row: Array.from(doc.stateAsUpdate)
+          }
+        }
+
+        this.ws.registerHandler<CuboCrdtSubescribe<T>>('crdt:subscribe', async ({ client, message }) => {
+          const { sub, subKey } = await getSub(client, message.data)
+
+          if (!sub) {
+            throw 'Подписка не определена: "' + subKey + '"'
+          }
+
+          if (sub.entity_id) {
+            const entity = await this.getOne(
+              sub.entity,
+              { query: { ...(sub.filters || {}), id: sub.entity_id } },
+              { queryOptions: { extra: { auth: client.auth } } }
+            )
+
+            return crdtSubscribe(entity, sub, client)
+          } else {
+            const { rows } = await this.getMany(sub.entity, { query: sub.filters || {} }, { extra: { auth: client.auth } })
+
+            return Promise.all(rows.map((row) => crdtSubscribe(row, sub, client)))
+          }
+        })
+
+        this.ws.registerHandler<CuboCrdtSubescribe<T>>('crdt:unsubscribe', async ({ client, message }) => {
+          const { sub, clientSub } = await getSub(client, message.data)
+
+          if (sub) {
+            sub.docs?.forEach((doc) => doc?.unsubscribe(sub.id))
+
+            clientSub.delete(sub.id)
+          }
+
+          return true
+        })
+
+        const subFilterCheck = (row: object, filters?: object) => {
+          let sutable = true
+
+          if (Object.keys(filters || {}).length) {
+            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
+        }
+
+        await this.ws.start()
+
+        this.ws.httpServer.registerRoute('GET', '/clients', () => {
+          return {
+            documents: this.crdt.documents.size,
+            subescribes: Object.fromEntries(
+              Array.from(this.subscribes).map(([key, clients]) => {
+                return [
+                  key,
+                  {
+                    count: clients.size,
+                    clients: Object.fromEntries(
+                      Array.from(clients).map(([client, sub]) => {
+                        return [
+                          client.id,
+                          {
+                            auth: (client.auth as any)?.user?.name,
+                            subscribes: Object.fromEntries(Array.from(sub))
+                          }
+                        ]
+                      })
+                    )
+                  }
+                ]
+              })
+            ),
+            clients: this.ws.clients.size
+          }
+        })
+      }
+    } catch (e) {
+      console.error('[API-BACKEND] startup error', e)
+    }
+  }
+
+  async destroy() {
+    const read = await this.helpers.getConnection('read', false)
+    const write = await this.helpers.getConnection('write', false)
+
+    if (read) {
+      await read.disconnect()
+    }
+
+    if (write) {
+      await write.disconnect()
+    }
+  }
+
+  // private debouncers = new Map<string, { createOne: any; updateOne: any; deleteOne: any }>()
+  // private createDebouncers() {
+  //   this.options.entities.forEach((entity) => {
+  //     this.debouncers.set(entity.alias, {
+  //       createOne: (wait: number, req: any, opts?: any) => {
+  //         return debounce(this.createOne.bind(this, entity.alias, req, { ...(opts || {}), debounce: undefined }), wait)
+  //       },
+  //       updateOne: (wait: number, req: any, opts?: any) => {
+  //         return debounce(this.updateOne.bind(this, entity.alias, req, { ...(opts || {}), debounce: undefined }), wait)
+  //       },
+  //       deleteOne: (wait: number, req: any, opts?: any) => {
+  //         return debounce(this.deleteOne.bind(this, entity.alias, req, { ...(opts || {}), debounce: undefined }), wait)
+  //       }
+  //     })
+  //   })
+  // }
+
+  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'
+
+    const headers: Record<string, any> = {
+      ...(opts?.headers || {})
+    }
+
+    if (opts?.withAuth) {
+      Object.assign(headers, this.options.api?.headers || {})
+    }
+
+    if (!headers['Content-Type'] && !opts?.withoutContentType) {
+      headers['Accept'] = 'application/json'
+      headers['Content-Type'] = 'application/json'
+    }
+
+    const requestUrl = baseUrl.replace(/\/$/, '') + '/' + url.replace(/^\//, '')
+    const requestOpts = {
+      ...(opts || {}),
+      headers
+    }
+
+    try {
+      const response = await fetch(requestUrl, requestOpts)
+
+      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 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()
+        }
+      }
+    } catch (e) {
+      if (opts?.debug) {
+        console.log(
+          '[API BACKEND]',
+          JSON.stringify(
+            {
+              request: {
+                url: requestUrl,
+                opts: requestOpts
+              },
+              error: e
+            },
+            null,
+            2
+          )
+        )
+      }
+
+      throw e
+    }
+  }
+
+  private async getEntity(entityAlias: Extract<keyof T, string>) {
+    const entity = await this.helpers.getEntityByAlias(entityAlias)
+    if (!entity) {
+      throw new Error('Entity no found: "' + String(entityAlias) + '"')
+    }
+
+    return entity
+  }
+
+  private async crdtAfterEvent<K extends Extract<keyof T, string>>(
+    event: 'update',
+    entity: K,
+    newVal?: T[K],
+    oldVal?: T[K],
+    origin?: CuboCrudMethodOptions['crdt']
+  ) {
+    const entity_id = newVal ? (newVal as any).id : (oldVal as any)?.id
+
+    const doc = await this.crdt.getDocument(`${entity}:${entity_id}`, { autoCreate: false })
+
+    if (doc) {
+      switch (event) {
+        case 'update':
+          {
+            const diff = Object.fromEntries(
+              Object.entries(newVal)
+                .map(([key, value]) => {
+                  if (value !== oldVal[key]) {
+                    return [key, value]
+                  }
+
+                  return undefined
+                })
+                .filter((i) => !!i)
+            )
+            // console.log('call crdtAfterEvent', { entity, diff })
+
+            if (Object.keys(diff).length) {
+              doc.writeMap(diff, origin)
+            }
+          }
+          break
+      }
+    }
+  }
+
+  async getMany<K extends Extract<keyof T, string> = Extract<keyof T, string>>(
+    entityAlias: K,
+    req?: CuboCrudRequest,
+    opts?: CuboCrudMethodOptions
+  ): Promise<CuboCrudGetManyResponse<T[K]>> {
+    opts = opts || {}
+    req = req || {}
+    const entity = await this.getEntity(entityAlias)
+    const augmentation = this.options?.augmentations?.[entityAlias]
+
+    if (augmentation?.beforeGetMany) {
+      opts.queryOptions = await augmentation.beforeGetMany(req, opts)
+    }
+
+    // get all joins
+    const queryDto = await this.helpers.withes.prepare(req, entity, opts)
+    queryDto.withDeleted = opts.queryOptions?.withDeleted
+    // queryDto.withCrdt = opts.queryOptions?.withCrdt
+
+    // create find query
+    const regularQuery = await this.helpers.createFindQuery(req, entity, queryDto)
+    const countQuery = await this.helpers.createFindQuery(req, entity, queryDto, true)
+
+    const db = await this.helpers.getConnection('write')
+
+    if (opts?.log) {
+      console.log(`QUERY:getMany to "${String(entityAlias)}":`, regularQuery.sql, regularQuery.replacements, { req, opts, queryDto })
+    }
+
+    const rows = await db.connection.query<any>(regularQuery.sql!, {
+      type: QueryTypes.SELECT,
+      replacements: regularQuery.replacements,
+      transaction: opts?.transaction
+    })
+    const [totals] = await db.connection.query<any>(countQuery.sql!, {
+      type: QueryTypes.SELECT,
+      replacements: countQuery.replacements,
+      transaction: opts?.transaction
+    })
+
+    const response = {
+      rows: await this.helpers.convert.prepareAll(req, entity, rows, regularQuery),
+      totals: {
+        count: totals.total !== undefined ? +totals.total : 0
+      }
+    }
+
+    if (augmentation?.afterGetMany && !opts?.excludeHooks?.includes('afterGetMany')) {
+      return augmentation.afterGetMany(response, req, opts)
+    }
+
+    return response
+  }
+
+  async getOne<K extends Extract<keyof T, string> = Extract<keyof T, string>>(
+    entityAlias: K,
+    req: CuboCrudRequest,
+    opts?: CuboCrudMethodOptions
+  ): Promise<T[K] | undefined> {
+    opts = opts || {}
+
+    const entity = await this.getEntity(entityAlias)
+    const augmentation = this.options?.augmentations?.[entityAlias]
+    if (augmentation?.beforeGetOne) {
+      opts.queryOptions = await augmentation.beforeGetOne(req, opts)
+    }
+
+    // get all joins
+    const queryDto = await this.helpers.withes.prepare(req, entity, opts)
+    queryDto.withDeleted = opts.queryOptions?.withDeleted
+    queryDto.withCrdt = opts.queryOptions?.withCrdt
+    queryDto.limit = 1
+
+    const query = await this.helpers.createFindQuery(req, entity, queryDto)
+
+    const db = await this.helpers.getConnection('read')
+
+    const [row] = await db.connection.query<any>(query.sql!, {
+      type: QueryTypes.SELECT,
+      replacements: query.replacements,
+      transaction: opts?.transaction
+    })
+
+    if (opts?.log) {
+      console.log(`QUERY:getOne to "${String(entityAlias)}":`, query.sql, query.replacements)
+    }
+
+    if (!row) {
+      return null as any
+      // throw { status: 404, message: 'Element "' + entityAlias + '" not found', details: req }
+    }
+
+    const response = await this.helpers.convert.prepareOne(req, entity, row, query)
+
+    if (augmentation?.afterGetOne && !opts?.excludeHooks?.includes('afterGetOne')) {
+      return augmentation.afterGetOne(response, req, opts)
+    }
+
+    return response
+  }
+
+  async createOne<K extends Extract<keyof T, string> = Extract<keyof T, string>>(
+    entityAlias: K,
+    req: CuboCrudRequest,
+    opts?: CuboCrudMethodOptions
+  ): Promise<T[K]> {
+    opts = opts || {}
+    const entity = await this.helpers.getEntityByAlias(entityAlias)
+    const augmentation = this.options?.augmentations?.[entityAlias]
+
+    if (augmentation?.beforeCreate) {
+      opts.queryOptions = await augmentation.beforeCreate(req, opts)
+    }
+
+    const dto = await this.helpers.data.prepare('create', entity!.fields, req.body, opts?.performer_id || 0)
+    if (!Object.keys(dto)) {
+      throw { status: 400, text: 'No keys to update' }
+    }
+
+    // const prepared = dbPrepareInsertQueryString(dto)
+    const db = await this.helpers.getConnection('write')
+    const [created_id] = await db.create(entity.alias, dto, { transaction: opts?.transaction, log: opts?.log })
+
+    if (!created_id) {
+      throw { status: 400, text: 'Unable to create entity' }
+    }
+
+    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')) {
+      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}` })
+    }
+
+    return response
+  }
+
+  async updateOne<K extends Extract<keyof T, string> = Extract<keyof T, string>>(
+    entityAlias: K,
+    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]
+
+    if (req.query?.crdt_exclude) {
+      opts = opts || {}
+      opts.crdt = {
+        exclude: req.query.crdt_exclude
+      }
+
+      delete req.query.crdt_exclude
+    }
+
+    if (augmentation?.beforeUpdate && !opts?.excludeHooks?.includes('beforeUpdate')) {
+      opts.queryOptions = await augmentation.beforeUpdate(req, opts)
+    }
+
+    const item: any = await this.getOne(entityAlias, req, opts)
+
+    if (!item) {
+      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 })
+      }
+    } 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' }
+    }
+
+    const db = await this.helpers.getConnection('write')
+    await db.update(entity.alias, 'id = :id', { id: item.id }, dto, { transaction: opts?.transaction, log: opts?.log })
+
+    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')) {
+      response = await augmentation.afterUpdate(response, req, opts)
+    }
+
+    if (this.crdt && opts?.crdt !== undefined) {
+      // console.log('on update crdt', entity.alias, opts?.crdt)
+      await this.crdtAfterEvent('update', entityAlias, response, initialEntity, opts.crdt)
+    }
+
+    return response
+  }
+
+  async deleteOne<K extends Extract<keyof T, string>>(
+    entityAlias: K,
+    req: CuboCrudRequest,
+    opts?: CuboCrudMethodOptions
+  ): Promise<boolean> {
+    opts = opts || {}
+    const entity = await this.helpers.getEntityByAlias(entityAlias)
+    const augmentation = this.options?.augmentations?.[entityAlias]
+
+    if (augmentation?.beforeDelete) {
+      opts.queryOptions = await augmentation.beforeDelete(req, opts)
+    }
+
+    const item: any = await this.getOne(entityAlias, req, opts)
+    if (!item) {
+      throw { status: 404, text: 'Entity not found' }
+    }
+
+    const dto = await this.helpers.data.prepare('delete', entity!.fields, req.body || {}, opts?.performer_id)
+    if (!Object.keys(dto)) {
+      throw { status: 400, text: 'No keys to update' }
+    }
+
+    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.crdt) {
+      // this.crdt.ee.emit(CUBO_CRDT_EVENT.DOCUMENT_DELETED, { name: `${entityAlias}:${item.id}` })
+    }
+
+    return true
+  }
+}
+
+export * from './helpers'
+export * from './types'