@veltra/sheet 2.3.4 → 2.5.0

package/src/report/__test__/rules.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  evaluateCondition,
-  evaluateConditionalStyle,
-  resolveRuleCompareValue,
-  type ConditionalEvalContext
-} from '../rules'
-import type { ConditionalRule } from '../types'
-
-function rule(
-  operator: ConditionalRule['operator'],
-  value: unknown,
-  style: ConditionalRule['style'],
-  extra?: Partial<ConditionalRule>
-): ConditionalRule {
-  return { operator, value, style, ...extra }
-}
-
-function ctx(
-  cellValue: unknown,
-  record?: Record<string, unknown>,
-  bindingField = 'amount'
-): ConditionalEvalContext {
-  return { cellValue, bindingField, record }
-}
-
-describe('report rules', () => {
-  describe('evaluateCondition', () => {
-    it('数值比较运算符', () => {
-      expect(evaluateCondition(150, rule('gt', 100, {}))).toBe(true)
-      expect(evaluateCondition(100, rule('gt', 100, {}))).toBe(false)
-      expect(evaluateCondition(100, rule('gte', 100, {}))).toBe(true)
-      expect(evaluateCondition(99, rule('lt', 100, {}))).toBe(true)
-      expect(evaluateCondition(100, rule('lte', 100, {}))).toBe(true)
-      expect(evaluateCondition(42, rule('eq', 42, {}))).toBe(true)
-      expect(evaluateCondition('42', rule('eq', 42, {}))).toBe(true)
-    })
-
-    it('between 含端点范围比较', () => {
-      const between = rule('between', [100, 200], {})
-      expect(evaluateCondition(100, between)).toBe(true)
-      expect(evaluateCondition(200, between)).toBe(true)
-      expect(evaluateCondition(150, between)).toBe(true)
-      expect(evaluateCondition(99, between)).toBe(false)
-      expect(evaluateCondition(201, between)).toBe(false)
-    })
-
-    it('contains 字符串包含', () => {
-      expect(evaluateCondition('华东-上海', rule('contains', '上海', {}))).toBe(true)
-      expect(evaluateCondition('华北', rule('contains', '上海', {}))).toBe(false)
-      expect(evaluateCondition(null, rule('contains', 'x', {}))).toBe(false)
-    })
-
-    it('非数值比较在 gt 等运算符下返回 false', () => {
-      expect(evaluateCondition('abc', rule('gt', 1, {}))).toBe(false)
-    })
-  })
-
-  describe('resolveRuleCompareValue', () => {
-    it('缺省 field 时取 cellValue', () => {
-      const context = ctx(150, { amount: 150, region: '华东' })
-      expect(resolveRuleCompareValue(context, rule('gt', 100, {}))).toBe(150)
-    })
-
-    it('指定 field 时取同记录另一字段', () => {
-      const context = ctx(150, { amount: 150, region: '华东' })
-      expect(resolveRuleCompareValue(context, rule('eq', '华东', {}, { field: 'region' }))).toBe(
-        '华东'
-      )
-    })
-  })
-
-  describe('evaluateConditionalStyle', () => {
-    const baseStyle = { fill: { color: '#FFFFFF' }, font: { color: '#000000' } }
-
-    it('未命中规则时原样返回 baseStyle', () => {
-      const rules = [rule('gt', 1000, { fill: { color: '#FF0000' } })]
-      expect(evaluateConditionalStyle(ctx(50), baseStyle, rules)).toBe(baseStyle)
-    })
-
-    it('命中单条规则时叠加样式增量', () => {
-      const rules = [rule('gt', 100, { fill: { color: '#FFCCCC' }, font: { bold: true } })]
-      expect(evaluateConditionalStyle(ctx(150), baseStyle, rules)).toEqual({
-        fill: { color: '#FFCCCC' },
-        font: { color: '#000000', bold: true }
-      })
-    })
-
-    it('跨字段求值命中时叠加样式', () => {
-      const rules = [rule('eq', '华东', { fill: { color: '#FFCCCC' } }, { field: 'region' })]
-      const context = ctx(100, { amount: 100, region: '华东' })
-      expect(evaluateConditionalStyle(context, baseStyle, rules)?.fill?.color).toBe('#FFCCCC')
-    })
-
-    it('scope: row 仅评估行级规则', () => {
-      const rules = [
-        rule('gt', 100, { fill: { color: '#FFCCCC' } }, { scope: 'row' }),
-        rule('gt', 100, { font: { bold: true } })
-      ]
-      expect(evaluateConditionalStyle(ctx(150), baseStyle, rules, 'row')?.fill?.color).toBe(
-        '#FFCCCC'
-      )
-      expect(evaluateConditionalStyle(ctx(150), baseStyle, rules, 'cell')?.font?.bold).toBe(true)
-      expect(evaluateConditionalStyle(ctx(150), baseStyle, rules, 'cell')?.fill?.color).toBe(
-        '#FFFFFF'
-      )
-    })
-
-    it('多规则按优先级合并，后命中规则覆盖同名字段', () => {
-      const rules = [
-        rule('gt', 0, { fill: { color: '#FFFFCC' } }),
-        rule('gt', 100, { fill: { color: '#FFCCCC' }, font: { bold: true } }),
-        rule('gt', 200, { font: { color: '#FF0000' } })
-      ]
-
-      const style150 = evaluateConditionalStyle(ctx(150), baseStyle, rules)
-      expect(style150?.fill?.color).toBe('#FFCCCC')
-      expect(style150?.font).toEqual({ color: '#000000', bold: true })
-
-      const style250 = evaluateConditionalStyle(ctx(250), baseStyle, rules)
-      expect(style250?.fill?.color).toBe('#FFCCCC')
-      expect(style250?.font).toEqual({ color: '#FF0000', bold: true })
-    })
-
-    it('无规则或未传规则时返回 baseStyle', () => {
-      expect(evaluateConditionalStyle(ctx(100), baseStyle, undefined)).toBe(baseStyle)
-      expect(evaluateConditionalStyle(ctx(100), baseStyle, [])).toBe(baseStyle)
-    })
-  })
-})

package/src/report/__test__/template.test.ts

@@ -1,366 +0,0 @@
-import { Sheet } from '@veltra/sheet-core'
-import { describe, expect, it } from 'vitest'
-
-import { REPORT_META_NAMESPACE } from '../binding'
-import type { DataConnection, DataConnector } from '../connector'
-import {
-  assertCompatibleTemplateVersion,
-  createReportTemplate,
-  fetchTemplateRecords,
-  getBoundDatasetIds,
-  getTemplateDatasets,
-  IncompatibleTemplateVersionError,
-  REPORT_TEMPLATE_VERSION,
-  resolveParamDefaults,
-  resolveTemplateParams,
-  type ReportDatasetDef,
-  type ReportTemplate
-} from '../template'
-import type { ParamValues, ReportBinding } from '../types'
-
-// ---- 内联 fixtures ----
-
-const MYSQL: DataConnection = {
-  id: 'c-mysql',
-  label: '本地 MySQL',
-  type: 'mysql',
-  host: '127.0.0.1',
-  port: 3306,
-  database: 'demo',
-  username: 'root',
-  password: 'secret'
-}
-
-const PG: DataConnection = {
-  ...MYSQL,
-  id: 'c-pg',
-  label: '本地 PG',
-  type: 'postgresql',
-  port: 5432
-}
-
-// BETWEEN ${dateRange} 置于 SQL 末尾：后随 AND 时不会推断为 date-range（params.ts 既有推断规则）
-const ORDERS_SQL =
-  'SELECT customer, region, amount, orderDate FROM orders ' +
-  'WHERE region = ${region} AND amount >= ${minAmount} ' +
-  'AND customer LIKE ${keyword} AND orderDate BETWEEN ${dateRange}'
-
-const CUSTOMERS_SQL = 'SELECT id, region FROM customers WHERE region = ${region}'
-
-const ORDERS_DATASET: ReportDatasetDef = {
-  id: 'orders',
-  label: '销售明细',
-  connection: MYSQL,
-  sql: ORDERS_SQL
-}
-
-const CUSTOMERS_DATASET: ReportDatasetDef = {
-  id: 'customers',
-  label: '客户',
-  connection: PG,
-  sql: CUSTOMERS_SQL,
-  paramOverrides: {
-    region: {
-      label: '地区',
-      type: 'select',
-      defaultValue: '华东',
-      options: [
-        { label: '华东', value: '华东' },
-        { label: '华南', value: '华南' }
-      ]
-    }
-  }
-}
-
-const UNUSED_DATASET: ReportDatasetDef = {
-  id: 'unused',
-  label: '未绑定',
-  connection: MYSQL,
-  sql: 'SELECT id FROM t WHERE x = ${unusedParam}'
-}
-
-function binding(dataset: string, field: string): ReportBinding {
-  return { dataset, field, aggregate: 'list', expand: 'down', preset: 'detail' }
-}
-
-/** 构造自包含 Report Template：SheetSnapshot + 内嵌数据集定义 */
-function createTemplate(
-  datasets: ReportDatasetDef[],
-  bindings: Array<{ row: number; col: number; dataset: string; field: string }>
-): ReportTemplate {
-  const sheet = new Sheet()
-  for (const item of bindings) {
-    sheet.setCellMeta(
-      { row: item.row, col: item.col },
-      REPORT_META_NAMESPACE,
-      binding(item.dataset, item.field)
-    )
-  }
-  return createReportTemplate(sheet.snapshot(), datasets)
-}
-
-describe('ReportTemplate version', () => {
-  it('createReportTemplate 写入当前版本', () => {
-    const template = createTemplate([ORDERS_DATASET], [])
-    expect(template.version).toBe(REPORT_TEMPLATE_VERSION)
-  })
-
-  it('createReportTemplate 继承 snapshot.colWidths', () => {
-    const sheet = new Sheet()
-    sheet.setColWidth(0, 120)
-    sheet.setColWidth(2, 90)
-    const template = createReportTemplate(sheet.snapshot(), [ORDERS_DATASET])
-    expect(template.colWidths).toEqual([
-      [0, 120],
-      [2, 90]
-    ])
-  })
-
-  it('version 缺失时 assertCompatibleTemplateVersion 抛可读错误', () => {
-    const sheet = new Sheet()
-    const template = sheet.snapshot() as ReportTemplate
-    expect(() => assertCompatibleTemplateVersion(template)).toThrow(
-      IncompatibleTemplateVersionError
-    )
-    expect(() => assertCompatibleTemplateVersion(template)).toThrow(/缺少 version/)
-  })
-
-  it('version 高于当前支持时 assertCompatibleTemplateVersion 抛可读错误', () => {
-    const template = createTemplate([ORDERS_DATASET], [])
-    template.version = REPORT_TEMPLATE_VERSION + 1
-    expect(() => assertCompatibleTemplateVersion(template)).toThrow(
-      IncompatibleTemplateVersionError
-    )
-    expect(() => assertCompatibleTemplateVersion(template)).toThrow(/高于当前支持/)
-  })
-
-  it('version 为当前值时通过校验', () => {
-    const template = createTemplate([ORDERS_DATASET], [])
-    expect(() => assertCompatibleTemplateVersion(template)).not.toThrow()
-  })
-})
-
-describe('getTemplateDatasets', () => {
-  it('返回模板内嵌的数据集定义', () => {
-    const template = createTemplate([ORDERS_DATASET], [])
-    expect(getTemplateDatasets(template)).toEqual([ORDERS_DATASET])
-  })
-
-  it('未内嵌数据集（旧模板）回退为空数组', () => {
-    const sheet = new Sheet()
-    const template = sheet.snapshot() as ReportTemplate
-    expect(getTemplateDatasets(template)).toEqual([])
-  })
-})
-
-describe('getBoundDatasetIds', () => {
-  it('按绑定出现顺序返回去重的数据集 id（绑定即真相）', () => {
-    const template = createTemplate(
-      [],
-      [
-        { row: 1, col: 0, dataset: 'orders', field: 'customer' },
-        { row: 1, col: 1, dataset: 'orders', field: 'amount' },
-        { row: 2, col: 0, dataset: 'customers', field: 'region' }
-      ]
-    )
-    expect(getBoundDatasetIds(template)).toEqual(['orders', 'customers'])
-  })
-
-  it('无绑定时返回空数组', () => {
-    expect(getBoundDatasetIds(createTemplate([], []))).toEqual([])
-  })
-})
-
-describe('resolveTemplateParams', () => {
-  it('从实际绑定的数据集提取参数并集（未绑定数据集的参数不出现）', () => {
-    const template = createTemplate(
-      [ORDERS_DATASET, CUSTOMERS_DATASET, UNUSED_DATASET],
-      [
-        { row: 1, col: 0, dataset: 'orders', field: 'customer' },
-        { row: 2, col: 0, dataset: 'customers', field: 'region' }
-      ]
-    )
-    const params = resolveTemplateParams(template)
-    expect(params.map((p) => p.id)).toEqual(['region', 'minAmount', 'keyword', 'dateRange'])
-  })
-
-  it('按 SQL 上下文推断控件类型（= 数值 / LIKE 文本 / BETWEEN 单参 date-range）', () => {
-    const template = createTemplate(
-      [ORDERS_DATASET],
-      [{ row: 1, col: 0, dataset: 'orders', field: 'customer' }]
-    )
-    const params = resolveTemplateParams(template)
-    const byId = new Map(params.map((p) => [p.id, p]))
-    expect(byId.get('region')?.type).toBe('number')
-    expect(byId.get('minAmount')?.type).toBe('number')
-    expect(byId.get('dateRange')?.type).toBe('date-range')
-    expect(byId.get('keyword')?.type).toBe('text')
-  })
-
-  it('同名参数合并，先见数据集为准', () => {
-    const ordersFirst = createTemplate(
-      [ORDERS_DATASET, CUSTOMERS_DATASET],
-      [
-        { row: 1, col: 0, dataset: 'orders', field: 'customer' },
-        { row: 2, col: 0, dataset: 'customers', field: 'region' }
-      ]
-    )
-    const region = resolveTemplateParams(ordersFirst).find((p) => p.id === 'region')
-    // orders 先见：无覆盖元数据，label 回退 id、类型按 orders SQL 推断
-    expect(region?.label).toBe('region')
-    expect(region?.type).toBe('number')
-  })
-
-  it('应用数据集参数元数据覆盖（label / 类型 / 默认值 / 选项）', () => {
-    const template = createTemplate(
-      [CUSTOMERS_DATASET],
-      [{ row: 1, col: 0, dataset: 'customers', field: 'region' }]
-    )
-    const [region] = resolveTemplateParams(template)
-    expect(region).toEqual({
-      id: 'region',
-      label: '地区',
-      type: 'select',
-      defaultValue: '华东',
-      options: [
-        { label: '华东', value: '华东' },
-        { label: '华南', value: '华南' }
-      ]
-    })
-  })
-
-  it('绑定引用了模板未定义的数据集时跳过该数据集', () => {
-    const template = createTemplate(
-      [],
-      [
-        { row: 1, col: 0, dataset: 'ghost', field: 'x' },
-        { row: 1, col: 1, dataset: 'orders', field: 'amount' }
-      ]
-    )
-    // orders 未内嵌 → 也无参数；整体为空
-    expect(resolveTemplateParams(template)).toEqual([])
-
-    const withOrders = createTemplate(
-      [ORDERS_DATASET],
-      [
-        { row: 1, col: 0, dataset: 'ghost', field: 'x' },
-        { row: 1, col: 1, dataset: 'orders', field: 'amount' }
-      ]
-    )
-    expect(resolveTemplateParams(withOrders).map((p) => p.id)).toEqual([
-      'region',
-      'minAmount',
-      'keyword',
-      'dateRange'
-    ])
-  })
-})
-
-describe('resolveParamDefaults', () => {
-  it('以参数默认值生成初始运行时值', () => {
-    const template = createTemplate(
-      [ORDERS_DATASET, CUSTOMERS_DATASET],
-      [
-        { row: 1, col: 0, dataset: 'customers', field: 'region' },
-        { row: 2, col: 0, dataset: 'orders', field: 'amount' }
-      ]
-    )
-    const values = resolveParamDefaults(resolveTemplateParams(template))
-    expect(values.region).toBe('华东')
-    expect(values.minAmount).toBe(0)
-    expect(values.dateRange).toEqual(['', ''])
-    expect(values.keyword).toBe('')
-  })
-})
-
-// ---- fetchTemplateRecords（stub connector：实现 DataConnector 接口的内存测试夹具）----
-
-function createStubConnector(handlers: {
-  rowsBySql?: Record<string, Record<string, unknown>[]>
-  errorBySql?: Record<string, { code: string; message: string }>
-}) {
-  const calls: Array<{ connection: DataConnection; sql: string; values: ParamValues }> = []
-  const connector: DataConnector = {
-    test: () => Promise.resolve({ ok: true, data: undefined }),
-    describe: () => Promise.resolve({ ok: true, data: [] }),
-    query: (connection, sql, values) => {
-      calls.push({ connection, sql, values })
-      const error = handlers.errorBySql?.[sql]
-      if (error) return Promise.resolve({ ok: false, error })
-      return Promise.resolve({
-        ok: true,
-        data: { fields: [], rows: handlers.rowsBySql?.[sql] ?? [] }
-      })
-    }
-  }
-  return { connector, calls }
-}
-
-describe('fetchTemplateRecords', () => {
-  it('按绑定的数据集逐一经连接器取数并按数据集 id 折叠行记录', async () => {
-    const template = createTemplate(
-      [ORDERS_DATASET, CUSTOMERS_DATASET, UNUSED_DATASET],
-      [
-        { row: 1, col: 0, dataset: 'orders', field: 'customer' },
-        { row: 2, col: 0, dataset: 'customers', field: 'region' }
-      ]
-    )
-    const { connector, calls } = createStubConnector({
-      rowsBySql: {
-        [ORDERS_SQL]: [{ customer: '甲公司', amount: 100 }],
-        [CUSTOMERS_SQL]: [{ id: 'C-01', region: '华东' }]
-      }
-    })
-    const values: ParamValues = { region: '华东' }
-    const result = await fetchTemplateRecords(connector, template, values)
-
-    expect(result).toEqual({
-      ok: true,
-      data: {
-        orders: [{ customer: '甲公司', amount: 100 }],
-        customers: [{ id: 'C-01', region: '华东' }]
-      }
-    })
-    // 未绑定的数据集不取数；连接对象与参数原样透传
-    expect(calls).toHaveLength(2)
-    expect(calls[0]).toEqual({ connection: MYSQL, sql: ORDERS_SQL, values })
-    expect(calls[1]).toEqual({ connection: PG, sql: CUSTOMERS_SQL, values })
-  })
-
-  it('业务错误（ok:false）原样透传', async () => {
-    const template = createTemplate(
-      [ORDERS_DATASET],
-      [{ row: 1, col: 0, dataset: 'orders', field: 'customer' }]
-    )
-    const { connector } = createStubConnector({
-      errorBySql: { [ORDERS_SQL]: { code: 'SQL_ERROR', message: '语法错误 near WHERE' } }
-    })
-    const result = await fetchTemplateRecords(connector, template, {})
-    expect(result).toEqual({
-      ok: false,
-      error: { code: 'SQL_ERROR', message: '语法错误 near WHERE' }
-    })
-  })
-
-  it('跳过模板未定义的绑定数据集', async () => {
-    const template = createTemplate(
-      [ORDERS_DATASET],
-      [
-        { row: 1, col: 0, dataset: 'ghost', field: 'x' },
-        { row: 1, col: 1, dataset: 'orders', field: 'amount' }
-      ]
-    )
-    const { connector, calls } = createStubConnector({ rowsBySql: { [ORDERS_SQL]: [] } })
-    const result = await fetchTemplateRecords(connector, template, {})
-    expect(result).toEqual({ ok: true, data: { orders: [] } })
-    expect(calls).toHaveLength(1)
-  })
-
-  it('无绑定数据集时不取数，返回空记录集', async () => {
-    const template = createTemplate([ORDERS_DATASET], [])
-    const { connector, calls } = createStubConnector({})
-    const result = await fetchTemplateRecords(connector, template, {})
-    expect(result).toEqual({ ok: true, data: {} })
-    expect(calls).toHaveLength(0)
-  })
-})