@cuboapp/api-backend 1.0.8 → 1.0.11

package/src/constants/backend.ts

@@ -1,74 +0,0 @@
-import { CuboEntityField } from '@cuboapp/types'
-
-import { CUBO_ENTITY_FIELD_TYPE } from './base'
-
-export const CUBO_CRUD_QUERY_KEY_REGEX = /[^a-zA-Z\.\_]/g
-
-export const CUBO_CRUD_QUERY_SYMBOL_NOT = 'not'
-
-export const CUBO_CRUD_DEFAULT_PAGE_LIMIT = 25
-export const CUBO_CRUD_MAX_PAGE_LIMIT = 500
-
-export const CUBO_CRUD_QUERY_CONDITION = {
-  EQ: 'eq',
-  EX: 'ex',
-  LIKE: 'like',
-  ILIKE: 'ilike',
-  IN: 'in',
-  NIN: 'nin',
-  GT: 'gt',
-  LT: 'lt',
-  GTE: 'gte',
-  LTE: 'lte'
-}
-
-export const CUBO_CRUD_DEFAULT_FIELDS: Pick<CuboEntityField, 'type_id' | 'alias' | 'extra'>[] = [
-  {
-    type_id: CUBO_ENTITY_FIELD_TYPE.NUMBER,
-    alias: 'id',
-    extra: {
-      number_subtype: 'int'
-    }
-  },
-  {
-    type_id: CUBO_ENTITY_FIELD_TYPE.TIMESTAMP,
-    alias: 'created_at',
-    extra: {}
-  },
-  {
-    type_id: CUBO_ENTITY_FIELD_TYPE.SELECT,
-    alias: 'created_by',
-    extra: {
-      select_subtype: 'user',
-      select_entity_key: 'created_by'
-    }
-  },
-  {
-    type_id: CUBO_ENTITY_FIELD_TYPE.TIMESTAMP,
-    alias: 'modified_at',
-    extra: {}
-  },
-  {
-    type_id: CUBO_ENTITY_FIELD_TYPE.SELECT,
-    alias: 'modified_by',
-    extra: {
-      select_subtype: 'user',
-      select_entity_key: 'modified_by'
-    }
-  },
-  {
-    type_id: CUBO_ENTITY_FIELD_TYPE.TIMESTAMP,
-    alias: 'deleted_at',
-    extra: {}
-  },
-  {
-    type_id: CUBO_ENTITY_FIELD_TYPE.SELECT,
-    alias: 'deleted_by',
-    extra: {
-      select_subtype: 'user',
-      select_entity_key: 'modified_by'
-    }
-  }
-]
-
-export const CUBO_CRUD_DEFAULT_FIELDS_ALIASES = CUBO_CRUD_DEFAULT_FIELDS.map((i) => i.alias)

package/src/constants/base.ts

@@ -1,11 +0,0 @@
-export const CUBO_ENTITY_FIELD_TYPE = {
-  TEXT: 1,
-  NUMBER: 2,
-  TEXTAREA: 3,
-  BOOLEAN: 4,
-  SELECT: 5,
-  DATE: 6,
-  TIMESTAMP: 7,
-  FILE: 8,
-  JSON: 9
-}

package/src/helpers/entities.ts

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

package/src/helpers/query.ts

@@ -1,157 +0,0 @@
-import { CuboApiEntitiesMap, CuboEntity } from '@cuboapp/types'
-
-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 } from '../types'
-import { dbPrepareUpdateQueryString } from '../utils'
-
-import { ApiHelpers } from '.'
-
-export class ApiHelpersQuery<T extends CuboApiEntitiesMap<T>> {
-  constructor(private helpers: ApiHelpers<T>) {}
-
-  public async createFindQuery(
-    req: CuboCrudRequest,
-    entity: CuboEntity,
-    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 havings = queryDto?.havings !== undefined ? queryDto.havings : []
-    const sorts = queryDto?.sorts !== undefined ? queryDto.sorts : []
-    const replacements = queryDto?.replacements !== undefined ? queryDto?.replacements : {}
-    const groupBy = queryDto?.groupBy !== undefined ? queryDto?.groupBy : undefined
-
-    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 (!sorts.length) {
-      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 = queryDto?.groupBy ?? ''
-
-    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}
-      ${havings.length > 0 ? `having (${havings.join(') and (')})` : ''}
-      ${sorts.length > 0 && !isCount ? 'order by ' + sorts.join(', ') : ''}
-      ${limitString}
-      ${offsetString}
-    `
-
-    // console.log('conditions', { conditions })
-    // console.log('sql', sql)
-
-    return {
-      withes,
-      selects,
-      joins,
-      conditions,
-      groupBy,
-      havings,
-      sorts,
-      replacements,
-      sql
-    }
-  }
-
-  public async createUpdateQuery(req: CuboCrudRequest, entity: CuboEntity, 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)
-  }
-}

package/src/helpers/users.ts

@@ -1,37 +0,0 @@
-import { CuboApiEntitiesMap, CuboUser } from '@cuboapp/types'
-import keyBy from 'lodash-es/keyBy'
-
-import { ApiHelpers } from '.'
-
-export class ApiHelpersUsers<T extends CuboApiEntitiesMap<T>> {
-  constructor(private helpers: ApiHelpers<T>) {}
-
-  public async getMany(force = false): Promise<CuboUser[]> {
-    const users = await this.helpers.getCached(
-      `users`,
-      async () => {
-        return this.helpers.api
-          .apiRequest<{ items: CuboUser[] }>(`/api/v1/users?account_id=${this.helpers.api.account.id}`)
-          .then((res) => res.items)
-      },
-      force
-    )
-
-    return users
-  }
-
-  public async getManyById(force = false) {
-    const users = await this.getMany(force)
-    return this.helpers.getCached(`users_by_id`, async () => keyBy(users, (i) => +i.id), force)
-  }
-
-  public async getByEmail(email: string): Promise<CuboUser | undefined> {
-    const entities = await this.getMany()
-    return entities.find((e) => e.email === email)
-  }
-
-  public async getById(id: number): Promise<CuboUser | undefined> {
-    const entities = await this.getManyById()
-    return entities[id]
-  }
-}

package/src/utils/index.ts

@@ -1,128 +0,0 @@
-import { QueryTypes, Sequelize, Transaction } from 'sequelize'
-
-export function dbPrepareUpdateQueryString(obj: Record<string, any>) {
-  const keys: string[] = []
-  const replacements: Record<string, any> = {}
-
-  for (const key in obj) {
-    const value = obj[key]
-
-    keys.push(`${key} = :${key}`)
-
-    let val = null
-
-    if (typeof value === 'string') {
-      val = !!value ? value : null
-    } else if (typeof value === 'number') {
-      val = !isNaN(value) ? value : null
-    } else if (typeof value === 'boolean') {
-      val = value
-    } else if (Array.isArray(value) || typeof value === 'object') {
-      val = value ? JSON.stringify(value) : null
-    }
-
-    replacements[key] = val
-  }
-
-  return { query: keys.join(', '), replacements }
-}
-
-export function dbPrepareInsertQueryString(obj: Record<string, any>) {
-  const values: string[] = []
-  const replacements: Record<string, any> = {}
-
-  for (const key in obj) {
-    const value = obj[key]
-
-    values.push(`:${key}`)
-
-    let val = null
-
-    if (typeof value === 'string') {
-      val = !!value ? value : null
-    } else if (typeof value === 'number') {
-      val = !isNaN(value) ? value : null
-    } else if (typeof value === 'boolean') {
-      val = value
-    } else if (Array.isArray(value) || typeof value === 'object') {
-      val = value ? JSON.stringify(value) : null
-    }
-
-    replacements[key] = val
-  }
-
-  return { keys: Object.keys(obj).join(', '), values: values.join(','), replacements }
-}
-
-export async function dbCreate(
-  db: Sequelize,
-  table: string,
-  arInsert: any,
-  opts?: { log?: boolean; transaction?: Transaction }
-): Promise<{ id: number }> {
-  if (Object.keys(arInsert).length > 0) {
-    const dialect = db.getDialect()
-
-    const { keys, values, replacements } = dbPrepareInsertQueryString(arInsert)
-
-    let sql = ''
-
-    switch (dialect) {
-      case 'postgres':
-        sql = `insert into ${table} (${keys}) values (${values}) returning id`
-        break
-      case 'mysql':
-        sql = `insert into ${table} (${keys}) values (${values})`
-        break
-      default:
-        throw ''
-    }
-
-    if (opts?.log) {
-      console.warn(`QUERY: ${sql} [${JSON.stringify(replacements)}]`)
-    }
-
-    return db
-      .query(sql, {
-        type: QueryTypes.INSERT,
-        replacements,
-        transaction: opts?.transaction
-      })
-      .then((res: any) => {
-        switch (dialect) {
-          case 'postgres':
-            return { id: +res?.[0]?.[0].id }
-          case 'mysql':
-            return { id: +res[0] }
-        }
-      })
-  }
-
-  throw new Error('QUERY: db create array empty')
-}
-
-export async function dbUpdate(
-  db: Sequelize,
-  table: string,
-  where: string,
-  replacements: Record<string, any>,
-  arUpdate: any,
-  opts?: { log?: boolean; transaction?: Transaction }
-) {
-  if (Object.keys(arUpdate).length > 0) {
-    const prepared = dbPrepareUpdateQueryString(arUpdate)
-
-    if (opts?.log) {
-      console.warn(`QUERY: update ${table} set ${prepared.query} where ${where} [${JSON.stringify(replacements)}]`)
-    }
-
-    await db.query(`update ${table} set ${prepared.query} where ${where}`, {
-      type: QueryTypes.UPDATE,
-      replacements: {
-        ...(replacements || {}),
-        ...(prepared.replacements || {})
-      },
-      transaction: opts?.transaction
-    })
-  }
-}