@cuboapp/api-backend 1.0.38 → 3.0.1

package/src/index.ts

@@ -1,444 +1,7 @@
-import { QueryTypes } from '@cuboapp/database'
-import { CuboApiEntitiesMap } from '@cuboapp/types'
-import { cloneDeep } from '@cuboapp/utils'
-
-import { ApiHelpers } from './helpers'
-import { CuboS3UploadFunctionOptions, CuboS3UploadFunctionResult, uploadToS3 } from './s3'
-import { CuboBackendApiAuth, CuboBackendApiOptions, CuboCrudGetManyResponse, CuboCrudMethodOptions, CuboCrudRequest } from './types'
-
-export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown> {
-  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 || {})
-          }
-        }
-      }
-    } 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 debounces = new Map<`${string}:${number}`, { started: number; promise: Promise<any> }>()
-
-  public async transaction() {
-    const db = await this.helpers.getConnection('write')
-
-    return db.connection.transaction()
-  }
-
-  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
-    }
-  }
-
-  public async uploadToS3(buffer: Buffer, opts: CuboS3UploadFunctionOptions): Promise<CuboS3UploadFunctionResult> {
-    return uploadToS3(buffer, opts)
-  }
-
-  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
-  }
-
-  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 || {}
-
-    req.query = cloneDeep(req.query || {})
-
-    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
-
-    // 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.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' }
-    }
-
-    // console.log('dto', dto)
-    // 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.options.hooks?.onAfterCreate && !opts?.excludeHooks?.includes('baseHooks')) {
-      await this.options.hooks.onAfterCreate(entity, response, 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> {
-    if (opts?.debounce) {
-      if (!req.query?.id) {
-        throw 'Debounce "updateOne" allowed only with "id"'
-      }
-
-      const key = `${entityAlias}:${+req.query.id}` as `${string}:${number}`
-      let ex = this.debounces.get(key)
-      if (ex) {
-        if (ex.started > +new Date() - opts.debounce) {
-          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 (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.options.hooks?.onAfterUpdate && !opts?.excludeHooks?.includes('baseHooks')) {
-      await this.options.hooks.onAfterUpdate(entity, response, initialEntity, 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.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 (this.options.hooks?.onAfterDelete && !opts?.excludeHooks?.includes('baseHooks')) {
-      await this.options.hooks.onAfterDelete(entity, item, opts)
-    }
-
-    // console.log(entityAlias, augmentation, opts)
-
-    if (augmentation?.afterDelete && !opts?.excludeHooks?.includes('afterDelete')) {
-      return augmentation.afterDelete(item, req, opts)
-    }
-
-    return true
-  }
-
-  async deleteMany<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 { rows: items } = await this.getMany(entityAlias, req, opts)
-    if (!items) {
-      return false
-    }
-
-    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')
-
-    for (const item of items) {
-      await db.update(entity.alias, 'id = :id', { id: (item as any).id }, dto, { transaction: opts?.transaction, log: opts?.log })
-
-      if (this.options.hooks?.onAfterDelete && !opts?.excludeHooks?.includes('baseHooks')) {
-        await this.options.hooks.onAfterDelete(entity, item, opts)
-      }
-    }
-
-    return true
-  }
-}
-
-export * from './helpers'
+export * from './core'
 export * from './types'
+export * from './helpers'
+export * from './hooks'
+export * from './query'
+export * from './dialects'
+export * from './crdt'

package/src/query/compile.ts

@@ -0,0 +1,212 @@
+import { CuboCompiledQuery, CuboOp, CuboQuery, CuboSort, CuboWith } from './types'
+
+/**
+ * Компилирует типизированный CuboQuery<R> в плоский «строковый» запрос движка
+ * (CuboCrudRequest.query). Чистая функция: на каждый вызов создаётся новый
+ * объект — query-опции иммутабельны по построению, ничего не «накапливается».
+ *
+ * Поддержка операторов через flat-DSL:
+ *   eq/ne/gt/gte/lt/lte/in/nin/like/ilike/between/isNull/not.
+ * Диапазон gte+lte на одном поле автоматически сворачивается в between.
+ * Экзотические комбинации (>1 оператора, не сводящиеся к диапазону) —
+ * через escape-hatch `raw` в CuboCrudMethodOptions.queryOptions.
+ */
+export function compileQuery<R>(query?: CuboQuery<R>): CuboCompiledQuery {
+  const out: CuboCompiledQuery = {}
+
+  if (!query) {
+    return out
+  }
+
+  if (query.where) {
+    compileWhere(query.where as Record<string, any>, '', out)
+  }
+
+  if (query.with) {
+    const withList = compileWith(query.with as CuboWith<R>)
+    if (withList.length) {
+      out.with = withList.join(',')
+    }
+  }
+
+  if (query.sort) {
+    const sort = compileSort(query.sort)
+    if (sort) {
+      out.sort = sort
+    }
+  }
+
+  if (query.limit !== undefined) {
+    out.limit = query.limit
+  }
+
+  if (query.page !== undefined) {
+    out.page = query.page
+  }
+
+  return out
+}
+
+function compileWhere(where: Record<string, any>, prefix: string, out: CuboCompiledQuery) {
+  for (const key in where) {
+    const value = where[key]
+    const fullKey = prefix ? `${prefix}.${key}` : key
+
+    // вложенная связь -> рекурсивно с dot-notation ключом
+    if (isPlainObject(value) && !isOperatorObject(value)) {
+      compileWhere(value, fullKey, out)
+      continue
+    }
+
+    out[fullKey] = compileOp(fullKey, value)
+  }
+}
+
+/** true, если объект похож на набор операторов (а не на вложенный where). */
+const OP_KEYS = ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'like', 'ilike', 'between', 'isNull', 'not']
+function isOperatorObject(value: object): boolean {
+  return Object.keys(value).some((k) => OP_KEYS.includes(k))
+}
+
+function isPlainObject(value: any): value is Record<string, any> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)
+}
+
+/** Кодирует один оператор поля в строковое значение flat-DSL. */
+function compileOp(key: string, op: CuboOp<any>): any {
+  // короткая форма: просто значение (или null) = eq
+  if (op === null || typeof op !== 'object' || op instanceof Date || Array.isArray(op)) {
+    return op
+  }
+
+  const o = op as Exclude<CuboOp<any>, any[]> & Record<string, any>
+  const present = Object.keys(o).filter((k) => o[k] !== undefined)
+
+  // диапазон gte+lte -> between
+  if (present.length === 2 && present.includes('gte') && present.includes('lte')) {
+    return `btw:${o.gte}:${o.lte}`
+  }
+
+  if (present.length > 1) {
+    throw new Error(`query "${key}": несколько операторов на одно поле не поддерживаются (используйте between или queryOptions.raw): ${present.join(', ')}`)
+  }
+
+  const [cond] = present
+
+  switch (cond) {
+    case 'eq':
+      return o.eq
+    case 'ne':
+      return o.ne === null ? 'not:null' : `not:${o.ne}`
+    case 'gt':
+      return `gt:${o.gt}`
+    case 'gte':
+      return `gte:${o.gte}`
+    case 'lt':
+      return `lt:${o.lt}`
+    case 'lte':
+      return `lte:${o.lte}`
+    case 'in':
+      return `in:${(o.in as any[]).join(',')}`
+    case 'nin':
+      return `nin:${(o.nin as any[]).join(',')}`
+    case 'like':
+      return `like:${o.like}`
+    case 'ilike':
+      return `ilike:${o.ilike}`
+    case 'between':
+      return `btw:${o.between[0]}:${o.between[1]}`
+    case 'isNull':
+      return o.isNull ? null : 'not:null'
+    case 'not':
+      return compileNot(key, o.not)
+    default:
+      // пустой объект операторов — игнорируем
+      return undefined
+  }
+}
+
+/** Кодирует отрицание. Движок поддерживает максимум 3 уровня: not:<cond>:<value>. */
+function compileNot(key: string, inner: CuboOp<any>): string {
+  if (inner === null) {
+    return 'not:null'
+  }
+  if (typeof inner !== 'object' || inner instanceof Date || Array.isArray(inner)) {
+    return `not:${inner}` // not:value === ne
+  }
+
+  const o = inner as Record<string, any>
+  const present = Object.keys(o).filter((k) => o[k] !== undefined)
+  if (present.length !== 1) {
+    throw new Error(`query "${key}": "not" поддерживает ровно один оператор`)
+  }
+
+  const [cond] = present
+  switch (cond) {
+    case 'eq':
+      return o.eq === null ? 'not:null' : `not:${o.eq}`
+    case 'gt':
+      return `not:gt:${o.gt}`
+    case 'gte':
+      return `not:gte:${o.gte}`
+    case 'lt':
+      return `not:lt:${o.lt}`
+    case 'lte':
+      return `not:lte:${o.lte}`
+    case 'in':
+      return `not:in:${(o.in as any[]).join(',')}`
+    case 'nin':
+      return `not:nin:${(o.nin as any[]).join(',')}`
+    case 'like':
+      return `not:like:${o.like}`
+    case 'ilike':
+      return `not:ilike:${o.ilike}`
+    case 'isNull':
+      return o.isNull ? 'not:null' : null!
+    default:
+      throw new Error(`query "${key}": оператор "${cond}" нельзя инвертировать через "not" (используйте queryOptions.raw)`)
+  }
+}
+
+/** Собирает список dot-notation путей для `with` из массива или дерева. */
+function compileWith<R>(input: CuboWith<R>, prefix = ''): string[] {
+  const result: string[] = []
+
+  if (Array.isArray(input)) {
+    for (const key of input) {
+      result.push(prefix ? `${prefix}.${String(key)}` : String(key))
+    }
+    return result
+  }
+
+  for (const key in input as Record<string, any>) {
+    const node = (input as Record<string, any>)[key]
+    const path = prefix ? `${prefix}.${key}` : key
+
+    result.push(path)
+
+    if (node && node !== true && node.with) {
+      result.push(...compileWith(node.with, path))
+    }
+  }
+
+  return result
+}
+
+function compileSort<R>(sort: CuboSort<R> | CuboSort<R>[]): string {
+  const list = Array.isArray(sort) ? sort : [sort]
+  const parts: string[] = []
+
+  for (const item of list) {
+    if (typeof item === 'string') {
+      parts.push(item)
+    } else if (item && typeof item === 'object') {
+      for (const key in item as Record<string, any>) {
+        const dir = (item as Record<string, any>)[key]
+        parts.push(dir === 'desc' ? `-${key}` : key)
+      }
+    }
+  }
+
+  return parts.join(',')
+}

package/src/query/index.ts

@@ -0,0 +1,2 @@
+export * from './types'
+export * from './compile'