@cuboapp/api-backend 3.0.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/api-backend",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Backend Api for CuboApp",
   "main": "src/index.ts",
   "repository": "git@github.com:cuboapp/api-backend.git",

package/src/core/index.ts

@@ -60,11 +60,13 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown =
     // @cuboapp/crdt (и yjs) — опциональная зависимость: грузим лениво только если
     // включён crdt, чтобы проекты без CRDT не тянули yjs.
     if (this.options.crdt?.ws) {
-      let createCrdtServer: typeof import('@cuboapp/crdt')['createCrdtServer']
+      let createCrdtServer: (typeof import('@cuboapp/crdt'))['createCrdtServer']
       try {
         ;({ createCrdtServer } = await import('@cuboapp/crdt'))
       } catch (e) {
-        throw new Error("[API-BACKEND] опция 'crdt' требует пакета '@cuboapp/crdt' (и 'yjs'). Установите их: npm i @cuboapp/crdt @cuboapp/ws yjs")
+        throw new Error(
+          "[API-BACKEND] опция 'crdt' требует пакета '@cuboapp/crdt' (и 'yjs'). Установите их: npm i @cuboapp/crdt @cuboapp/ws yjs"
+        )
       }
 
       this.crdt = new CuboCrdtAdapter<T, A>(this, this.options.crdt.ws, createCrdtServer, this.options.crdt.debug)
@@ -138,6 +140,7 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown =
   ): Promise<CuboCrudGetManyResponse<T[K]>> {
     opts = opts || {}
     req = { ...(req || {}), query: cloneDeep(req?.query || {}) }
+    this.helpers.applyDataFilters(req.query)
 
     const entity = await this.getEntity(entityAlias)
     const augmentation = this.options?.augmentations?.[entityAlias]
@@ -194,6 +197,7 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown =
   ): Promise<T[K] | undefined> {
     opts = opts || {}
     req = { ...(req || {}), query: cloneDeep(req?.query || {}) }
+    this.helpers.applyDataFilters(req.query)
 
     const entity = await this.getEntity(entityAlias)
     const augmentation = this.options?.augmentations?.[entityAlias]
@@ -262,21 +266,30 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown =
     }
 
     const db = await this.helpers.getConnection('write')
-    const [created_id] = await db.create(entity.alias, dto, {
-      transaction: opts.transaction,
-      log: opts.log,
-      pk_key: this.pkKey,
-      pk_type: this.pkType
-    })
-    if (!created_id) {
-      throw { status: 400, text: 'Unable to create entity' }
-    }
 
-    let response = await this.getOne<K>(entityAlias, { query: { id: created_id } }, this.readBackOpts(opts))
-    if (!response) {
-      throw { status: 400, text: 'Unable to find entity after create' }
+    // INSERT + read-back в одной транзакции: getOne-хуки на re-select'е теперь
+    // срабатывают; если beforeGetOne «спрячет» свежесозданную строку (или
+    // afterGetOne вернёт пусто), throw откатит INSERT — без «осиротевшей» записи.
+    const run = async (tx: any): Promise<T[K]> => {
+      const [created_id] = await db.create(entity.alias, dto, {
+        transaction: tx,
+        log: opts!.log,
+        pk_key: this.pkKey,
+        pk_type: this.pkType
+      })
+      if (!created_id) {
+        throw { status: 400, text: 'Unable to create entity' }
+      }
+
+      const created = await this.getOne<K>(entityAlias, { query: { id: created_id } }, this.readBackOpts({ ...opts, transaction: tx }))
+      if (!created) {
+        throw { status: 400, text: 'Unable to find entity after create' }
+      }
+      return created as T[K]
     }
 
+    let response = opts.transaction ? await run(opts.transaction) : await this.withTransaction(run)
+
     if (augmentation?.afterCreate && !this.excluded(opts, 'afterCreate')) {
       response = await augmentation.afterCreate({ ...this.ctx(entity, req, opts, queryOptions), row: response })
     }
@@ -350,18 +363,27 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown =
     }
 
     const db = await this.helpers.getConnection('write')
-    await db.update(entity.alias, 'id = :id', { id: (item as any).id }, dto, {
-      transaction: opts.transaction,
-      log: opts.log,
-      pk_key: this.pkKey,
-      pk_type: this.pkType
-    })
+    const id = (item as any).id
+
+    // UPDATE + read-back в одной транзакции: getOne-хуки на re-select'е теперь
+    // срабатывают; если они «спрячут» обновлённую строку, throw откатит UPDATE.
+    const run = async (tx: any): Promise<T[K]> => {
+      await db.update(entity.alias, 'id = :id', { id }, dto, {
+        transaction: tx,
+        log: opts!.log,
+        pk_key: this.pkKey,
+        pk_type: this.pkType
+      })
 
-    let response = await this.getOne<K>(entityAlias, { query: { id: (item as any).id } }, this.readBackOpts(opts))
-    if (!response) {
-      throw { status: 400, text: 'Unable to find entity after update' }
+      const updated = await this.getOne<K>(entityAlias, { query: { id } }, this.readBackOpts({ ...opts, transaction: tx }))
+      if (!updated) {
+        throw { status: 400, text: 'Unable to find entity after update' }
+      }
+      return updated as T[K]
     }
 
+    let response = opts.transaction ? await run(opts.transaction) : await this.withTransaction(run)
+
     if (augmentation?.afterUpdate && !this.excluded(opts, 'afterUpdate')) {
       response = await augmentation.afterUpdate({ ...this.ctx(entity, req, opts, queryOptions), row: response, prev: prev as T[K] })
     }
@@ -410,12 +432,17 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown =
     }
 
     const db = await this.helpers.getConnection('write')
-    await db.update(entity.alias, 'id = :id', { id: (item as any).id }, dto, {
-      transaction: opts.transaction,
-      log: opts.log,
-      pk_key: this.pkKey,
-      pk_type: this.pkType
-    })
+    const id = (item as any).id
+
+    const runDelete = (tx: any) =>
+      db.update(entity.alias, 'id = :id', { id }, dto, {
+        transaction: tx,
+        log: opts!.log,
+        pk_key: this.pkKey,
+        pk_type: this.pkType
+      })
+
+    await (opts.transaction ? runDelete(opts.transaction) : this.withTransaction(runDelete))
 
     if (this.options.hooks?.onAfterDelete && !this.excluded(opts, 'baseHooks')) {
       await this.options.hooks.onAfterDelete(entity, item as T[K], opts)
@@ -608,14 +635,20 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown =
     return this.helpers.getConnection(opts.transaction ? 'write' : 'read')
   }
 
-  /** Опции для внутренних read-back'ов: без наследования queryOptions и без хуков чтения. */
+  /**
+   * Опции для внутренних read-back'ов: без наследования queryOptions.
+   * getOne-хуки чтения (beforeGetOne/afterGetOne) ВКЛЮЧЕНЫ — они должны срабатывать
+   * на select/re-select внутри createOne/updateOne/deleteOne (запись+read-back идут
+   * в одной транзакции, поэтому «спрятавший» строку beforeGetOne откатит запись).
+   * getMany-хуки подавляются — они нужны только для batch read-back'ов.
+   */
   private readBackOpts(opts: CuboCrudMethodOptions): CuboCrudMethodOptions {
     return {
       transaction: opts.transaction,
       performer_id: opts.performer_id,
       auth: opts.auth,
       log: opts.log,
-      excludeHooks: ['beforeGetOne', 'afterGetOne', 'beforeGetMany', 'afterGetMany']
+      excludeHooks: ['beforeGetMany', 'afterGetMany']
     }
   }
 
@@ -664,11 +697,18 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown =
     const replacements: Record<string, any> = {}
 
     const valuesSql = dtos
-      .map((dto, i) => '(' + cols.map((c) => {
-        const key = `b_${i}_${c}`
-        replacements[key] = dto[c] ?? null
-        return `:${key}`
-      }).join(', ') + ')')
+      .map(
+        (dto, i) =>
+          '(' +
+          cols
+            .map((c) => {
+              const key = `b_${i}_${c}`
+              replacements[key] = dto[c] ?? null
+              return `:${key}`
+            })
+            .join(', ') +
+          ')'
+      )
       .join(', ')
 
     let sql = `insert into ${entity.alias} (${cols.join(', ')}) values ${valuesSql}`

package/src/helpers/index.ts

@@ -13,7 +13,7 @@ import {
   CUBO_CRUD_QUERY_SYMBOL_NOT
 } from '../constants'
 import { CuboDialect, getDialect } from '../dialects'
-import { CuboBackendApiDbConnectionType, CuboCrudFindQuery, CuboCrudRequest } from '../types'
+import { CuboBackendApiDbConnectionType, CuboCrudFindQuery, CuboCrudRequest, CuboDataFilter, CuboDataFiltersQuery } from '../types'
 
 import { ApiHelpersConvert } from './convert'
 import { ApiHelpersData } from './data'
@@ -316,6 +316,106 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>, A = unknown> {
     }
   }
 
+  /**
+   * Разворачивает структурный query-параметр `filters` (JSON вида
+   * `{"filters":[{"field","op","value"}],"sort":[{"field","dir"}]}`) в обычные
+   * flat-DSL записи `req.query`. Дальше их подхватывает общий пайплайн
+   * (createFindQuery + withes): вложенные связи по dot-notation, приведение типов
+   * и сортировка работают без дополнительного кода. Мутирует и возвращает `query`.
+   *
+   * Ограничения наследуются от flat-DSL: одно условие на поле (при нескольких
+   * фильтрах на одно поле побеждает последний) и значения без `:` (двоеточие —
+   * разделитель условий). Для экзотики — `queryOptions.raw`.
+   */
+  public applyDataFilters(query: Record<string, any>): Record<string, any> {
+    const raw = query?.filters
+    if (raw === undefined || raw === null || raw === '') {
+      return query
+    }
+
+    let parsed: CuboDataFiltersQuery
+    try {
+      parsed = typeof raw === 'string' ? JSON.parse(raw) : raw
+    } catch {
+      throw { status: 400, text: 'Invalid "filters" query param: must be valid JSON' }
+    }
+
+    // убираем сырой ключ, чтобы пайплайн не принял "filters" за поле-условие
+    delete query.filters
+
+    for (const filter of parsed?.filters || []) {
+      if (!filter || !filter.field) {
+        continue
+      }
+
+      const value = this.dataFilterToQueryValue(filter)
+      if (value !== undefined) {
+        query[filter.field] = value
+      }
+    }
+
+    if (parsed?.sort?.length) {
+      const sort = parsed.sort
+        .filter((s) => s && s.field)
+        .map((s) => (s.dir === 'desc' ? '-' : '') + s.field)
+        .join(',')
+
+      if (sort) {
+        query.sort = sort
+      }
+    }
+
+    return query
+  }
+
+  /** Маппинг `CuboDataFilter.op` -> flat-DSL значение движка (`ilike:foo`, `not:gt:5`, `in:1,2`, ...). */
+  private dataFilterToQueryValue(filter: CuboDataFilter): string | undefined {
+    const C = CUBO_CRUD_QUERY_CONDITION
+    const NOT = CUBO_CRUD_QUERY_SYMBOL_NOT
+    const v = filter.value
+    const list = () => (Array.isArray(v) ? v.join(',') : `${v}`)
+
+    switch (filter.op) {
+      case 'eq':
+        return `${v}`
+      case 'ne':
+        return `${NOT}:${v}`
+      case 'contains':
+        return `${C.ILIKE}:${v}`
+      case 'notContains':
+        return `${NOT}:${C.ILIKE}:${v}`
+      case 'like':
+        return `${C.LIKE}:${v}`
+      case 'ilike':
+        return `${C.ILIKE}:${v}`
+      case 'gt':
+        return `${C.GT}:${v}`
+      case 'gte':
+        return `${C.GTE}:${v}`
+      case 'lt':
+        return `${C.LT}:${v}`
+      case 'lte':
+        return `${C.LTE}:${v}`
+      case 'in':
+        return `${C.IN}:${list()}`
+      case 'nin':
+        return `${C.NIN}:${list()}`
+      case 'between': {
+        const [from, to] = Array.isArray(v) ? v : `${v}`.split(':')
+        if (from === undefined || to === undefined) {
+          throw { status: 400, text: `Filter "${filter.field}": "between" requires [from, to]` }
+        }
+        return `${C.BTW}:${from}:${to}`
+      }
+      case 'isNull':
+        return 'null'
+      case 'isNotNull':
+        return `${NOT}:null`
+      default:
+        throw { status: 400, text: `Unsupported filter op "${(filter as any).op}" for "${filter.field}"` }
+    }
+  }
+
   public async dropConnection(type: CuboBackendApiDbConnectionType) {
     if (this.connections[type]) {
       await this.connections[type].disconnect()

package/src/types/filters.ts

@@ -0,0 +1,50 @@
+/**
+ * Структурированные фильтры из query-параметра `filters` (передаётся JSON-строкой).
+ * Формат совместим со слоем data-view в @cuboapp/ui: массив `{ field, op, value }`
+ * + сортировка `{ field, dir }`.
+ *
+ * Пример query-параметра (URL-encoded):
+ *   filters={"filters":[{"field":"name","op":"contains","value":"asdf"}],"sort":[{"field":"name","dir":"asc"}]}
+ *
+ * Транслируется в существующий flat-DSL движка (см. `ApiHelpers.applyDataFilters`),
+ * поэтому работает и для вложенных полей (dot-notation, напр. `company.name`), и с
+ * тем же приведением типов, что и обычные query-условия.
+ */
+
+export type CuboDataFilterOp =
+  | 'eq'
+  | 'ne'
+  | 'contains'
+  | 'notContains'
+  | 'like'
+  | 'ilike'
+  | 'gt'
+  | 'gte'
+  | 'lt'
+  | 'lte'
+  | 'in'
+  | 'nin'
+  | 'between'
+  | 'isNull'
+  | 'isNotNull'
+
+export type CuboDataFilter = {
+  /** Имя поля; поддерживается dot-notation для вложенных связей (`company.name`). */
+  field: string
+  op: CuboDataFilterOp
+  /** Значение условия. Для `in`/`nin` — массив, для `between` — `[from, to]`, для `isNull`/`isNotNull` — игнорируется. */
+  value?: any
+}
+
+export type CuboDataSortDir = 'asc' | 'desc'
+
+export type CuboDataSort = {
+  field: string
+  dir?: CuboDataSortDir
+}
+
+/** Полезная нагрузка query-параметра `filters`. */
+export type CuboDataFiltersQuery = {
+  filters?: CuboDataFilter[]
+  sort?: CuboDataSort[]
+}

package/src/types/index.ts

@@ -8,6 +8,7 @@ import { CuboCrudMethodOptions } from './db'
 
 export * from './basic'
 export * from './db'
+export * from './filters'
 
 export type CuboBackendApiOptions<T extends CuboApiEntitiesMap<T>, A> = {
   api?: {