@cuboapp/api-backend 1.0.7 → 1.0.9

package/src/helpers/convert.ts

@@ -1,11 +1,10 @@
 import { CuboApiEntitiesMap, CuboEntity, CuboEntityField } from '@cuboapp/types'
-import get from 'lodash-es/get'
-import set from 'lodash-es/set'
-import unset from 'lodash-es/unset'
+import { get, set, unset } from '@cuboapp/utils'
 
-import { CUBO_CRUD_DEFAULT_FIELDS, CUBO_ENTITY_FIELD_TYPE } from '../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>> {
@@ -42,58 +41,34 @@ export class ApiHelpersConvert<T extends CuboApiEntitiesMap<T>> {
 
       const rowValue = get(row, initialValueKey, undefined)
 
-      // todo: fix fields from core
-      if (!withEl.entity && withEl.entity.alias === 'users') {
-        userFieldsPrepared.push(withEl.full_key)
-
-        switch (rowValue) {
-          case null:
-          case undefined:
-            set(row, withEl.full_key, null)
-            break
-          case 0:
-            set(row, withEl.full_key, { id: 0, name: this.helpers.api.account.name })
-            break
-          default:
-            const user = await this.helpers.users.getById(rowValue)
-
-            set(
-              row,
-              withEl.full_key,
-              user ? { id: user.id, name: user.name, email: user.email } : { id: rowValue, name: `User #${rowValue}` }
-            )
-            break
-        }
-      } else {
-        const rowValueEmpty = [0, '0', '', null, 'null'].includes(rowValue)
+      const rowValueEmpty = [0, '0', '', null, 'null'].includes(rowValue)
 
-        if (rowValueEmpty) {
-          set(row, withEl.full_key, null)
-        }
+      if (rowValueEmpty) {
+        set(row, withEl.full_key, null)
+      }
 
-        if (toPrepare[withEl.key]) {
-          delete toPrepare[withEl.key]
-        }
+      if (toPrepare[withEl.key]) {
+        delete toPrepare[withEl.key]
+      }
 
-        // console.log('rowValue', withEl.full_key, { rowValueEmpty, rowValue })
+      // console.log('rowValue', withEl.full_key, { rowValueEmpty, rowValue })
 
-        for (const field of [...withEl.entity.fields, ...CUBO_CRUD_DEFAULT_FIELDS]) {
-          const fieldValueKey = withEl.table_name.toLowerCase() + '_' + field.alias
+      for (const field of [...withEl.entity.fields, ...CUBO_CRUD_DEFAULT_FIELDS]) {
+        const fieldValueKey = withEl.table_name.toLowerCase() + '_' + field.alias
 
-          // console.log('add field', field.alias, rowValueEmpty)
+        // console.log('add field', field.alias, rowValueEmpty)
 
-          if (!rowValueEmpty && !usersDefaultFields.includes(field.alias)) {
-            const fieldKeyPath = withEl.full_key + '.' + field.alias
-            const rowRelationValue = get(row, fieldValueKey, undefined)
+        if (!rowValueEmpty && !usersDefaultFields.includes(field.alias)) {
+          const fieldKeyPath = withEl.full_key + '.' + field.alias
+          const rowRelationValue = get(row, fieldValueKey, undefined)
 
-            set(row, fieldKeyPath, this.prepareFieldValue(field, rowRelationValue))
+          set(row, fieldKeyPath, this.prepareFieldValue(field, rowRelationValue))
 
-            toPrepare[fieldKeyPath] = field
-          }
+          toPrepare[fieldKeyPath] = field
+        }
 
-          if (field.alias !== 'id') {
-            toRemove.push(fieldValueKey)
-          }
+        if (field.alias !== 'id') {
+          toRemove.push(fieldValueKey)
         }
       }
     }
@@ -113,8 +88,8 @@ export class ApiHelpersConvert<T extends CuboApiEntitiesMap<T>> {
     return row
   }
 
-  private prepareFieldValue(field: Pick<CuboEntityField, 'type_id' | 'alias' | 'extra'>, value: any) {
-    switch (field.type_id) {
+  private prepareFieldValue(field: Pick<CuboEntityField, 'type' | 'alias' | 'extra'>, value: any) {
+    switch (field.type) {
       case CUBO_ENTITY_FIELD_TYPE.BOOLEAN:
         return value !== undefined ? (['true', true].includes(value) ? true : false) : null
       case CUBO_ENTITY_FIELD_TYPE.DATE:

package/src/helpers/data.ts

@@ -1,7 +1,6 @@
+import { CUBO_ENTITY_FIELD_TYPE } from '@cuboapp/constants'
 import { CuboApiEntitiesMap, CuboEntityField } from '@cuboapp/types'
-import keyBy from 'lodash-es/keyBy'
-
-import { CUBO_ENTITY_FIELD_TYPE } from '../constants'
+import { keyBy } from '@cuboapp/utils'
 
 import { ApiHelpers } from '.'
 
@@ -43,7 +42,7 @@ export class ApiHelpersData<T extends CuboApiEntitiesMap<T>> {
         const value = dto[key]
         const tval = typeof value
 
-        switch (fieldsByAlias[key].type_id) {
+        switch (fieldsByAlias[key].type) {
           case CUBO_ENTITY_FIELD_TYPE.TEXT:
             {
               if (value === null) {

package/src/helpers/index.ts

@@ -1,31 +1,33 @@
-import { CuboConfigDatabase } from '@cuboapp/config'
-import { CuboApiEntitiesMap, CuboEntityField, CuboEntityFieldExtra } from '@cuboapp/types'
-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 { CUBO_ENTITY_FIELD_TYPE } from '@cuboapp/constants'
+import { Database, createDatabase, type Options } from '@cuboapp/database'
+import { CuboApiEntitiesMap, CuboEntity, CuboEntityField, CuboEntityFieldExtra, CuboEntityFieldType } from '@cuboapp/types'
+
+import { CuboBackendApi, CuboBackendApiDbConnectionType, CuboCrudFindQuery, CuboCrudRequest } from '../..'
+import {
+  CUBO_CRUD_DEFAULT_FIELDS,
+  CUBO_CRUD_DEFAULT_PAGE_LIMIT,
+  CUBO_CRUD_MAX_PAGE_LIMIT,
+  CUBO_CRUD_QUERY_CONDITION,
+  CUBO_CRUD_QUERY_KEY_REGEX,
+  CUBO_CRUD_QUERY_SYMBOL_NOT
+} from '../constants'
 
 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 CuboApiEntitiesMap<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>> = {}
+  private connections: Partial<Record<CuboBackendApiDbConnectionType, Database>> = {}
+  private connecting: Record<string, Promise<Database>> = {}
 
   public getCached(alias: string, cb: (force: boolean) => Promise<any>, force = false) {
     if (!force && this.cache[alias] !== undefined) return this.cache[alias]
@@ -49,7 +51,10 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
     return this.fetching[alias]
   }
 
-  public clearFieldConditionValue(field: CuboEntityField | { type_id: number; alias: string; extra?: CuboEntityFieldExtra }, value: any) {
+  public clearFieldConditionValue(
+    field: CuboEntityField | { type: CuboEntityFieldType; alias: string; extra?: CuboEntityFieldExtra },
+    value: any
+  ) {
     const type = typeof value
 
     const parts = `${value}`.split(':')
@@ -87,7 +92,7 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
         throw new Error(`"${field.alias}": incorrect condition value "${value}"`)
     }
 
-    switch (field.type_id) {
+    switch (field.type) {
       case CUBO_ENTITY_FIELD_TYPE.TEXT:
       case CUBO_ENTITY_FIELD_TYPE.TEXTAREA:
         switch (type) {
@@ -265,25 +270,23 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
     }
   }
 
-  public async dropConnection(account_id: number) {
-    if (this.connections[account_id]) {
-      await this.connections[account_id].close()
-      delete this.connections[account_id]
+  public async dropConnection(type: CuboBackendApiDbConnectionType) {
+    if (this.connections[type]) {
+      await this.connections[type].disconnect()
+      delete this.connections[type]
     }
   }
 
-  public async getConnection(type: 'read' | 'write') {
-    const cacheKey = `${type}_${this.api.account.id}`
-
-    if (this.connections[cacheKey]) {
-      return this.connections[cacheKey]
+  public async getConnection(type: CuboBackendApiDbConnectionType) {
+    if (this.connections[type]) {
+      return this.connections[type]
     }
 
-    if (this.connecting[cacheKey] !== undefined) {
-      return this.connecting[cacheKey]
+    if (this.connecting[type] !== undefined) {
+      return this.connecting[type]
     }
 
-    this.connecting[cacheKey] = new Promise(async (success) => {
+    this.connecting[type] = new Promise(async (success) => {
       let database: string = ''
       let host: string = ''
       let port: number = 0
@@ -293,22 +296,23 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
       let dialect: string = ''
       let dialectModule: any = undefined
 
-      if (!this.api.config.db) {
+      if (!this.api.options.db.options) {
         throw 'DB connection is not configured'
       }
 
-      const dbConfig = this.api.config.db as any
-      let cfg: CuboConfigDatabase = {} as any
+      const dbConfig = this.api.options.db.options
+
+      let cfg: Options = {}
       if (dbConfig) {
         if (dbConfig[type]) {
           cfg = dbConfig[type]
         } else {
-          cfg = dbConfig as CuboConfigDatabase
+          cfg = dbConfig as Options
         }
       }
 
       database = cfg.database as string
-      dialectModule = cfg.dialectModule as string
+      dialectModule = cfg.dialectModule
       host = cfg.host as string
       port = cfg.port as number
       username = cfg.username as string
@@ -316,10 +320,6 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
       schema = cfg.schema as string
       dialect = cfg.dialect as string
 
-      if (!schema) {
-        schema = `account_${this.api.account.id}`
-      }
-
       const config: Options = {
         host,
         port,
@@ -351,26 +351,168 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>> {
         }
       }
 
-      const db = new Sequelize(config)
-
-      this.connections[cacheKey] = db
-      await db.authenticate()
+      this.connections[type] = createDatabase(config)
+      await this.connections[type].connect()
 
       if (dialect === 'postgres') {
-        await db.query(`SET schema '${schema}';`)
+        await this.connections[type].connection.query(`SET schema '${schema}';`)
       }
 
-      success(db)
+      success(this.connections[type])
 
-      delete this.connecting[cacheKey]
+      delete this.connecting[type]
     })
 
-    return this.connecting[cacheKey]
+    return this.connecting[type]
   }
 
-  public async transaction(type: 'read' | 'write') {
+  public async transaction(type: CuboBackendApiDbConnectionType) {
     const db = await this.getConnection(type)
 
-    return db.transaction()
+    return db.connection.transaction()
+  }
+
+  public async getEntityByAlias(alias: keyof T): Promise<CuboEntity | undefined> {
+    return this.api.options.entities.find((e) => e.alias === alias)
+  }
+
+  public async getEntityById(id: number): Promise<CuboEntity | undefined> {
+    return this.api.options.entities.find((e) => e.id === id)
+  }
+
+  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.clearFieldConditionValue(conditionField ? conditionField : defaultField!, query[key])
+        const prepared = this.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
+    }
   }
 }

package/src/helpers/withes.ts

@@ -1,5 +1,5 @@
 import { CuboApiEntitiesMap, CuboApiEntityDefaultUsersKeys, CuboEntity, CuboEntityField } from '@cuboapp/types'
-import cloneDeep from 'lodash-es/cloneDeep'
+import { cloneDeep } from '@cuboapp/utils'
 
 import { CUBO_CRUD_DEFAULT_FIELDS, CUBO_CRUD_QUERY_KEY_REGEX } from '../constants'
 import { CuboCrudFindQuery, CuboCrudMethodOptions, CuboCrudRequest, CuboCrudWith } from '../types'
@@ -79,11 +79,11 @@ export class ApiHelpersWithes<T extends CuboApiEntitiesMap<T>> {
         let relationEntity: CuboEntity | undefined
 
         if (relation_entity_id) {
-          relationEntity = await this.helpers.entities.getById(relation_entity_id)
+          relationEntity = await this.helpers.getEntityById(relation_entity_id)
         }
 
         if (!relationEntity && relation_entity_alias) {
-          relationEntity = await this.helpers.entities.getByAlias(relation_entity_alias)
+          relationEntity = await this.helpers.getEntityByAlias(relation_entity_alias)
         }
 
         lastEntity = relationEntity
@@ -238,9 +238,9 @@ export class ApiHelpersWithes<T extends CuboApiEntitiesMap<T>> {
     const havings: string[] = [...(opts?.queryOptions?.havings || [])]
     const replacements: Record<string, any> = { ...(opts?.queryOptions?.replacements || {}) }
     const groupBy: string = opts?.queryOptions?.groupBy || undefined
+    const sorts: string[] = opts?.queryOptions?.sorts || []
 
     const withes: CuboCrudWith[] = []
-    const sorts: string[] = []
 
     // from sort key
     if (_sort) {