@svgrid/enterprise 2.5.3 → 2.6.1

package/src/sources/aggregate.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { EntitySchema } from '../schema'
-import { aggregateRows, chartFieldsFromSchema } from './aggregate'
-
-const rows = [
-  { id: 1, tier: 'pro', mrr: 100, active: true },
-  { id: 2, tier: 'pro', mrr: 300, active: true },
-  { id: 3, tier: 'free', mrr: 0, active: false },
-  { id: 4, tier: 'enterprise', mrr: 1000, active: true },
-]
-
-describe('aggregateRows', () => {
-  it('sums a measure by dimension, sorted desc', () => {
-    expect(aggregateRows(rows, { dimension: 'tier', measure: 'mrr', reduce: 'sum' })).toEqual([
-      { category: 'enterprise', value: 1000 },
-      { category: 'pro', value: 400 },
-      { category: 'free', value: 0 },
-    ])
-  })
-
-  it('counts rows per dimension (measure ignored); ties keep insertion order', () => {
-    expect(aggregateRows(rows, { dimension: 'tier', reduce: 'count' })).toEqual([
-      { category: 'pro', value: 2 },
-      { category: 'free', value: 1 },
-      { category: 'enterprise', value: 1 },
-    ])
-  })
-
-  it('averages, and handles min / max', () => {
-    expect(aggregateRows(rows, { dimension: 'tier', measure: 'mrr', reduce: 'avg' }).find((b) => b.category === 'pro')).toEqual({ category: 'pro', value: 200 })
-    expect(aggregateRows(rows, { dimension: 'tier', measure: 'mrr', reduce: 'max' }).find((b) => b.category === 'pro')).toEqual({ category: 'pro', value: 300 })
-    expect(aggregateRows(rows, { dimension: 'tier', measure: 'mrr', reduce: 'min' }).find((b) => b.category === 'pro')).toEqual({ category: 'pro', value: 100 })
-  })
-
-  it('groups a boolean dimension', () => {
-    const out = aggregateRows(rows, { dimension: 'active', reduce: 'count' })
-    expect(out).toEqual([{ category: 'true', value: 3 }, { category: 'false', value: 1 }])
-  })
-
-  it('with no dimension, returns a single grand-total bucket (a KPI)', () => {
-    expect(aggregateRows(rows, { reduce: 'count' })).toEqual([{ category: '', value: 4 }])
-    expect(aggregateRows(rows, { measure: 'mrr', reduce: 'sum' })).toEqual([{ category: '', value: 1400 }])
-    expect(aggregateRows(rows, { measure: 'mrr', reduce: 'max' })).toEqual([{ category: '', value: 1000 }])
-  })
-})
-
-describe('chartFieldsFromSchema', () => {
-  const schema: EntitySchema = {
-    name: 'customers', idField: 'id',
-    fields: [
-      { field: 'id', type: 'text', primaryKey: true },
-      { field: 'name', type: 'text' },
-      { field: 'tier', type: 'enum', options: [] },
-      { field: 'mrr', type: 'number' },
-      { field: 'seats', type: 'number' },
-      { field: 'active', type: 'boolean' },
-    ],
-  }
-
-  it('classifies dimensions (enum/boolean/text, non-key) and measures (number)', () => {
-    const f = chartFieldsFromSchema(schema)
-    expect(f.dimensions).toEqual(['name', 'tier', 'active'])
-    expect(f.measures).toEqual(['mrr', 'seats'])
-  })
-
-  it('prefers an enum dimension and the first measure as defaults', () => {
-    const f = chartFieldsFromSchema(schema)
-    expect(f.defaultDimension).toBe('tier')
-    expect(f.defaultMeasure).toBe('mrr')
-  })
-
-  it('falls back to boolean then text when there is no enum', () => {
-    const noEnum: EntitySchema = {
-      name: 't', idField: 'id',
-      fields: [{ field: 'id', type: 'text', primaryKey: true }, { field: 'label', type: 'text' }, { field: 'on', type: 'boolean' }],
-    }
-    expect(chartFieldsFromSchema(noEnum).defaultDimension).toBe('on')
-  })
-})

package/src/sources/aggregate.ts

@@ -1,102 +0,0 @@
-/**
- * Aggregation for charts / dashboards: group rows by a dimension and reduce a
- * measure into `{ category, value }` buckets. `aggregateRows` does it in memory;
- * data sources can implement `getAggregate` to push the same shape down to the
- * database (a `GROUP BY`) so it scales past what a page can hold. `SvSchemaChart`
- * consumes either.
- */
-import type { RowData, ServerFilterModel } from '@svgrid/grid'
-import type { EntitySchema } from '../schema'
-
-export type AggregateReduce = 'sum' | 'avg' | 'count' | 'min' | 'max'
-
-export type AggregateRequest = {
-  /**
-   * Field to group by (the chart's category axis). Omit it for a single grand
-   * total (a KPI) - the result is one bucket with an empty `category`.
-   */
-  dimension?: string
-  /** Field to reduce. Ignored for `count`. */
-  measure?: string
-  reduce: AggregateReduce
-  /** Optional filter, same shape the grid emits. */
-  filterModel?: ServerFilterModel
-}
-
-export type AggregateBucket = { category: string; value: number }
-
-/** A data source that can aggregate server-side (e.g. a SQL `GROUP BY`). */
-export type AggregateSource = {
-  getAggregate(request: AggregateRequest): Promise<AggregateBucket[]>
-}
-
-const num = (v: unknown) => {
-  const n = Number(v)
-  return Number.isFinite(n) ? n : 0
-}
-
-/** Group `rows` by `dimension` and reduce `measure`; sorted by value desc. */
-export function aggregateRows<T extends RowData>(
-  rows: ReadonlyArray<T>,
-  request: AggregateRequest,
-): AggregateBucket[] {
-  const { dimension, measure, reduce } = request
-  const sum = new Map<string, number>()
-  const count = new Map<string, number>()
-  const ext = new Map<string, number>() // running min/max
-
-  for (const row of rows) {
-    // No dimension -> a single grand-total bucket (KPI).
-    const category = dimension ? String(row[dimension] ?? '') : ''
-    count.set(category, (count.get(category) ?? 0) + 1)
-    if (reduce !== 'count') {
-      const v = num(measure ? row[measure] : 0)
-      sum.set(category, (sum.get(category) ?? 0) + v)
-      if (reduce === 'min') ext.set(category, Math.min(ext.get(category) ?? Infinity, v))
-      if (reduce === 'max') ext.set(category, Math.max(ext.get(category) ?? -Infinity, v))
-    }
-  }
-
-  const buckets: AggregateBucket[] = [...count.keys()].map((category) => {
-    const c = count.get(category)!
-    let value: number
-    if (reduce === 'count') value = c
-    else if (reduce === 'avg') value = c ? (sum.get(category) ?? 0) / c : 0
-    else if (reduce === 'min' || reduce === 'max') value = ext.get(category) ?? 0
-    else value = sum.get(category) ?? 0
-    return { category, value }
-  })
-
-  return buckets.sort((a, b) => b.value - a.value)
-}
-
-/**
- * Pick chart-able fields from a schema: **dimensions** to group by (enum /
- * boolean / text, non-key) and **measures** to reduce (number). Defaults favor a
- * low-cardinality dimension (enum, then boolean) and the first numeric measure.
- */
-export function chartFieldsFromSchema(schema: EntitySchema): {
-  dimensions: string[]
-  measures: string[]
-  defaultDimension: string | null
-  defaultMeasure: string | null
-} {
-  const nonKey = schema.fields.filter((f) => !f.primaryKey)
-  const dimensions = nonKey
-    .filter((f) => f.type === 'enum' || f.type === 'boolean' || f.type === 'text')
-    .map((f) => f.field)
-  const measures = nonKey.filter((f) => f.type === 'number').map((f) => f.field)
-
-  const preferred =
-    nonKey.find((f) => f.type === 'enum')?.field ??
-    nonKey.find((f) => f.type === 'boolean')?.field ??
-    dimensions[0] ??
-    null
-
-  return {
-    dimensions,
-    measures,
-    defaultDimension: preferred,
-    defaultMeasure: measures[0] ?? null,
-  }
-}

package/src/sources/auth-supabase.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { createSupabaseAuth, type AuthState } from './auth-supabase'
-
-/** A supabase-js-like auth client with controllable session + spies. */
-function makeClient(initialSession: { user: { id: string; email?: string } } | null = null) {
-  let cb: ((event: string, session: unknown) => void) | undefined
-  const unsubscribe = vi.fn()
-  type AuthResult = { error: { message: string } | null }
-  const ok = async (): Promise<AuthResult> => ({ error: null })
-  const client = {
-    auth: {
-      getSession: vi.fn(async () => ({ data: { session: initialSession } })),
-      onAuthStateChange: vi.fn((fn: (e: string, s: unknown) => void) => {
-        cb = fn
-        return { data: { subscription: { unsubscribe } } }
-      }),
-      signInWithPassword: vi.fn(ok),
-      signUp: vi.fn(ok),
-      signOut: vi.fn(ok),
-    },
-  }
-  return { client, unsubscribe, fire: (session: unknown) => cb?.('x', session) }
-}
-
-const track = () => {
-  const states: AuthState[] = []
-  return { states, onChange: (s: AuthState) => states.push(s) }
-}
-
-describe('createSupabaseAuth', () => {
-  it('resolves the current session on init', async () => {
-    const { client } = makeClient({ user: { id: 'u1', email: 'a@b.co' } })
-    const { states, onChange } = track()
-    createSupabaseAuth({ client, onChange })
-    await vi.waitFor(() => expect(states.at(-1)?.user).toEqual({ id: 'u1', email: 'a@b.co' }))
-    expect(states.at(-1)?.loading).toBe(false)
-  })
-
-  it('starts in a loading, signed-out state', () => {
-    const { client } = makeClient(null)
-    const { states, onChange } = track()
-    createSupabaseAuth({ client, onChange })
-    expect(states[0]).toEqual({ user: null, loading: true, error: null })
-  })
-
-  it('updates when auth state changes (sign in elsewhere)', async () => {
-    const { client, fire } = makeClient(null)
-    const { states, onChange } = track()
-    createSupabaseAuth({ client, onChange })
-    await vi.waitFor(() => expect(states.at(-1)?.loading).toBe(false))
-    fire({ user: { id: 'u2', email: 'x@y.co' } })
-    expect(states.at(-1)?.user).toEqual({ id: 'u2', email: 'x@y.co' })
-  })
-
-  it('signIn calls signInWithPassword and surfaces errors', async () => {
-    const { client } = makeClient(null)
-    client.auth.signInWithPassword.mockResolvedValueOnce({ error: { message: 'bad creds' } })
-    const { states, onChange } = track()
-    const auth = createSupabaseAuth({ client, onChange })
-    await auth.signIn('a@b.co', 'pw')
-    expect(client.auth.signInWithPassword).toHaveBeenCalledWith({ email: 'a@b.co', password: 'pw' })
-    expect(states.at(-1)).toMatchObject({ error: 'bad creds', loading: false })
-  })
-
-  it('signUp and signOut call through', async () => {
-    const { client } = makeClient(null)
-    const auth = createSupabaseAuth({ client, onChange: () => {} })
-    await auth.signUp('a@b.co', 'pw')
-    await auth.signOut()
-    expect(client.auth.signUp).toHaveBeenCalledWith({ email: 'a@b.co', password: 'pw' })
-    expect(client.auth.signOut).toHaveBeenCalled()
-  })
-
-  it('dispose unsubscribes from auth changes', () => {
-    const { client, unsubscribe } = makeClient(null)
-    const auth = createSupabaseAuth({ client, onChange: () => {} })
-    auth.dispose()
-    expect(unsubscribe).toHaveBeenCalled()
-  })
-})

package/src/sources/auth-supabase.ts

@@ -1,87 +0,0 @@
-/**
- * createSupabaseAuth - a tiny reactive controller over Supabase Auth, so a
- * Studio screen can require a signed-in user. You bring the `supabase-js` client
- * (BYO, no dependency); this tracks the session and exposes sign in / up / out.
- * Pair it with `SvAuthGate` to gate the UI, and with Row-Level Security to scope
- * data per user - auth establishes *who*, RLS enforces *what they can see*.
- *
- *     const auth = createSupabaseAuth({ client, onChange: (s) => (authState = s) })
- *     await auth.signIn(email, password)
- *     // ... auth.signOut(); auth.dispose() on unmount
- */
-import { nudgeEnterprise } from '../license'
-
-export type AuthUser = { id: string; email?: string }
-
-export type AuthState = {
-  /** The signed-in user, or null. */
-  user: AuthUser | null
-  /** True during the initial session check or an in-flight auth call. */
-  loading: boolean
-  /** Last auth error message, or null. */
-  error: string | null
-}
-
-type Session = { user: { id: string; email?: string } } | null
-
-/** The slice of a `supabase-js` client's `auth` this needs. */
-export type SupabaseAuthClientLike = {
-  auth: {
-    getSession(): Promise<{ data: { session: Session } }>
-    onAuthStateChange(cb: (event: string, session: Session) => void): {
-      data: { subscription: { unsubscribe(): void } }
-    }
-    signInWithPassword(c: { email: string; password: string }): Promise<{ error: { message: string } | null }>
-    signUp(c: { email: string; password: string }): Promise<{ error: { message: string } | null }>
-    signOut(): Promise<{ error: { message: string } | null }>
-  }
-}
-
-export type SupabaseAuthConfig = {
-  client: SupabaseAuthClientLike
-  onChange: (state: AuthState) => void
-}
-
-export type SupabaseAuthController = {
-  signIn(email: string, password: string): Promise<void>
-  signUp(email: string, password: string): Promise<void>
-  signOut(): Promise<void>
-  getState(): AuthState
-  dispose(): void
-}
-
-const userOf = (session: Session): AuthUser | null =>
-  session?.user ? { id: session.user.id, email: session.user.email } : null
-
-export function createSupabaseAuth(config: SupabaseAuthConfig): SupabaseAuthController {
-  nudgeEnterprise('Studio') // soft-gate; never blocks
-  let state: AuthState = { user: null, loading: true, error: null }
-  const emit = () => config.onChange({ ...state })
-  const set = (patch: Partial<AuthState>) => {
-    state = { ...state, ...patch }
-    emit()
-  }
-
-  emit() // initial loading state
-
-  // Resolve the current session, then keep it in sync.
-  config.client.auth.getSession().then(({ data }) => set({ user: userOf(data.session), loading: false }))
-  const sub = config.client.auth.onAuthStateChange((_event, session) =>
-    set({ user: userOf(session), loading: false }),
-  )
-
-  const run = async (op: () => Promise<{ error: { message: string } | null }>) => {
-    set({ loading: true, error: null })
-    const { error } = await op()
-    // On success the user arrives via onAuthStateChange; just clear loading.
-    set(error ? { loading: false, error: error.message } : { loading: false })
-  }
-
-  return {
-    signIn: (email, password) => run(() => config.client.auth.signInWithPassword({ email, password })),
-    signUp: (email, password) => run(() => config.client.auth.signUp({ email, password })),
-    signOut: () => run(() => config.client.auth.signOut()),
-    getState: () => ({ ...state }),
-    dispose: () => sub.data.subscription.unsubscribe(),
-  }
-}

package/src/sources/dashboard.kpi.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { kpiSeries, sparklinePoints, seriesDelta, formatKpiValue } from './dashboard'
-
-describe('kpiSeries', () => {
-  const rows = [
-    { stage: '2026-01', value: 10 },
-    { stage: '2026-01', value: 5 },
-    { stage: '2026-03', value: 20 },
-    { stage: '2026-02', value: 8 },
-    { stage: '', value: 99 }, // empty bucket key is skipped
-  ]
-  it('buckets by trendField (sorted) and reduces the measure', () => {
-    expect(kpiSeries(rows, { trendField: 'stage', measure: 'value', reduce: 'sum' })).toEqual([15, 8, 20])
-  })
-  it('counts rows per bucket when reduce is count', () => {
-    expect(kpiSeries(rows, { trendField: 'stage', reduce: 'count' })).toEqual([2, 1, 1])
-  })
-})
-
-describe('sparklinePoints', () => {
-  it('maps values into a w x h box with the max at the top', () => {
-    const pts = sparklinePoints([0, 10], 100, 20, 0).split(' ')
-    expect(pts).toHaveLength(2)
-    expect(pts[0]).toBe('0.0,20.0') // min -> bottom
-    expect(pts[1]).toBe('100.0,0.0') // max -> top, last x at width
-  })
-  it('is empty for no data', () => {
-    expect(sparklinePoints([])).toBe('')
-  })
-})
-
-describe('seriesDelta', () => {
-  it('is the percent change from first non-zero to last', () => {
-    expect(seriesDelta([100, 150])).toBe(50)
-    expect(seriesDelta([0, 100, 50])).toBe(-50) // first non-zero is 100, last is 50
-  })
-  it('is null when it cannot be computed', () => {
-    expect(seriesDelta([5])).toBeNull()
-    expect(seriesDelta([0, 0])).toBeNull()
-  })
-})
-
-describe('formatKpiValue', () => {
-  it('formats currency / percent / compact / number', () => {
-    expect(formatKpiValue(1234.5, 'currency')).toBe('$1,235')
-    expect(formatKpiValue(42.5, 'percent')).toBe('42.5%')
-    expect(formatKpiValue(12500, 'compact')).toBe('12.5K')
-    expect(formatKpiValue(1234.5, 'number')).toBe('1,234.5')
-  })
-})

package/src/sources/dashboard.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { EntitySchema } from '../schema'
-import { dashboardFromSchema, reduceValue } from './dashboard'
-
-const rows = [
-  { id: '1', tier: 'pro', mrr: 100 },
-  { id: '2', tier: 'free', mrr: 0 },
-  { id: '3', tier: 'pro', mrr: 300 },
-]
-
-describe('reduceValue', () => {
-  it('counts rows regardless of measure', () => {
-    expect(reduceValue(rows, { reduce: 'count' })).toBe(3)
-    expect(reduceValue(rows, { measure: 'mrr', reduce: 'count' })).toBe(3)
-  })
-  it('sums / averages / min / max a measure', () => {
-    expect(reduceValue(rows, { measure: 'mrr', reduce: 'sum' })).toBe(400)
-    expect(reduceValue(rows, { measure: 'mrr', reduce: 'avg' })).toBeCloseTo(133.33, 1)
-    expect(reduceValue(rows, { measure: 'mrr', reduce: 'min' })).toBe(0)
-    expect(reduceValue(rows, { measure: 'mrr', reduce: 'max' })).toBe(300)
-  })
-  it('is 0 for an empty set', () => {
-    expect(reduceValue([], { measure: 'mrr', reduce: 'sum' })).toBe(0)
-  })
-})
-
-describe('dashboardFromSchema', () => {
-  const schema: EntitySchema = {
-    name: 'customers',
-    label: 'Customer',
-    fields: [
-      { field: 'id', type: 'text', primaryKey: true },
-      { field: 'tier', type: 'enum', options: [{ value: 'free', label: 'Free' }, { value: 'pro', label: 'Pro' }] },
-      { field: 'mrr', type: 'number' },
-    ],
-  }
-
-  it('proposes count + measure KPIs and a chart on the default dimension', () => {
-    const { widgets } = dashboardFromSchema(schema)
-    const kpis = widgets.filter((w) => w.kind === 'kpi')
-    const charts = widgets.filter((w) => w.kind === 'chart')
-    expect(kpis.some((w) => w.reduce === 'count')).toBe(true)
-    expect(kpis.some((w) => w.kind === 'kpi' && w.measure === 'mrr' && w.reduce === 'sum')).toBe(true)
-    expect(charts).toHaveLength(1)
-    expect(charts[0]).toMatchObject({ kind: 'chart', dimension: 'tier', measure: 'mrr' })
-  })
-
-  it('degrades to a count-only dashboard when there is no measure', () => {
-    const noMeasure: EntitySchema = {
-      name: 'tags',
-      fields: [
-        { field: 'id', type: 'text', primaryKey: true },
-        { field: 'kind', type: 'enum', options: [{ value: 'a', label: 'A' }] },
-      ],
-    }
-    const { widgets } = dashboardFromSchema(noMeasure)
-    expect(widgets.filter((w) => w.kind === 'kpi')).toHaveLength(1)
-    const chart = widgets.find((w) => w.kind === 'chart')
-    expect(chart).toMatchObject({ reduce: 'count' })
-  })
-})

package/src/sources/dashboard.ts

@@ -1,136 +0,0 @@
-/**
- * Dashboard model - a declarative, schema-driven set of widgets (KPI tiles +
- * charts) over an entity. This is a *data view*, not a page builder: the spec is
- * plain data, `SvSchemaDashboard` renders it, and `dashboardFromSchema` proposes
- * a sensible default from the schema's chart-able fields. KPI tiles reduce a
- * measure to a single number; charts reuse `SvSchemaChart` (and its `aggregateRows`
- * / `getAggregate` seam), so nothing here re-implements aggregation.
- */
-import type { RowData } from '@svgrid/grid'
-import type { EntitySchema } from '../schema'
-import { chartFieldsFromSchema, type AggregateReduce } from './aggregate'
-import type { ChartType } from '@svgrid/grid'
-
-/** A single-number tile: reduce `measure` over the rows (count ignores measure). */
-export type KpiWidget = {
-  kind: 'kpi'
-  label: string
-  measure?: string
-  reduce: AggregateReduce
-  /** Format the number for display (e.g. currency). */
-  format?: (value: number) => string
-}
-
-/** A chart tile bound to a fixed dimension / measure / reduce / type. */
-export type ChartWidget = {
-  kind: 'chart'
-  label?: string
-  dimension: string
-  measure?: string
-  reduce: AggregateReduce
-  type: ChartType
-  /** Columns spanned in the dashboard grid. Default 1. */
-  span?: 1 | 2 | 3
-}
-
-export type DashboardWidget = KpiWidget | ChartWidget
-
-export type DashboardSpec = { widgets: DashboardWidget[] }
-
-const num = (v: unknown): number => {
-  const n = Number(v)
-  return Number.isFinite(n) ? n : 0
-}
-
-/**
- * Reduce a measure over rows into a single KPI number. `count` returns the row
- * count; `sum`/`avg`/`min`/`max` fold the measure. An empty set is 0.
- */
-export function reduceValue<T extends RowData>(
-  rows: ReadonlyArray<T>,
-  request: { measure?: string; reduce: AggregateReduce },
-): number {
-  const { measure, reduce } = request
-  if (reduce === 'count' || !measure) return rows.length
-  if (rows.length === 0) return 0
-  const values = rows.map((r) => num(r[measure]))
-  if (reduce === 'sum') return values.reduce((a, b) => a + b, 0)
-  if (reduce === 'avg') return values.reduce((a, b) => a + b, 0) / values.length
-  if (reduce === 'min') return Math.min(...values)
-  return Math.max(...values) // 'max'
-}
-
-/**
- * Group rows by `trendField` (sorted, so ISO dates / ordered categories line up)
- * and reduce `measure` per bucket - the series behind a KPI card's sparkline.
- */
-export function kpiSeries<T extends RowData>(
-  rows: ReadonlyArray<T>,
-  opts: { trendField: string; measure?: string; reduce: AggregateReduce },
-): number[] {
-  const groups = new Map<string, T[]>()
-  for (const r of rows) {
-    const k = String(r[opts.trendField] ?? '')
-    if (k === '') continue
-    ;(groups.get(k) ?? groups.set(k, []).get(k)!).push(r)
-  }
-  return [...groups.keys()].sort().map((k) => reduceValue(groups.get(k)!, { measure: opts.measure, reduce: opts.reduce }))
-}
-
-/** SVG polyline points for a sparkline in a `w` x `h` box (y grows downward). */
-export function sparklinePoints(values: number[], w = 120, h = 30, pad = 2): string {
-  if (values.length === 0) return ''
-  const min = Math.min(...values)
-  const range = Math.max(...values) - min || 1
-  const dx = values.length > 1 ? (w - pad * 2) / (values.length - 1) : 0
-  return values
-    .map((v, i) => `${(pad + i * dx).toFixed(1)},${(pad + (h - pad * 2) * (1 - (v - min) / range)).toFixed(1)}`)
-    .join(' ')
-}
-
-/** Percent change from the first non-zero point to the last (null when < 2 points). */
-export function seriesDelta(values: number[]): number | null {
-  if (values.length < 2) return null
-  const first = values.find((v) => v !== 0)
-  const last = values[values.length - 1]!
-  if (first == null || first === 0) return null
-  return ((last - first) / Math.abs(first)) * 100
-}
-
-/** Format a KPI number: currency (`$`), percent (`%`), compact (`1.2k`), or grouped. */
-export function formatKpiValue(value: number, format?: 'number' | 'currency' | 'percent' | 'compact'): string {
-  if (format === 'currency') return '$' + value.toLocaleString(undefined, { maximumFractionDigits: 0 })
-  if (format === 'percent') return value.toLocaleString(undefined, { maximumFractionDigits: 1 }) + '%'
-  if (format === 'compact') return new Intl.NumberFormat(undefined, { notation: 'compact', maximumFractionDigits: 1 }).format(value)
-  return value.toLocaleString(undefined, { maximumFractionDigits: 1 })
-}
-
-/**
- * Propose a default dashboard from a schema: a total-count KPI, a sum/avg KPI on
- * the first numeric measure (when there is one), and a bar chart on the default
- * dimension / measure. Built from `chartFieldsFromSchema`.
- */
-export function dashboardFromSchema(schema: EntitySchema): DashboardSpec {
-  const { defaultDimension, defaultMeasure } = chartFieldsFromSchema(schema)
-  const label = schema.label ?? schema.name
-  const widgets: DashboardWidget[] = [{ kind: 'kpi', label: `Total ${label}`, reduce: 'count' }]
-
-  if (defaultMeasure) {
-    widgets.push({ kind: 'kpi', label: `Total ${defaultMeasure}`, measure: defaultMeasure, reduce: 'sum' })
-    widgets.push({ kind: 'kpi', label: `Avg ${defaultMeasure}`, measure: defaultMeasure, reduce: 'avg' })
-  }
-
-  if (defaultDimension) {
-    widgets.push({
-      kind: 'chart',
-      label: defaultMeasure ? `${defaultMeasure} by ${defaultDimension}` : `Count by ${defaultDimension}`,
-      dimension: defaultDimension,
-      measure: defaultMeasure ?? undefined,
-      reduce: defaultMeasure ? 'sum' : 'count',
-      type: 'bar',
-      span: 2,
-    })
-  }
-
-  return { widgets }
-}

package/src/sources/field-inference.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { refineField } from './field-inference'
-import type { EntityField } from '../schema'
-
-const f = (field: string, type: EntityField['type'] = 'text', extra: Partial<EntityField> = {}): EntityField =>
-  ({ field, type, ...extra })
-
-describe('refineField', () => {
-  it('infers formats + editors from text column names', () => {
-    expect(refineField(f('email')).format).toBe('email')
-    expect(refineField(f('contact_email')).format).toBe('email')
-    expect(refineField(f('website')).format).toBe('url')
-    expect(refineField(f('phone')).input?.editorType).toBe('phone')
-    expect(refineField(f('mobile_number')).input?.editorType).toBe('phone')
-    expect(refineField(f('country')).input?.editorType).toBe('country')
-    expect(refineField(f('brand_color')).input?.editorType).toBe('color')
-  })
-
-  it('masks structured codes with the right pattern', () => {
-    expect(refineField(f('ssn')).input).toMatchObject({ editorType: 'mask', mask: '###-##-####' })
-    expect(refineField(f('vin')).input?.mask).toBe('*****************')
-    expect(refineField(f('license_plate')).input?.mask).toBe('AAA-####')
-    expect(refineField(f('isbn')).input?.mask).toBe('###-#-#####-###-#')
-    expect(refineField(f('zip')).input?.mask).toBe('#####')
-    expect(refineField(f('tax_id')).input?.mask).toBe('##-#######')
-  })
-
-  it('routes password fields to a hidden-from-grid password editor', () => {
-    const r = refineField(f('password'))
-    expect(r.input?.editorType).toBe('password')
-    expect(r.hidden).toEqual({ grid: true })
-  })
-
-  it('infers rating / slider from numeric column names', () => {
-    expect(refineField(f('rating', 'number')).input?.editorType).toBe('rating')
-    expect(refineField(f('csat', 'number')).input?.editorType).toBe('rating')
-    expect(refineField(f('progress', 'number')).input?.editorType).toBe('slider')
-    expect(refineField(f('fuel_level', 'number')).input?.editorType).toBe('slider')
-  })
-
-  it('does NOT add range validation (must not reject existing data)', () => {
-    const r = refineField(f('rating', 'number'))
-    expect(r.min).toBeUndefined()
-    expect(r.max).toBeUndefined()
-  })
-
-  it('leaves keys, relations, enums, and explicit editors untouched', () => {
-    expect(refineField(f('phone', 'text', { primaryKey: true })).input).toBeUndefined()
-    expect(refineField(f('email', 'text', { readonly: true })).format).toBeUndefined()
-    expect(refineField({ field: 'ownerId', type: 'relation', relation: { entity: 'users', labelField: 'name' } }).input).toBeUndefined()
-    expect(refineField(f('country', 'enum', { options: [{ value: 'us', label: 'US' }] })).input).toBeUndefined()
-    const explicit = f('phone', 'text', { input: { editorType: 'mask', mask: '###' } })
-    expect(refineField(explicit).input).toEqual({ editorType: 'mask', mask: '###' })
-  })
-
-  it('leaves an ordinary field alone', () => {
-    expect(refineField(f('description'))).toEqual(f('description'))
-    expect(refineField(f('quantity', 'number'))).toEqual(f('quantity', 'number'))
-  })
-})