@svgrid/enterprise 2.3.0 → 2.3.2

package/src/ai-export-xlsx.dom.test.ts

@@ -1,90 +1,90 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Real exportGrid runs (NOT mocked). Capture the xlsx parts / avoid the DOM.
-const captured: { parts: Record<string, string> } = { parts: {} }
-vi.mock('jszip', () => ({
-  default: class {
-    file(p: string, d: string) {
-      captured.parts[p] = d
-    }
-    async generateAsync() {
-      return new Blob([])
-    }
-  },
-}))
-vi.mock('./export-serialize', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>
-  return { ...actual, downloadBlobFile: () => {}, downloadTextFile: () => {} }
-})
-
-import { aiExport, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
-import { exportGrid } from './export'
-import { setLicenseKey } from './license'
-
-// Mirrors the real makeOrders shape - crucially includes `inStock` (boolean)
-// and `quantity`/`index` (numbers that never exceed 300), so the mock must
-// target `price` for "$300", not a boolean or a count.
-type Order = {
-  id: string
-  index: number
-  country: string
-  company: string
-  product: string
-  inStock: boolean
-  quantity: number
-  price: number
-}
-const rows: Order[] = Array.from({ length: 120 }, (_, i) => ({
-  id: `o${i}`,
-  index: i + 1,
-  country: ['USA', 'UK', 'Germany'][i % 3]!,
-  company: `Co${i}`,
-  product: 'Widget',
-  inStock: i % 3 !== 0,
-  quantity: 5 + (i % 50), // max 54 - never > 300
-  price: Math.round((10 + ((i * 41) % 480)) * 100) / 100, // spread 10..490
-}))
-
-function makeApi() {
-  return {
-    getData: () => rows,
-    getDisplayedRows: () => rows,
-    getSelectedRows: () => [],
-    getColumns: () => [
-      { id: 'country', field: 'country', header: 'Country', visible: true },
-      { id: 'company', field: 'company', header: 'Company', visible: true },
-      { id: 'product', field: 'product', header: 'Product', visible: true },
-      { id: 'quantity', field: 'quantity', header: 'Qty', visible: true },
-      { id: 'price', field: 'price', header: 'Price', visible: true, format: { type: 'currency', currency: 'USD' } },
-    ],
-    getState: () => ({ grouping: [] }),
-    getColumnPinning: () => ({ left: [], right: [] }),
-    clearAllFilters: vi.fn(),
-    clearSort: vi.fn(),
-    setFilter: vi.fn(),
-    setSort: vi.fn(),
-    setGroupBy: vi.fn(),
-  } as any
-}
-
-beforeEach(() => {
-  captured.parts = {}
-  setLicenseKey('SVENTERPRISE-DEV-TEST')
-  setAIProvider(mockAIProvider)
-  // aiExport is free (grid) and delegates the real write to enterprise's engine.
-  registerExportProvider(exportGrid)
-})
-
-describe('aiExport - "export orders over $300" (xlsx default)', () => {
-  it('produces a non-empty xlsx via the real export path', async () => {
-    const plan = await aiExport(makeApi(), 'export orders over $300')
-    expect(plan.format).toBe('xlsx')
-    expect(plan.filters).toContainEqual({ field: 'price', operator: 'greaterThan', value: '300' })
-
-    const sheet = captured.parts['xl/worksheets/sheet1.xml']
-    expect(sheet).toBeTruthy()
-    // header row + at least one data row
-    const rowCount = (sheet!.match(/<row /g) ?? []).length
-    expect(rowCount).toBeGreaterThan(1)
-  })
-})
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Real exportGrid runs (NOT mocked). Capture the xlsx parts / avoid the DOM.
+const captured: { parts: Record<string, string> } = { parts: {} }
+vi.mock('jszip', () => ({
+  default: class {
+    file(p: string, d: string) {
+      captured.parts[p] = d
+    }
+    async generateAsync() {
+      return new Blob([])
+    }
+  },
+}))
+vi.mock('./export-serialize', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>
+  return { ...actual, downloadBlobFile: () => {}, downloadTextFile: () => {} }
+})
+
+import { aiExport, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
+import { exportGrid } from './export'
+import { setLicenseKey } from './license'
+
+// Mirrors the real makeOrders shape - crucially includes `inStock` (boolean)
+// and `quantity`/`index` (numbers that never exceed 300), so the mock must
+// target `price` for "$300", not a boolean or a count.
+type Order = {
+  id: string
+  index: number
+  country: string
+  company: string
+  product: string
+  inStock: boolean
+  quantity: number
+  price: number
+}
+const rows: Order[] = Array.from({ length: 120 }, (_, i) => ({
+  id: `o${i}`,
+  index: i + 1,
+  country: ['USA', 'UK', 'Germany'][i % 3]!,
+  company: `Co${i}`,
+  product: 'Widget',
+  inStock: i % 3 !== 0,
+  quantity: 5 + (i % 50), // max 54 - never > 300
+  price: Math.round((10 + ((i * 41) % 480)) * 100) / 100, // spread 10..490
+}))
+
+function makeApi() {
+  return {
+    getData: () => rows,
+    getDisplayedRows: () => rows,
+    getSelectedRows: () => [],
+    getColumns: () => [
+      { id: 'country', field: 'country', header: 'Country', visible: true },
+      { id: 'company', field: 'company', header: 'Company', visible: true },
+      { id: 'product', field: 'product', header: 'Product', visible: true },
+      { id: 'quantity', field: 'quantity', header: 'Qty', visible: true },
+      { id: 'price', field: 'price', header: 'Price', visible: true, format: { type: 'currency', currency: 'USD' } },
+    ],
+    getState: () => ({ grouping: [] }),
+    getColumnPinning: () => ({ left: [], right: [] }),
+    clearAllFilters: vi.fn(),
+    clearSort: vi.fn(),
+    setFilter: vi.fn(),
+    setSort: vi.fn(),
+    setGroupBy: vi.fn(),
+  } as any
+}
+
+beforeEach(() => {
+  captured.parts = {}
+  setLicenseKey('SVENTERPRISE-DEV-TEST')
+  setAIProvider(mockAIProvider)
+  // aiExport is free (grid) and delegates the real write to enterprise's engine.
+  registerExportProvider(exportGrid as never)
+})
+
+describe('aiExport - "export orders over $300" (xlsx default)', () => {
+  it('produces a non-empty xlsx via the real export path', async () => {
+    const plan = await aiExport(makeApi(), 'export orders over $300')
+    expect(plan.format).toBe('xlsx')
+    expect(plan.filters).toContainEqual({ field: 'price', operator: 'greaterThan', value: '300' })
+
+    const sheet = captured.parts['xl/worksheets/sheet1.xml']
+    expect(sheet).toBeTruthy()
+    // header row + at least one data row
+    const rowCount = (sheet!.match(/<row /g) ?? []).length
+    expect(rowCount).toBeGreaterThan(1)
+  })
+})

package/src/ai-export.dom.test.ts

@@ -1,114 +1,114 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Capture downloads instead of touching the DOM (aiExport -> exportGrid).
-const downloads: Array<{ text: string; filename: string }> = []
-vi.mock('./export-serialize', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>
-  return {
-    ...actual,
-    downloadTextFile: (text: string, filename: string) => {
-      downloads.push({ text, filename })
-    },
-  }
-})
-
-import { aiExport, aiFindAnomalies, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
-import { exportGrid } from './export'
-import { setLicenseKey } from './license'
-
-type Row = { region: string; amount: number; name: string }
-const rows: Row[] = [
-  { region: 'EMEA', amount: 100, name: 'A' },
-  { region: 'NA', amount: 2000, name: 'B' },
-  { region: 'EMEA', amount: 50, name: 'C' },
-]
-
-function makeApi() {
-  return {
-    getData: () => rows,
-    getDisplayedRows: () => rows,
-    getSelectedRows: () => [],
-    getColumns: () => [
-      { id: 'region', field: 'region', header: 'Region', visible: true },
-      { id: 'amount', field: 'amount', header: 'Amount', visible: true },
-      { id: 'name', field: 'name', header: 'Name', visible: true },
-    ],
-    getState: () => ({ grouping: [] }),
-    clearAllFilters: vi.fn(),
-    clearSort: vi.fn(),
-    setFilter: vi.fn(),
-    setSort: vi.fn(),
-  } as any
-}
-
-beforeEach(() => {
-  downloads.length = 0
-  setLicenseKey('SVENTERPRISE-DEV-TEST')
-  setAIProvider(mockAIProvider)
-  // aiExport is free (grid) and delegates the WRITE to the registered engine;
-  // register enterprise's exportGrid so the download path actually runs.
-  registerExportProvider(exportGrid)
-})
-afterEach(() => setAIProvider(null))
-
-describe('aiExport', () => {
-  it('parses format + groupBy + filters; applies to the grid only when asked', async () => {
-    const api = makeApi()
-    const plan = await aiExport(api, 'export deals over 500 grouped by region as a pdf', {
-      run: false,
-      apply: true,
-    })
-    expect(plan.format).toBe('pdf')
-    expect(plan.groupBy).toEqual(['region'])
-    expect(plan.filters).toContainEqual({ field: 'amount', operator: 'greaterThan', value: '500' })
-    // apply: true -> the grid is mutated
-    expect(api.clearAllFilters).toHaveBeenCalled()
-    expect(api.setFilter).toHaveBeenCalledWith('amount', { operator: 'greaterThan', value: '500' })
-    // run:false -> nothing downloaded
-    expect(downloads).toHaveLength(0)
-  })
-
-  it('defaults to xlsx and does NOT touch the grid (apply defaults off)', async () => {
-    const api = makeApi()
-    const plan = await aiExport(api, 'just export everything', { run: false })
-    expect(plan.format).toBe('xlsx')
-    expect(api.clearAllFilters).not.toHaveBeenCalled()
-    expect(api.setFilter).not.toHaveBeenCalled()
-  })
-
-  it('runs the export (downloads) when run is not false', async () => {
-    const api = makeApi()
-    await aiExport(api, 'export as csv', { filename: 'report' })
-    expect(downloads).toHaveLength(1)
-    expect(downloads[0]!.filename).toBe('report.csv')
-  })
-
-  it('exports the plan-filtered rows directly (not the grid displayed rows)', async () => {
-    // getDisplayedRows returns EVERYTHING (as if the grid hadn't re-filtered);
-    // the export must still contain only rows matching the plan's filter.
-    const api = makeApi()
-    await aiExport(api, 'export deals over 500 as csv', { filename: 'big' })
-    const { text } = downloads[0]!
-    expect(text).toContain('2000') // amount 2000 > 500 kept
-    expect(text).not.toContain('100') // amount 100 filtered out
-    expect(text).not.toContain('50') // amount 50 filtered out
-  })
-})
-
-describe('aiFindAnomalies', () => {
-  it('flags a numeric outlier over the scanned rows', async () => {
-    const api = makeApi()
-    const result = await aiFindAnomalies(api, {})
-    expect(result.anomalies.length).toBeGreaterThan(0)
-    const amountAnomaly = result.anomalies.find((a) => a.field === 'amount')
-    expect(amountAnomaly?.value).toBe(2000) // the max in the sample
-    expect(amountAnomaly?.severity).toBe('medium')
-    expect(result.summary).toBeTruthy()
-  })
-
-  it('returns empty for an empty selection', async () => {
-    const api = makeApi()
-    const result = await aiFindAnomalies(api, { target: { kind: 'selection', rowIndices: [] } })
-    expect(result.anomalies).toEqual([])
-  })
-})
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Capture downloads instead of touching the DOM (aiExport -> exportGrid).
+const downloads: Array<{ text: string; filename: string }> = []
+vi.mock('./export-serialize', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>
+  return {
+    ...actual,
+    downloadTextFile: (text: string, filename: string) => {
+      downloads.push({ text, filename })
+    },
+  }
+})
+
+import { aiExport, aiFindAnomalies, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
+import { exportGrid } from './export'
+import { setLicenseKey } from './license'
+
+type Row = { region: string; amount: number; name: string }
+const rows: Row[] = [
+  { region: 'EMEA', amount: 100, name: 'A' },
+  { region: 'NA', amount: 2000, name: 'B' },
+  { region: 'EMEA', amount: 50, name: 'C' },
+]
+
+function makeApi() {
+  return {
+    getData: () => rows,
+    getDisplayedRows: () => rows,
+    getSelectedRows: () => [],
+    getColumns: () => [
+      { id: 'region', field: 'region', header: 'Region', visible: true },
+      { id: 'amount', field: 'amount', header: 'Amount', visible: true },
+      { id: 'name', field: 'name', header: 'Name', visible: true },
+    ],
+    getState: () => ({ grouping: [] }),
+    clearAllFilters: vi.fn(),
+    clearSort: vi.fn(),
+    setFilter: vi.fn(),
+    setSort: vi.fn(),
+  } as any
+}
+
+beforeEach(() => {
+  downloads.length = 0
+  setLicenseKey('SVENTERPRISE-DEV-TEST')
+  setAIProvider(mockAIProvider)
+  // aiExport is free (grid) and delegates the WRITE to the registered engine;
+  // register enterprise's exportGrid so the download path actually runs.
+  registerExportProvider(exportGrid as never)
+})
+afterEach(() => setAIProvider(null))
+
+describe('aiExport', () => {
+  it('parses format + groupBy + filters; applies to the grid only when asked', async () => {
+    const api = makeApi()
+    const plan = await aiExport(api, 'export deals over 500 grouped by region as a pdf', {
+      run: false,
+      apply: true,
+    })
+    expect(plan.format).toBe('pdf')
+    expect(plan.groupBy).toEqual(['region'])
+    expect(plan.filters).toContainEqual({ field: 'amount', operator: 'greaterThan', value: '500' })
+    // apply: true -> the grid is mutated
+    expect(api.clearAllFilters).toHaveBeenCalled()
+    expect(api.setFilter).toHaveBeenCalledWith('amount', { operator: 'greaterThan', value: '500' })
+    // run:false -> nothing downloaded
+    expect(downloads).toHaveLength(0)
+  })
+
+  it('defaults to xlsx and does NOT touch the grid (apply defaults off)', async () => {
+    const api = makeApi()
+    const plan = await aiExport(api, 'just export everything', { run: false })
+    expect(plan.format).toBe('xlsx')
+    expect(api.clearAllFilters).not.toHaveBeenCalled()
+    expect(api.setFilter).not.toHaveBeenCalled()
+  })
+
+  it('runs the export (downloads) when run is not false', async () => {
+    const api = makeApi()
+    await aiExport(api, 'export as csv', { filename: 'report' })
+    expect(downloads).toHaveLength(1)
+    expect(downloads[0]!.filename).toBe('report.csv')
+  })
+
+  it('exports the plan-filtered rows directly (not the grid displayed rows)', async () => {
+    // getDisplayedRows returns EVERYTHING (as if the grid hadn't re-filtered);
+    // the export must still contain only rows matching the plan's filter.
+    const api = makeApi()
+    await aiExport(api, 'export deals over 500 as csv', { filename: 'big' })
+    const { text } = downloads[0]!
+    expect(text).toContain('2000') // amount 2000 > 500 kept
+    expect(text).not.toContain('100') // amount 100 filtered out
+    expect(text).not.toContain('50') // amount 50 filtered out
+  })
+})
+
+describe('aiFindAnomalies', () => {
+  it('flags a numeric outlier over the scanned rows', async () => {
+    const api = makeApi()
+    const result = await aiFindAnomalies(api, {})
+    expect(result.anomalies.length).toBeGreaterThan(0)
+    const amountAnomaly = result.anomalies.find((a) => a.field === 'amount')
+    expect(amountAnomaly?.value).toBe(2000) // the max in the sample
+    expect(amountAnomaly?.severity).toBe('medium')
+    expect(result.summary).toBeTruthy()
+  })
+
+  it('returns empty for an empty selection', async () => {
+    const api = makeApi()
+    const result = await aiFindAnomalies(api, { target: { kind: 'selection', rowIndices: [] } })
+    expect(result.anomalies).toEqual([])
+  })
+})

package/src/export-ooxml.ts

@@ -83,6 +83,10 @@ const XML_ESCAPE: Record<string, string> = {
   "'": '&apos;',
 }
 // Control chars that are illegal in XML 1.0 (would make Excel reject the file).
+// XML 1.0 forbids these control characters outright, so they are stripped
+// rather than escaped - a stray \x00 from a data source would otherwise
+// produce a workbook Excel refuses to open.
+// eslint-disable-next-line no-control-regex
 const INVALID_XML = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g
 function esc(s: string): string {
   return s.replace(INVALID_XML, '').replace(/[&<>"']/g, (c) => XML_ESCAPE[c]!)

package/src/export-xls.ts

@@ -17,6 +17,9 @@ import type { RowData } from '@svgrid/grid'
 import type { SerializeOptions } from './export-serialize'
 
 // Control chars illegal in XML 1.0 - strip so a stray \x00 can't corrupt the file.
+// See export-ooxml.ts: XML 1.0 has no representation for these at all, so a
+// control character has to be dropped before it reaches the file.
+// eslint-disable-next-line no-control-regex
 const INVALID_XML = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g
 function xmlEscape(s: string): string {
   return s

package/src/expressions/evaluate.ts

@@ -103,6 +103,11 @@ export function evaluateScalar<TData = ExprRow>(
           return b === 0 ? NaN : a / b
         case '%':
           return b === 0 ? NaN : a % b
+        // Rules are authored at runtime, so an operator outside the union can
+        // arrive from parsed JSON. Without this the switch falls out of its
+        // case and into `case 'agg'`, reading agg fields off a binary node.
+        default:
+          return null
       }
     }
     case 'agg': {
@@ -123,6 +128,10 @@ export function evaluateScalar<TData = ExprRow>(
           return Math.min(...nums)
         case 'max':
           return Math.max(...nums)
+        // Same here: falling through to `case 'func'` would call
+        // `expr.name.toUpperCase()` on an agg node and throw.
+        default:
+          return null
       }
     }
     case 'func': {

package/src/import.test.ts

@@ -250,7 +250,7 @@ describe('validation + commit', () => {
     const { api } = fakeApi()
     const r = await importData(api, {
       file: csv, format: 'csv',
-      validator: (row, i) => {
+      validator: (row, _i) => {
         const errs = []
         const price = (row as any).price as number
         if (price < 0) errs.push({ field: 'price', message: 'must be >= 0' })

package/src/import.ts

@@ -658,7 +658,7 @@ function coerceTyped(raw: string, type: ImportFieldType):
       if (iso) return { ok: true, value: `${iso[1]}-${iso[2]}-${iso[3]}` }
       // mm/dd/yyyy or dd/mm/yyyy - we don't try to disambiguate; the
       // demo can declare the locale via its own validator if it cares.
-      const slash = trimmed.match(/^(\d{1,2})[\/\-](\d{1,2})[\/\-](\d{4})/)
+      const slash = trimmed.match(/^(\d{1,2})[/-](\d{1,2})[/-](\d{4})/)
       if (slash) {
         const [, a, b, y] = slash
         // Default to mm/dd/yyyy because it's the dominant locale where

package/src/index.ts

@@ -201,6 +201,7 @@ export {
   type PlanOp,
   type KitDataSourceOptions,
   type KitHandlerOptions,
+  type KitScope,
   type KitHandlers,
   type KitMessage,
   type SqlDialect,
@@ -321,6 +322,17 @@ export {
   liveDataSamples,
   getLiveDataSample,
   type SampleApp,
+  starterDatasets,
+  getStarterDataset,
+  type StarterDataset,
+  crudSuiteScreens,
+  addCrudSuite,
+  crudAppFromSchemas,
+  type CrudScreenKind,
+  type CrudEditingMode,
+  type CrudSuiteOptions,
+  type CrudAppOptions,
+  introspectJson,
   sanitizeStudioProject,
   buildStudioBugReport,
   type BugReport,

package/src/pivot.test.ts

@@ -8,7 +8,6 @@ import {
   filterCollapsedPivotRows,
   pivotAggregators,
   type PivotConfig,
-  type PivotRow,
 } from './pivot'
 
 type Sale = {

package/src/schema-designer.ts

@@ -60,7 +60,7 @@ export function updateField(
     if (f.field !== fieldName) {
       return makesPrimary && f.primaryKey ? { ...f, primaryKey: false } : f
     }
-    let next: EntityField = { ...f, ...patch }
+    const next: EntityField = { ...f, ...patch }
     if (patch.type && patch.type !== f.type) {
       if (patch.type !== 'enum') delete next.options
       if (patch.type !== 'relation') delete next.relation

package/src/sources/introspect-supabase.ts

@@ -11,8 +11,8 @@
  * whose OpenAPI is blocked) - the caller can then ask the user to list columns.
  */
 import type { RowData } from '@svgrid/grid'
-import type { EntityFieldType, EntitySchema } from '../schema'
-import { buildEntitySchema, type IntrospectedColumn } from './schema-from-columns'
+import type { EntityFieldType, EntitySchema } from '../schema.js'
+import { buildEntitySchema, type IntrospectedColumn } from './schema-from-columns.js'
 
 export type IntrospectSupabaseOptions = {
   /** Project URL, e.g. `https://xxxx.supabase.co`. */