@cuboapp/api-backend 1.0.0

package/src/helpers/data.ts

@@ -0,0 +1,147 @@
+import keyBy from 'lodash-es/keyBy'
+
+import { CUBO_ENTITY_FIELD_TYPE } from '../../constants'
+import { CuboEntitiesMap, CuboEntityFieldModel } from '../../types'
+import { isDateValid } from '../../utils'
+
+import { ApiHelpers } from '.'
+
+export class ApiHelpersData<T extends CuboEntitiesMap<T>> {
+  constructor(private helpers: ApiHelpers<T>) {}
+
+  public prepare(type: 'create' | 'update' | 'delete', fields: CuboEntityFieldModel[], dto?: any, performer_id?: number) {
+    const fieldsByAlias = keyBy(fields, (i) => i.alias)
+
+    const errors: string[] = []
+    const prepared: any = {}
+
+    switch (type) {
+      case 'create':
+        prepared.created_at = dto.created_at !== undefined ? dto.created_at : new Date().toISOString()
+        prepared.created_by = dto.created_by !== undefined ? dto.created_by : performer_id
+        break
+      case 'update':
+        prepared.modified_at = dto.modified_at !== undefined ? dto.modified_at : new Date().toISOString()
+        prepared.modified_by = dto.modified_by !== undefined ? dto.modified_by : performer_id
+
+        if (dto?.deleted_at !== undefined) {
+          prepared.deleted_at = dto.deleted_at
+        }
+        if (dto?.deleted_by !== undefined) {
+          prepared.deleted_by = dto.deleted_by
+        }
+        break
+      case 'delete':
+        prepared.deleted_at = dto?.deleted_at !== undefined ? dto.deleted_at : new Date().toISOString()
+        prepared.deleted_by = dto?.deleted_by !== undefined ? dto.deleted_by : performer_id
+        break
+    }
+
+    for (const key in dto || {}) {
+      if (!fieldsByAlias[key]) {
+        errors.push(`"${key}": unknown field`)
+      } else {
+        const value = dto[key]
+        const tval = typeof value
+
+        switch (fieldsByAlias[key].type_id) {
+          case CUBO_ENTITY_FIELD_TYPE.TEXT:
+            {
+              if (value === null) {
+                prepared[key] = value
+              } else if (tval !== 'string') {
+                errors.push(`"${key}": type of value must be string`)
+              } else if (tval.length > 2048) {
+                errors.push(`"${key}": max length of char field is ${2048}`)
+              } else {
+                prepared[key] = value
+              }
+            }
+            break
+          case CUBO_ENTITY_FIELD_TYPE.NUMBER:
+            {
+              if (value === null) {
+                prepared[key] = value
+              } else if (tval !== 'number') {
+                errors.push(`"${key}": type of value must be number`)
+              } else {
+                prepared[key] = value
+              }
+            }
+            break
+          case CUBO_ENTITY_FIELD_TYPE.TEXTAREA:
+            {
+              if (value === null) {
+                prepared[key] = value
+              } else if (tval !== 'string') {
+                errors.push(`"${key}": type of value must be string`)
+              } else if (value.length > 65535 * 10) {
+                errors.push(`"${key}": max length of text field is ${65535 * 10}`)
+              } else {
+                prepared[key] = value
+              }
+            }
+            break
+          case CUBO_ENTITY_FIELD_TYPE.BOOLEAN:
+            {
+              if (value === null) {
+                prepared[key] = value
+              } else if (tval !== 'boolean') {
+                errors.push(`"${key}": type of value must be boolean`)
+              } else {
+                prepared[key] = value
+              }
+            }
+            break
+          case CUBO_ENTITY_FIELD_TYPE.SELECT:
+            {
+              if (value === null) {
+                prepared[key] = value
+              } else if (tval !== 'number') {
+                errors.push(`"${key}": type of value must be number`)
+              } else {
+                prepared[key] = value
+              }
+              // errors.push(`"${key}": select field type is not already implemented`)
+            }
+            break
+          case CUBO_ENTITY_FIELD_TYPE.DATE:
+            {
+              if (value === null) {
+                prepared[key] = value
+              } else if (tval !== 'string' || !isDateValid(value)) {
+                errors.push(`"${key}": value must be a valid date string in format YYYY-MM-DD`)
+              } else {
+                prepared[key] = value
+              }
+            }
+            break
+          case CUBO_ENTITY_FIELD_TYPE.TIMESTAMP: {
+            if (value === null) {
+              prepared[key] = value
+            } else if (tval !== 'string' || !(new Date(value).getTime() > 0)) {
+              errors.push(`"${key}": value must be a valid date string in format YYYY-MM-DD HH:mm:ss`)
+            } else {
+              prepared[key] = value
+            }
+            break
+          }
+          case CUBO_ENTITY_FIELD_TYPE.FILE:
+            errors.push(`"${key}": file field type is not already implemented`)
+            break
+          case CUBO_ENTITY_FIELD_TYPE.JSON:
+            if (value === null) {
+              prepared[key] = value
+            } else if (Buffer.byteLength(JSON.stringify(value)) >= 65535 * 50) {
+              errors.push(`"${key}": max size of json field id ${65535 * 50} bytes`)
+            } else {
+              prepared[key] = value
+            }
+            break
+        }
+      }
+    }
+
+    return prepared
+  }
+}

package/src/helpers/entities.ts

@@ -0,0 +1,30 @@
+import { CuboEntitiesMap, CuboEntityModel } from '../../types'
+
+import { ApiHelpers } from '.'
+
+export class ApiHelpersEntities<T extends CuboEntitiesMap<T>> {
+  constructor(private helpers: ApiHelpers<T>) {}
+
+  public async getMany(force = false): Promise<CuboEntityModel[]> {
+    return (
+      this.helpers?.api?.options?.entities ??
+      this.helpers.getCached(
+        `get_entities`,
+        () => this.helpers.api.apiRequest<{ items: CuboEntityModel[] }>(`/api/v1/entities?with=fields`).then((res) => res.items),
+        force
+      )
+    )
+  }
+
+  public async getByAlias(alias: keyof T): Promise<CuboEntityModel | undefined> {
+    const entities = await this.getMany()
+
+    return entities.find((e) => e.alias === alias)
+  }
+
+  public async getById(id: number): Promise<CuboEntityModel | undefined> {
+    const entities = await this.getMany()
+
+    return entities.find((e) => e.id === id)
+  }
+}

package/src/helpers/index.ts

@@ -0,0 +1,381 @@
+import { CuboConfigDatabase } from '@cuboapp/config'
+import { Sequelize, type Options } from 'sequelize'
+
+import { CuboBackendApi } from '../..'
+import { CUBO_CRUD_QUERY_CONDITION, CUBO_CRUD_QUERY_SYMBOL_NOT, CUBO_ENTITY_FIELD_TYPE } from '../../constants'
+import { CuboEntitiesMap, CuboEntityFieldModel, CuboEntityFieldModelExtra } from '../../types'
+
+import { ApiHelpersConvert } from './convert'
+import { ApiHelpersData } from './data'
+import { ApiHelpersEntities } from './entities'
+import { ApiHelpersQuery } from './query'
+import { ApiHelpersUsers } from './users'
+import { ApiHelpersWithes } from './withes'
+
+export class ApiHelpers<T extends CuboEntitiesMap<T>> {
+  constructor(public api: CuboBackendApi<T>) {}
+
+  public withes = new ApiHelpersWithes<T>(this)
+  public query = new ApiHelpersQuery<T>(this)
+  public convert = new ApiHelpersConvert<T>(this)
+  public users = new ApiHelpersUsers<T>(this)
+  public entities = new ApiHelpersEntities<T>(this)
+  public data = new ApiHelpersData<T>(this)
+
+  private cache: Record<string, any> = {}
+  private fetching: Record<string, Promise<any> | null> = {}
+  private connections: Record<string, Sequelize> = {}
+  private connecting: Record<string, Promise<Sequelize>> = {}
+
+  public getCached(alias: string, cb: (force: boolean) => Promise<any>, force = false) {
+    if (!force && this.cache[alias] !== undefined) return this.cache[alias]
+
+    if (this.fetching[alias]) {
+      return this.fetching[alias]
+    }
+
+    this.fetching[alias] = new Promise(async (resolve, reject) => {
+      try {
+        this.cache[alias] = await cb(force)
+
+        resolve(this.cache[alias])
+      } catch (e: any) {
+        reject(e)
+      } finally {
+        delete this.fetching[alias]
+      }
+    })
+
+    return this.fetching[alias]
+  }
+
+  public clearFieldConditionValue(
+    field: CuboEntityFieldModel | { type_id: number; alias: string; extra: CuboEntityFieldModelExtra },
+    value: any
+  ) {
+    const type = typeof value
+
+    const parts = `${value}`.split(':')
+
+    let is_not = false
+    let condition = 'eq'
+
+    // condition parts
+    switch (parts.length) {
+      case 3:
+        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})`)
+        } else {
+          is_not = true
+          condition = parts[1]
+          value = parts[2]
+        }
+        break
+      case 2:
+        if (parts[0] === CUBO_CRUD_QUERY_SYMBOL_NOT) {
+          is_not = true
+          value = parts[1]
+        } else if (Object.values(CUBO_CRUD_QUERY_CONDITION).includes(parts[0])) {
+          condition = parts[0]
+          value = parts[1]
+        } else {
+          throw new Error(`"${field.alias}": incorrect condition "${parts[0]}" in second level (${value})`)
+        }
+        break
+      case 1:
+        break
+      default:
+        throw new Error(`"${field.alias}": incorrect condition value "${value}"`)
+    }
+
+    switch (field.type_id) {
+      case CUBO_ENTITY_FIELD_TYPE.TEXT:
+      case CUBO_ENTITY_FIELD_TYPE.TEXTAREA:
+        switch (type) {
+          case 'object':
+            if (value !== null) {
+              throw new Error('"' + field.alias + '" must be string')
+            }
+            break
+          case 'string':
+            if (value === 'null') {
+              value = null
+            }
+            break
+          case 'number':
+            value = `${value}`
+            break
+          default:
+            throw new Error('"' + field.alias + '" must be string')
+        }
+        break
+      case CUBO_ENTITY_FIELD_TYPE.SELECT:
+        if (value === 'null') {
+          value = null
+        } else {
+          if ([CUBO_CRUD_QUERY_CONDITION.IN, CUBO_CRUD_QUERY_CONDITION.NIN].includes(condition)) {
+            value = value.split(',')
+          }
+        }
+        break
+      case CUBO_ENTITY_FIELD_TYPE.NUMBER:
+        const precision = field.extra?.number_precision || 0
+
+        switch (type) {
+          case 'object':
+            if (value !== null) {
+              throw new Error('"' + field.alias + '" must be string')
+            }
+            break
+          case 'string':
+            if (value === 'null') {
+              value = null
+            } else {
+              if ([CUBO_CRUD_QUERY_CONDITION.IN, CUBO_CRUD_QUERY_CONDITION.NIN].includes(condition)) {
+                value = value.split(',')
+              } else {
+                const potentialValue = precision === 0 ? parseInt(value) : parseFloat(value)
+
+                if (isNaN(potentialValue)) {
+                  throw new Error('"' + field.alias + '" must be number')
+                } else {
+                  if (precision > 0) {
+                    value = parseFloat(potentialValue.toFixed(precision))
+                  } else {
+                    value = potentialValue
+                  }
+                }
+              }
+            }
+            break
+          case 'number':
+            if (precision > 0) {
+              value = parseFloat(parseFloat(value).toFixed(precision))
+            } else {
+              value = parseInt(value)
+            }
+            break
+          default:
+            throw new Error('"' + field.alias + '" must be number')
+        }
+        break
+      case CUBO_ENTITY_FIELD_TYPE.BOOLEAN:
+        switch (type) {
+          case 'object':
+            if (value !== null) {
+              throw new Error('"' + field.alias + '" must be string')
+            }
+            break
+          case 'string':
+            if (value === 'null') {
+              value = null
+            } else if (!['true', 'false'].includes(value)) {
+              throw new Error('"' + field.alias + '" must be true or false')
+            }
+            break
+          case 'number':
+            if (![0, 1].includes(value)) {
+              throw new Error('"' + field.alias + '" must be true or false')
+            }
+            break
+          case 'boolean':
+            break
+          default:
+            throw new Error('"' + field.alias + '" must be true or false')
+        }
+        break
+      default:
+        break
+    }
+
+    return {
+      value,
+      is_not,
+      condition
+    }
+  }
+
+  public prepareConditionSql(
+    field: string,
+    replacement: string,
+    value: any,
+    condition: string,
+    is_not: boolean
+  ): { conditions: string[]; replacements: Record<string, any> } {
+    const conditions: string[] = []
+    const replacements: Record<string, any> = {}
+
+    switch (condition) {
+      case CUBO_CRUD_QUERY_CONDITION.ILIKE:
+        conditions.push(`${field} ${is_not ? 'not ilike' : 'ilike'} :${replacement}`)
+        replacements[replacement] = '%' + value + '%'
+        break
+      case CUBO_CRUD_QUERY_CONDITION.LIKE:
+        conditions.push(`${field} ${is_not ? 'not like' : 'like'} :${replacement}`)
+        replacements[replacement] = '%' + value + '%'
+        break
+      case CUBO_CRUD_QUERY_CONDITION.EX:
+        conditions.push(`${is_not ? 'not exists' : 'exists'} ${field}`)
+        replacements[replacement] = value
+        break
+      case CUBO_CRUD_QUERY_CONDITION.IN:
+        if (Array.isArray(value)) {
+          conditions.push(`${field} ${is_not ? 'not in' : 'in'} (:${replacement})`)
+          replacements[replacement] = value
+        }
+        break
+      case CUBO_CRUD_QUERY_CONDITION.NIN:
+        if (Array.isArray(value)) {
+          conditions.push(`${field} ${is_not ? 'in' : 'not in'} (:${replacement})`)
+          replacements[replacement] = value
+        }
+        break
+      case CUBO_CRUD_QUERY_CONDITION.GT:
+        conditions.push(`${field} ${is_not ? '<' : '>'} :${replacement}`)
+        replacements[replacement] = value
+        break
+      case CUBO_CRUD_QUERY_CONDITION.GTE:
+        conditions.push(`${field} ${is_not ? '<=' : '>='} :${replacement}`)
+        replacements[replacement] = value
+        break
+      case CUBO_CRUD_QUERY_CONDITION.LT:
+        conditions.push(`${field} ${is_not ? '>' : '<'} :${replacement}`)
+        replacements[replacement] = value
+        break
+      case CUBO_CRUD_QUERY_CONDITION.LTE:
+        conditions.push(`${field} ${is_not ? '>=' : '<='} :${replacement}`)
+        replacements[replacement] = value
+        break
+      case CUBO_CRUD_QUERY_CONDITION.EQ:
+      default:
+        if (value === null) {
+          conditions.push(`${field} ${is_not ? 'is not' : 'is'} null`)
+        } else {
+          conditions.push(`${field} ${is_not ? '!=' : '='} :${replacement}`)
+        }
+        replacements[replacement] = value
+        break
+    }
+
+    return {
+      conditions,
+      replacements
+    }
+  }
+
+  public async dropConnection(account_id: number) {
+    if (this.connections[account_id]) {
+      await this.connections[account_id].close()
+      delete this.connections[account_id]
+    }
+  }
+
+  public async getConnection(type: 'read' | 'write') {
+    const cacheKey = `${type}_${this.api.account.id}`
+
+    if (this.connections[cacheKey]) {
+      return this.connections[cacheKey]
+    }
+
+    if (this.connecting[cacheKey] !== undefined) {
+      return this.connecting[cacheKey]
+    }
+
+    this.connecting[cacheKey] = new Promise(async (success) => {
+      const { storage } = this.api.account
+
+      let database: string = ''
+      let host: string = ''
+      let port: number = 0
+      let username: string = ''
+      let password: string = ''
+      let schema: string = ''
+      let dialect: string = ''
+
+      if (storage?.database) {
+        database = storage?.database
+        host = storage?.[type]?.host
+        port = storage?.[type]?.port
+        username = storage?.[type]?.username
+        password = storage?.[type]?.password
+        schema = storage?.[type]?.schema
+      } else {
+        if (!this.api.config.db) {
+          throw 'DB connection is not configured'
+        }
+
+        const dbConfig = this.api.config.db as any
+        let cfg: CuboConfigDatabase = {} as any
+        if (dbConfig) {
+          if (dbConfig[type]) {
+            cfg = dbConfig[type]
+          } else {
+            cfg = dbConfig as CuboConfigDatabase
+          }
+        }
+
+        database = cfg.database as string
+        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
+      }
+
+      if (!schema) {
+        schema = `account_${this.api.account.id}`
+      }
+
+      const config: Options = {
+        host,
+        port,
+        username,
+        password,
+        database,
+        dialect: dialect as any,
+        timezone: '+03:00',
+        logging: false,
+        schema
+      }
+
+      // 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 db = new Sequelize(config)
+
+      this.connections[cacheKey] = db
+      await db.authenticate()
+
+      if (dialect === 'postgres') {
+        await db.query(`SET schema '${schema}';`)
+      }
+
+      success(db)
+
+      delete this.connecting[cacheKey]
+    })
+
+    return this.connecting[cacheKey]
+  }
+
+  public async transaction(type: 'read' | 'write') {
+    const db = await this.getConnection(type)
+
+    return db.transaction()
+  }
+}

package/src/helpers/query.ts

@@ -0,0 +1,145 @@
+import { CUBO_CRUD_DEFAULT_FIELDS, CUBO_CRUD_DEFAULT_PAGE_LIMIT, CUBO_CRUD_MAX_PAGE_LIMIT, CUBO_CRUD_QUERY_KEY_REGEX } from '../../constants'
+import { CuboCrudFindQuery, CuboCrudRequest, CuboEntitiesMap, CuboEntityModel } from '../../types'
+import { dbPrepareUpdateQueryString } from '../../utils'
+
+import { ApiHelpers } from '.'
+
+export class ApiHelpersQuery<T extends CuboEntitiesMap<T>> {
+  constructor(private helpers: ApiHelpers<T>) {}
+
+  public async createFindQuery(
+    req: CuboCrudRequest,
+    entity: CuboEntityModel,
+    queryDto?: Partial<CuboCrudFindQuery>,
+    isCount?: boolean
+  ): Promise<Partial<CuboCrudFindQuery>> {
+    const withes = queryDto?.withes !== undefined ? queryDto.withes : []
+    const selects = queryDto?.selects !== undefined ? queryDto.selects : []
+    const joins = queryDto?.joins !== undefined ? queryDto.joins : []
+    const conditions = queryDto?.conditions !== undefined ? queryDto.conditions : []
+    const sorts = queryDto?.sorts !== undefined ? queryDto.sorts : []
+    const replacements = queryDto?.replacements !== undefined ? queryDto?.replacements : {}
+
+    const { sort, limit: _limit, page, with: _withes, ...query } = req.query || {}
+
+    // plain conditions (nested are in withes.ts)
+    for (const key in query || {}) {
+      const parts = key.replace(CUBO_CRUD_QUERY_KEY_REGEX, '')?.split('.')
+
+      if (parts.length === 1) {
+        const conditionField = entity.fields?.find((f) => f.alias === parts[0])
+        const defaultField = CUBO_CRUD_DEFAULT_FIELDS.find((f) => f.alias === parts[0])
+
+        if (!conditionField && !defaultField) {
+          throw new Error('condition field "' + parts[0] + '" not found in entity "' + entity.alias + '"')
+        }
+
+        const fieldAlias = conditionField ? conditionField.alias : defaultField!.alias
+        const preparedCondition = this.helpers.clearFieldConditionValue(conditionField ? conditionField : defaultField!, query[key])
+        const prepared = this.helpers.prepareConditionSql(
+          `t1.${fieldAlias}`,
+          `c_1_${fieldAlias}_value`,
+          preparedCondition.value,
+          preparedCondition.condition,
+          preparedCondition.is_not
+        )
+
+        conditions.push(...(prepared.conditions || []))
+        Object.assign(replacements, prepared.replacements || {})
+      }
+    }
+
+    // sort
+    if (sort !== undefined && typeof sort === 'string') {
+      const sortParts = sort.split(',')
+
+      for (const sortPart of sortParts) {
+        const parts = sortPart.replace(CUBO_CRUD_QUERY_KEY_REGEX, '')?.split('.')
+
+        if (parts.length === 1) {
+          const sortDirection = sortPart[0] === '-' ? 'desc' : 'asc'
+          const sortKey = sortPart[0] === '-' ? sortPart.slice(1) : sortPart
+
+          const conditionField = entity.fields?.find((f) => f.alias === sortKey)
+          const defaultField = CUBO_CRUD_DEFAULT_FIELDS.find((f) => f.alias === sortKey)
+
+          if (!conditionField && !defaultField) {
+            throw new Error('sortPart field "' + sortKey + '" not found')
+          }
+
+          sorts.push('t1.' + sortKey + ' ' + sortDirection)
+        }
+      }
+    } else {
+      sorts.push('t1.id desc')
+    }
+
+    // limit & offset
+    let perPage = _limit !== undefined && !isNaN(+_limit) ? _limit : CUBO_CRUD_DEFAULT_PAGE_LIMIT
+    let pageNumber = page !== undefined && !isNaN(+page) ? +page : 1
+    if (pageNumber < 1) {
+      pageNumber = 1
+    }
+    if (perPage > CUBO_CRUD_MAX_PAGE_LIMIT) {
+      perPage = CUBO_CRUD_MAX_PAGE_LIMIT
+    }
+    if (perPage < 0) {
+      perPage = 0
+    }
+
+    const filtersLimit = perPage
+    const filtersOffset = (pageNumber - 1) * perPage
+
+    let offsetString = ''
+    let limitString = ''
+    let groupByString = ''
+
+    if (!isCount && perPage > 0) {
+      if (filtersOffset > 0) {
+        offsetString = `offset ${filtersOffset}`
+      }
+      limitString = `limit ${filtersLimit}`
+    }
+
+    selects.push(...CUBO_CRUD_DEFAULT_FIELDS.map((f) => `t1.${f.alias}`))
+    selects.push(...entity.fields.map((f) => `t1.${f.alias}`))
+
+    // remove deleted rows
+    if (!queryDto?.withDeleted) {
+      conditions.push('t1.deleted_at is null')
+    }
+
+    const sql = `
+      select 
+        ${isCount ? 'count(t1.id) total' : selects.join(',\n')}
+      from 
+        ${entity.alias} t1
+      ${joins.join('\n')}
+      ${conditions.length > 0 ? `where (${conditions.join(') and (')})` : ''}
+      ${groupByString}
+      ${sorts.length > 0 && !isCount ? 'order by ' + sorts.join(', ') : ''}
+      ${limitString}
+      ${offsetString}
+    `
+
+    return {
+      withes,
+      selects,
+      joins,
+      conditions,
+      sorts,
+      replacements,
+      sql
+    }
+  }
+
+  public async createUpdateQuery(req: CuboCrudRequest, entity: CuboEntityModel, queryDto?: Partial<CuboCrudFindQuery>) {
+    const dto = await this.helpers.data.prepare('update', entity.fields, req.body)
+
+    if (!Object.keys(dto)) {
+      throw { status: 400, text: 'No keys to update' }
+    }
+
+    return dbPrepareUpdateQueryString(dto)
+  }
+}