@cuboapp/api-backend 1.0.0

package/src/helpers/users.ts

@@ -0,0 +1,38 @@
+import keyBy from 'lodash-es/keyBy'
+
+import { CuboEntitiesMap, CuboUserModel } from '../../types'
+
+import { ApiHelpers } from '.'
+
+export class ApiHelpersUsers<T extends CuboEntitiesMap<T>> {
+  constructor(private helpers: ApiHelpers<T>) {}
+
+  public async getMany(force = false): Promise<CuboUserModel[]> {
+    const users = await this.helpers.getCached(
+      `users`,
+      async () => {
+        return this.helpers.api
+          .apiRequest<{ items: CuboUserModel[] }>(`/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<CuboUserModel | undefined> {
+    const entities = await this.getMany()
+    return entities.find((e) => e.email === email)
+  }
+
+  public async getById(id: number): Promise<CuboUserModel | undefined> {
+    const entities = await this.getManyById()
+    return entities[id]
+  }
+}

package/src/helpers/withes.ts

@@ -0,0 +1,292 @@
+import cloneDeep from 'lodash-es/cloneDeep'
+
+import { CUBO_CRUD_DEFAULT_FIELDS, CUBO_CRUD_QUERY_KEY_REGEX } from '../../constants'
+import {
+  CuboCrudFindQuery,
+  CuboCrudMethodOptions,
+  CuboCrudRequest,
+  CuboCrudWith,
+  CuboEntitiesMap,
+  CuboEntityDefaultUsersKeys,
+  CuboEntityFieldModel,
+  CuboEntityModel
+} from '../../types'
+
+import { ApiHelpers } from '.'
+
+export class ApiHelpersWithes<T extends CuboEntitiesMap<T>> {
+  constructor(private helpers: ApiHelpers<T>) {}
+
+  private async getKeyWithes(
+    key: string,
+    entity: CuboEntityModel,
+    withes: CuboCrudWith[],
+    opts: {
+      replacements?: Record<string, any>
+      selects?: string[]
+      joins?: string[]
+      sorts?: string[]
+      conditions?: string[]
+      conditionKey?: string
+      conditionValue?: any
+      sortKey?: string
+      sortDirection?: 'asc' | 'desc'
+    }
+  ): Promise<{ withes: CuboCrudWith[]; joins: string[]; selects?: string[]; conditions?: string[]; replacements?: string[] }> {
+    const normalKey = key.replace(CUBO_CRUD_QUERY_KEY_REGEX, '')
+
+    if (normalKey !== key) {
+      throw new Error('invalid relation key: "' + key + '"')
+    }
+
+    withes = withes || []
+    opts.joins = opts.joins || []
+    opts.replacements = opts.replacements || {}
+
+    const needSelect = opts.selects !== undefined && Array.isArray(opts.selects)
+    const needConditions =
+      opts.conditions !== undefined &&
+      Array.isArray(opts.conditions) &&
+      typeof opts.conditionKey === 'string' &&
+      opts.conditionValue !== undefined
+
+    const needSorts = opts.sorts !== undefined && Array.isArray(opts.sorts)
+
+    const parts = normalKey.split('.') as (keyof T | CuboEntityDefaultUsersKeys)[]
+
+    const currentKey: string[] = []
+    let lastEntity: CuboEntityModel | undefined = entity
+    let joinIndex = (opts.joins.length || 0) + 1
+    let joinAlias = 0
+
+    for (const part of parts) {
+      const prevPartKey = currentKey.join('.')
+      const prevSelectKey = currentKey.join('_')
+
+      currentKey.push(part as string)
+
+      const partKey = currentKey.join('.')
+      const tableName = currentKey.join('_')
+
+      const joinCustomField: CuboEntityFieldModel | undefined = lastEntity?.fields?.find((f) => f.extra?.select_entity_key === part)
+      const joinDefaultField = CUBO_CRUD_DEFAULT_FIELDS.find((f) => f.extra?.select_entity_key === part)
+
+      const ex = withes.find((i) => i.key === partKey)
+
+      // если нашли кастомное поле
+      if (joinCustomField) {
+        const relation_entity_id: number | undefined = joinCustomField?.extra?.select_entity_id
+        const relation_entity_alias: keyof T | undefined = joinCustomField?.extra?.select_entity_alias as keyof T
+
+        if (!relation_entity_id && !relation_entity_alias) {
+          throw new Error('relation for key not found: "' + partKey + '"')
+        }
+
+        if (relation_entity_id) {
+          lastEntity = await this.helpers.entities.getById(relation_entity_id)
+        } else if (relation_entity_alias) {
+          lastEntity = await this.helpers.entities.getByAlias(relation_entity_alias)
+        }
+
+        if (!lastEntity) {
+          throw new Error('entity for relation key not found: "' + partKey + '"')
+        }
+
+        if (!ex) {
+          joinIndex += 1
+          joinAlias += 1
+
+          withes.push({
+            entity: cloneDeep(lastEntity),
+            full_key: partKey,
+            key: part as string,
+            table_name: tableName
+          })
+
+          opts.joins.push(
+            `
+              left join 
+                ${lastEntity.alias} t_${tableName}
+              on 
+                t_${tableName}.id = ${prevSelectKey ? `t_${prevSelectKey}` : 't1'}.${joinCustomField.alias}
+            `
+          )
+        }
+
+        if (needSelect) {
+          opts.selects = opts.selects || []
+
+          for (const selectKey of [
+            ...lastEntity.fields.map((f) => `t_${tableName}.${f.alias} as ${tableName}_${f.alias}`),
+            ...CUBO_CRUD_DEFAULT_FIELDS.map((f) => `t_${tableName}.${f.alias} as ${tableName}_${f.alias}`)
+          ]) {
+            if (!opts.selects.includes(selectKey)) {
+              opts.selects.push(selectKey)
+            }
+          }
+        }
+      } else if (joinDefaultField) {
+        if (ex === undefined) {
+          withes.push({
+            entity: { id: undefined, alias: 'users', fields: [] },
+            full_key: partKey,
+            key: part as string,
+            table_name: tableName
+          })
+        }
+      }
+    }
+
+    const ret: any = {
+      withes,
+      joins: opts.joins,
+      conditions: opts.conditions || undefined,
+      replacements: opts.replacements || undefined
+    }
+
+    if (needSelect) {
+      ret.selects = opts.selects
+    }
+
+    if (needConditions) {
+      const conditionKey = opts.conditionKey?.replace(CUBO_CRUD_QUERY_KEY_REGEX, '') || ''
+      const conditionKeyParts = conditionKey.split('.')
+      const conditionLastKey = conditionKeyParts.pop()
+
+      const conditionField =
+        lastEntity.fields?.find((f) => f.alias === conditionLastKey) || CUBO_CRUD_DEFAULT_FIELDS.find((f) => f.alias === conditionLastKey)
+
+      if (!conditionField) {
+        throw new Error('condition field "' + conditionKey + '" not found in entity "' + entity.alias + '"')
+      }
+
+      let conditionTableAlias = 't1'
+      if (conditionKeyParts.length > 0) {
+        const exWith = withes.find((w) => (w.full_key = conditionKeyParts.join('.')))
+
+        if (!exWith) {
+          throw new Error('condition field relation "' + conditionKey + '" not found')
+        }
+
+        conditionTableAlias = 't_' + exWith.table_name
+      }
+
+      opts.conditions = opts.conditions || []
+
+      const preparedCondition = this.helpers.clearFieldConditionValue(conditionField, opts.conditionValue)
+
+      const prepared = this.helpers.prepareConditionSql(
+        `${conditionTableAlias}.${conditionField.alias}`,
+        `${conditionTableAlias}_${conditionField.alias}_value`,
+        preparedCondition.value,
+        preparedCondition.condition,
+        preparedCondition.is_not
+      )
+
+      opts.conditions.push(...(prepared.conditions || []))
+      Object.assign(opts.replacements, prepared.replacements || {})
+    }
+
+    // сортировка
+    if (needSorts) {
+      const sortParts = (opts.sortKey?.replace(CUBO_CRUD_QUERY_KEY_REGEX, '') || '').split(',')
+
+      for (const sortPart of sortParts) {
+        const sortKeyParts = sortPart.split('.')
+        const sortLastKey = sortKeyParts.pop()
+
+        const sortField =
+          lastEntity.fields?.find((f) => f.alias === sortLastKey) || CUBO_CRUD_DEFAULT_FIELDS.find((f) => f.alias === sortLastKey)
+        if (!sortField) {
+          throw new Error('sort field "' + sortPart + '" not found')
+        }
+
+        opts.sorts = opts.sorts || []
+
+        let sortTableAlias = 't1'
+        if (sortKeyParts.length > 0) {
+          const exWith = withes.find((w) => (w.full_key = sortKeyParts.join('.')))
+
+          if (!exWith) {
+            throw new Error('sort field relation "' + sortPart + '" not found')
+          }
+
+          sortTableAlias = 't_' + exWith.table_name
+        }
+
+        opts.sorts.push(`${sortTableAlias}.${sortField.alias} ${opts.sortDirection || 'asc'}`)
+      }
+    }
+
+    return ret
+  }
+
+  public async prepare(req: CuboCrudRequest, entity: CuboEntityModel, opts?: CuboCrudMethodOptions): Promise<Partial<CuboCrudFindQuery>> {
+    const { with: __withes, sort: _sort, limit: _limit, ...other } = req.query || {}
+
+    const _withes = (__withes || '').split(',').filter((i: string) => i !== '')
+
+    if (opts?.queryOptions?.withes?.length) {
+      _withes.push(...(opts?.queryOptions?.withes || []).filter((i: string) => i !== ''))
+    }
+
+    const joins: string[] = [...(opts?.queryOptions?.joins || [])]
+    const selects: string[] = [...(opts?.queryOptions?.selects || [])]
+    const conditions: string[] = [...(opts?.queryOptions?.conditions || [])]
+    const replacements: Record<string, any> = { ...(opts?.queryOptions?.replacements || {}) }
+
+    const withes: CuboCrudWith[] = []
+    const sorts: string[] = []
+
+    // from sort key
+    if (_sort) {
+      const sortKeyParts = _sort.split('.')
+
+      if (sortKeyParts.length > 1) {
+        const sortDirection = _sort[0] === '-' ? 'desc' : 'asc'
+        const sortAlias = sortDirection === 'desc' ? sortKeyParts.join('.').slice(1) : sortKeyParts.join('.')
+
+        await this.getKeyWithes(sortAlias, entity, withes, {
+          joins,
+          replacements,
+          sorts,
+          sortKey: _sort,
+          sortDirection
+        })
+      }
+    }
+
+    // from query-string filters
+    if (Object.keys(other || {}).length) {
+      for (const key in other) {
+        const keyParts = key.split('.')
+
+        if (keyParts.length > 1) {
+          const conditionValue = other[key]
+
+          await this.getKeyWithes(keyParts.join('.'), entity, withes, {
+            joins,
+            replacements,
+            conditions,
+            conditionKey: key,
+            conditionValue
+          })
+        }
+      }
+    }
+
+    // from ?with query param
+    if (Object.keys(_withes || {}).length) {
+      for (const key of _withes) {
+        await this.getKeyWithes(key, entity, withes, {
+          joins,
+          selects
+        })
+      }
+    }
+
+    // console.log({ sorts, withes, joins, selects, conditions, replacements })
+
+    return { sorts, withes, joins, selects, conditions, replacements }
+  }
+}

package/src/index.ts

@@ -0,0 +1,367 @@
+import { type CuboConfigEntity, CuboConfig } from '@cuboapp/config'
+import { CuboAccount, CuboApiEntitiesMap, CuboUser } from '@cuboapp/types'
+import { QueryTypes } from 'sequelize'
+
+import { ApiHelpers } from './helpers'
+import { CuboCrudAugmentationsStore, CuboCrudGetManyResponse, CuboCrudMethodOptions, CuboCrudRequest } from './types'
+import { dbPrepareInsertQueryString, dbPrepareUpdateQueryString } from './utils'
+
+export * from './types'
+export * from './utils'
+
+export type CuboBackendApiOptions<T> = {
+  entities?: CuboConfigEntity[]
+}
+
+export class CuboBackendApi<T extends CuboApiEntitiesMap<T>> {
+  public augmentations: Partial<CuboCrudAugmentationsStore<T>> = {}
+  public options: CuboBackendApiOptions<T> = {}
+
+  constructor(public config: CuboConfig, augmentations?: Partial<CuboCrudAugmentationsStore<T>>, options?: CuboBackendApiOptions<T>) {
+    this.augmentations = augmentations || {}
+    this.options = options || {}
+  }
+
+  // добавил потому что в хелперах он при getConnection берет id аккаунта и делает cacheKey
+  public account: CuboAccount = {
+    id: 0,
+    name: '',
+    subdomain: '',
+    domain: '',
+    location: '',
+    language: '',
+    favicon: undefined
+  }
+
+  public user: CuboUser
+  public helpers = new ApiHelpers<T>(this)
+
+  async init() {
+    const auth = await this.authRequest<{ account: CuboAccount; user: CuboUser }>('/me')
+
+    this.account = auth.account
+    this.user = auth.user
+
+    if (!this.account) {
+      throw new Error('Account not found')
+    }
+  }
+
+  async apiRequest<T>(url: string, opts?: RequestInit) {
+    const subdomain = this.account.subdomain
+    const rootDomain = this.config.api?.rootDomain || 'cuboapp.ru'
+    const baseUrl = `https://${subdomain}.${rootDomain}`
+
+    return this.request<T>(baseUrl, url, opts)
+  }
+
+  async authRequest<T>(url: string, opts?: RequestInit) {
+    const baseUrl = this.config.api?.authDomain || 'https://auth.cuboapp.ru'
+
+    return this.request<T>(baseUrl, url, opts)
+  }
+
+  private async request<T>(baseUrl: string, url: string, opts?: RequestInit & { withoutContentType?: boolean }) {
+    const headers: Record<string, any> = {
+      ...(opts?.headers || {}),
+      Authorization: this.config.api?.authToken || ''
+    }
+
+    if (!headers['Content-Type'] && !opts?.withoutContentType) {
+      headers['Accept'] = 'application/json'
+      headers['Content-Type'] = 'application/json'
+    }
+
+    const response = await fetch(baseUrl.replace(/\/$/, '') + '/' + url.replace(/^\//, ''), {
+      ...(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 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()
+      }
+    }
+  }
+
+  private async getEntity(entityAlias: Extract<keyof T, string>) {
+    const entity = await this.helpers.entities.getByAlias(entityAlias)
+    if (!entity) {
+      throw new Error('Entity no found: "' + String(entityAlias) + '"')
+    }
+
+    return entity
+  }
+
+  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.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
+
+    // create find query
+    const regularQuery = await this.helpers.query.createFindQuery(req, entity, queryDto)
+    const countQuery = await this.helpers.query.createFindQuery(req, entity, queryDto, true)
+
+    const db = await this.helpers.getConnection('read')
+
+    if (opts?.log) {
+      console.log(`QUERY:getMany to "${String(entityAlias)}":`, regularQuery.sql, regularQuery.replacements, { req, opts, queryDto })
+    }
+
+    const rows = await db.query<any>(regularQuery.sql!, {
+      type: QueryTypes.SELECT,
+      replacements: regularQuery.replacements,
+      transaction: opts?.transaction
+    })
+    const [totals] = await db.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.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.limit = 1
+
+    const query = await this.helpers.query.createFindQuery(req, entity, queryDto)
+
+    const db = await this.helpers.getConnection('read')
+
+    const [row] = await db.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.entities.getByAlias(entityAlias)
+    const augmentation = this.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?.user_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 sql = `
+      insert into ${entity!.alias} (${prepared.keys})
+      values (${prepared.values})
+      returning id
+    `
+
+    const created_id = await db
+      .query(sql, {
+        type: QueryTypes.INSERT,
+        replacements: prepared.replacements || {},
+        transaction: opts?.transaction
+      })
+      .then((res: any) => {
+        return +res?.[0]?.[0]?.id
+      })
+
+    if (!created_id) {
+      throw { status: 400, text: 'Unable to create entity' }
+    }
+
+    const 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)
+    }
+
+    return response
+  }
+
+  async updateOne<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.helpers.entities.getByAlias(entityAlias)
+    const augmentation = this.augmentations?.[entityAlias]
+
+    if (augmentation?.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 dto = await this.helpers.data.prepare('update', entity!.fields, req.body, opts?.user_id || 0)
+    if (!Object.keys(dto)) {
+      throw { status: 400, text: 'No keys to update' }
+    }
+
+    // console.log(dto)
+
+    const prepared = dbPrepareUpdateQueryString(dto)
+    const db = await this.helpers.getConnection('write')
+
+    const sql = `
+      update ${entity!.alias}
+      set ${prepared.query}
+      where id = ${item.id}
+    `
+
+    await db.query(sql, {
+      type: QueryTypes.UPDATE,
+      replacements: {
+        ...(prepared.replacements || {})
+      },
+      transaction: opts?.transaction
+    })
+
+    const 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)
+    }
+
+    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.entities.getByAlias(entityAlias)
+    const augmentation = this.augmentations?.[entityAlias]
+
+    if (augmentation?.beforeDelete) {
+      opts.queryOptions = await augmentation.beforeDelete(req, opts)
+    }
+
+    const item: any = await this.getOne(entityAlias, req, opts)
+
+    const dto = await this.helpers.data.prepare('delete', entity!.fields, req.body || {}, opts?.user_id)
+    if (!Object.keys(dto)) {
+      throw { status: 400, text: 'No keys to update' }
+    }
+
+    // console.log(dto)
+
+    const prepared = dbPrepareUpdateQueryString(dto)
+    const db = await this.helpers.getConnection('write')
+
+    const sql = `
+      update ${entity!.alias}
+      set ${prepared.query}
+      where id = ${item.id}
+    `
+
+    await db.query(sql, {
+      type: QueryTypes.UPDATE,
+      replacements: prepared.replacements || {},
+      transaction: opts?.transaction
+    })
+
+    if (augmentation?.afterDelete && !opts?.excludeHooks?.includes('afterDelete')) {
+      return augmentation.afterDelete(item, req, opts)
+    }
+
+    return true
+  }
+}
+
+export * from './helpers'