@finebi/finebi-cli 1.6.0 → 1.6.1

package/templates/web-app/tests/cockpit.test.mjs

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import {after,test} from 'node:test';
+import {createServer} from 'vite';
+import {createElement} from 'react';
+import {renderToStaticMarkup} from 'react-dom/server';
+const server=await createServer({configFile:false,cacheDir:'temp/vite-cockpit-tests',server:{middlewareMode:true,hmr:false}});
+after(()=>server.close());
+const client=await server.ssrLoadModule('/src/finebi/client.ts');
+const data=await server.ssrLoadModule('/src/services/table-data.ts');
+const queries=await server.ssrLoadModule('/src/services/widget-queries.ts');
+const {Widget}=await server.ssrLoadModule('/src/components/Widget.tsx');
+const config={schemaVersion:'1',title:'Test',basePath:'/bi',layout:'cockpit',dashboardId:'r',directoryEntryId:'directory',maxRows:1000,pageSize:8,
+  widgets:[{entryId:'a',name:'A',type:'table',filterNames:['month']},{entryId:'b',name:'B',type:'table',filterNames:[]}],filters:[{name:'month',label:'月份',type:'month'}]};
+const native={previewResult:{resultType:'DETAIL',header:[],items:[],size:10,row:0,hasNext:false}};
+test('retry is only exposed after a settled failure, never while an initial request is pending',()=>{
+  const props={binding:config.widgets[0],pageSize:8,onRetry:()=>{}};
+  assert.doesNotMatch(renderToStaticMarkup(createElement(Widget,{...props,state:{loading:true}})),/重试组件/);
+  assert.match(renderToStaticMarkup(createElement(Widget,{...props,state:{loading:false,error:new Error('fixture')}})),/重试组件/);
+});
+test('directory source and verified per-widget scope survive individual queries, never falling back',async()=>{
+  const sent=[];
+  const fetcher=async(url,init)=>{sent.push({url,...JSON.parse(init.body)});return new Response(JSON.stringify({success:true,data:{a:native,b:native}}));};
+  await client.queryWidget(config,config.widgets[0],{month:'2024-02'},undefined,fetcher);
+  await client.queryWidget(config,config.widgets[1],{month:'2024-02'},undefined,fetcher);
+  assert.deepEqual(sent.map(s=>s.reportEntryId),['directory','directory']);
+  assert.deepEqual(sent.map(s=>s.widgetIds),[['a'],['b']]);
+  assert.deepEqual(sent.map(s=>s.refer),[{month:['2024-02']},{}]);
+  let calls=0;
+  await assert.rejects(client.queryWidget(config,config.widgets[0],{},undefined,async()=>{calls++;return new Response('{}',{status:403});}),e=>e.code==='PERMISSION_DENIED');
+  assert.equal(calls,1);
+});
+test('component loader limits concurrency, publishes independent failures and respects cancellation',async()=>{
+  const updates=[];let active=0,peak=0;
+  const many={...config,widgets:[...config.widgets,...Array.from({length:6},(_,i)=>({entryId:'extra-'+i,name:'Extra',type:'table'}))]};
+  await queries.loadWidgets(many,{},new AbortController().signal,(id,state)=>updates.push([id,state]),async(_url,init)=>{
+    active++;peak=Math.max(peak,active);await new Promise(r=>setTimeout(r,5));active--;
+    const id=JSON.parse(init.body).widgetIds[0];return id==='a'?new Response('{}',{status:500}):new Response(JSON.stringify({success:true,data:{[id]:native}}));
+  });
+  assert.equal(peak,3);assert.ok(updates.find(([id,s])=>id==='0:a'&&s.error));assert.ok(updates.find(([id,s])=>id==='1:b'&&s.result));
+  const controller=new AbortController();controller.abort();let calls=0;
+  await queries.loadWidgets(config,{},controller.signal,()=>assert.fail('no stale update'),async()=>{calls++;});assert.equal(calls,0);
+});
+test('same native widget can have separate display scopes; aborted old responses publish nothing',async()=>{
+  const duplicate={...config,widgets:[config.widgets[0],{...config.widgets[0],filterNames:[]}]};
+  const complete=[];
+  await queries.loadWidgets(duplicate,{month:'2024-02'},new AbortController().signal,(key,state)=>{if(state.result)complete.push(key);},async()=>new Response(JSON.stringify({success:true,data:{a:native}})));
+  assert.deepEqual(complete.sort(),['0:a','1:a']);
+  const controller=new AbortController(),updates=[];
+  await queries.loadWidgets(config,{},controller.signal,(_key,state)=>updates.push(state),async()=>{controller.abort();return new Response(JSON.stringify({success:true,data:{a:native,b:native}}));});
+  assert.ok(updates.every(s=>s.loading));
+});
+const cell=(value,state='AVAILABLE',display=value)=>({value,display,state,reason:null});
+const dataset={id:'main',returnedRowCount:4,columns:[{fieldId:'x',key:'c0',name:'名字',type:'STRING'},{fieldId:'v',key:'c1',name:'金额',type:'DECIMAL'}],rows:[
+  {kind:'DATA',cells:[cell('=HYPERLINK("x")'),cell('9007199254740993.01')]},
+  {kind:'DATA',cells:[cell('B'),cell('9007199254740993.02','AVAILABLE','9,007,199,254,740,993.02元')]},
+  {kind:'UNKNOWN',cells:[cell('C'),cell(null,'RESTRICTED','***')]},
+  {kind:'DATA',cells:[cell('D'),cell(null,'NULL',null)]},
+]};
+test('loaded table sorts decimals exactly, filters and exports matching rows with safe CSV and explicit states',()=>{
+  assert.equal(data.compareDecimal('9007199254740993.01','9007199254740993.02'),-1);
+  assert.equal(data.compareDecimal('-1.001e3','-1001'),0);
+  assert.equal(data.compareDecimal('1e-10','0.00000000009'),1);
+  assert.equal(data.compareDecimal('1.20','1.2'),0);
+  assert.equal(data.compareDecimal('1200','1.2e3'),0);
+  assert.equal(data.compareDecimal('-0.001200','-1.2e-3'),0);
+  const rows=data.tableRows(dataset,{search:'',sort:{fieldId:'v',direction:'desc'},filters:{}});
+  assert.equal(rows[0].cells[0].value,'B');assert.equal(rows[1].cells[0].value,'=HYPERLINK("x")');
+  const filtered=data.tableRows(dataset,{search:'',filters:{x:'B'}});assert.equal(filtered.length,1);
+  const csv=data.tableCsv(dataset,rows);
+  assert.match(csv,/'=HYPERLINK/);assert.match(csv,/受限/);assert.doesNotMatch(csv,/\*\*\*/);assert.match(csv,/UNKNOWN/);
+  assert.match(data.tableCsv(dataset,filtered),/9,007,199/);
+  assert.throws(()=>data.tableRows(dataset,{search:'',filters:{missing:'x'}}),/字段/);
+});

package/templates/web-app/tests/proxy.test.mjs

@@ -3,6 +3,18 @@ import {test} from 'node:test';
 import {createServer} from 'node:http';
 import {createDevMiddleware} from '../scripts/dev-proxy.mjs';
 
+test('directory proxy pins the published entry and never forwards another source',async()=>{
+  const sent=[];
+  const middleware=createDevMiddleware({basePath:'/bi',dashboardId:'r',directoryEntryId:'entry',widgets:[{entryId:'w'}],filters:[],maxRows:10},
+    {FINEBI_DEV_BASE_URL:'http://bi.example/bi',FINEBI_DEV_TOKEN:'secret'},async(_url,init)=>{sent.push(JSON.parse(init.body));return new Response(JSON.stringify({success:true,data:{}}));});
+  const server=createServer((req,res)=>middleware(req,res,()=>{}));await new Promise(r=>server.listen(0,'127.0.0.1',r));
+  const send=body=>fetch(`http://127.0.0.1:${server.address().port}/bi/v5/api/dashboard/report/r/widgets/query`,{method:'POST',headers:{'X-Requested-With':'XMLHttpRequest'},body:JSON.stringify({widgetIds:['w'],pageLimit:10,...body})});
+  try {
+    for(const body of [{},{reportEntryId:'other'},{directoryEntryId:'entry'}])assert.equal((await send(body)).status,400);
+    assert.equal(sent.length,0);assert.equal((await send({reportEntryId:'entry'})).status,200);assert.equal(sent[0].reportEntryId,'entry');
+  }finally{await new Promise(r=>server.close(r));}
+});
+
 test('development identity stays on server and cross-site or out-of-scope requests are rejected', async () => {
   const upstream = [];
   const middleware = createDevMiddleware({basePath:'/webroot/decision',dashboardId:'r',widgets:[{entryId:'w'}],maxRows:1000}, {FINEBI_DEV_BASE_URL:'http://bi.example/webroot/decision',FINEBI_DEV_USERNAME:'tester',FINEBI_DEV_PASSWORD:'dev-secret'}, async (url,init) => {

package/templates/web-app/tests/retail.test.mjs

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import {after,test} from 'node:test';
+import {createServer} from 'vite';
+const server=await createServer({configFile:false,cacheDir:'temp/vite-retail-tests',server:{middlewareMode:true,hmr:false}});
+after(()=>server.close());
+const {formatMetric,formatCategory}=await server.ssrLoadModule('/src/services/presentation.ts');
+const {configErrors}=await import('../src/finebi/config.js');
+const cell=(value,state='AVAILABLE')=>({value,display:null,state,reason:null});
+test('KPI display preserves decimal precision and formats ratios only by explicit configuration',()=>{
+  assert.equal(formatMetric(cell('9007199254740993.01'),'number'),'9,007,199,254,740,993.01');
+  assert.equal(formatMetric(cell('1.2345678e7'),'number'),'12,345,678');
+  assert.equal(formatMetric(cell('0.123456789'),'percent'),'12.35%');
+  assert.equal(formatMetric(cell('-0.00005'),'percent'),'-0.01%');
+  assert.equal(formatMetric(cell('42.0'),'number'),'42');
+  assert.equal(formatMetric(cell('100','RESTRICTED'),'number'),'受限');
+  assert.equal(formatMetric(cell(null,'NULL'),'percent'),'—');
+  assert.equal(formatMetric(cell('0.5')),'0.5');
+});
+test('month formatting is explicit, timezone-aware and preserves invalid or restricted values',()=>{
+  const binding={categoryFormat:'epoch-month',categoryTimeZone:'Asia/Shanghai'};
+  const timestamp=String(Date.UTC(2024,1,29,16));
+  assert.equal(formatCategory(cell(timestamp),binding),'2024-03');
+  assert.equal(formatCategory(cell(timestamp),{}),timestamp);
+  assert.equal(formatCategory(cell('not-a-date'),binding),'not-a-date');
+  assert.equal(formatCategory(cell(timestamp,'RESTRICTED'),binding),'受限');
+});
+test('display configuration rejects implicit date timezone and invalid formats',()=>{
+  const config={schemaVersion:'1',title:'Test',basePath:'/bi',layout:'retail',dashboardId:'r',maxRows:1000,pageSize:8,filters:[],widgets:[{entryId:'w',name:'Trend',type:'line',categoryFieldId:'x',valueFieldId:'y',categoryFormat:'epoch-month',categoryTimeZone:'Asia/Shanghai'}]};
+  assert.deepEqual(configErrors(config),[]);
+  for(const patch of [{categoryTimeZone:undefined},{categoryTimeZone:'Bad/Timezone'},{categoryFormat:'guess'},{valueFormat:'guess'}])assert.ok(configErrors({...config,widgets:[{...config.widgets[0],...patch}]}).length);
+});

package/templates/web-app/tests/runtime.test.mjs

@@ -52,7 +52,7 @@ test('chart preserves multiple models, rejects formatted numeric strings and mis
   assert.equal(r.datasets[0].rows[1].cells[1].state,'UNAVAILABLE');
   assert.equal(r.normalization,'PARTIAL');
 });
-const config = {schemaVersion:'1',basePath:'/webroot/decision',dashboardId:'report',maxRows:1000,widgets:[{entryId:'table',type:'table',name:'明细'}],filters:[{name:'地区',label:'地区',options:[{label:'西部',value:'West'}]}]};
+const config = {schemaVersion:'1',title:'Test',layout:'overview',pageSize:8,basePath:'/webroot/decision',dashboardId:'report',maxRows:1000,widgets:[{entryId:'table',type:'table',name:'明细'}],filters:[{name:'地区',label:'地区',options:[{label:'西部',value:'West'}]}]};
 test('query sends scoped refer, cookie credentials and bounded pageLimit without browser token storage', async () => {
   let sent;
   const r = await queryWidgets(config, {'地区':'West'}, undefined, async (url, init) => {

package/templates/web-app/vite.config.ts

@@ -1,9 +1,11 @@
 import {readFileSync} from 'node:fs';
+import {fileURLToPath} from 'node:url';
 import {defineConfig, loadEnv} from 'vite';
 // @ts-expect-error The development-only Node module is tested directly with node:test.
 import {createDevMiddleware} from './scripts/dev-proxy.mjs';
 export default defineConfig(({mode}) => ({
   base: './',
+  resolve:{alias:[{find:/^date-fns\/locale$/,replacement:fileURLToPath(new URL('./src/components/calendar-locales.ts',import.meta.url))}]},
   server: {host:'127.0.0.1',port:4173,strictPort:true},
   plugins:[{name:'finebi-development-session',apply:'serve',configureServer(server) {
     const config=JSON.parse(readFileSync(new URL('./public/app-config.json',import.meta.url),'utf8'));