@opengis/bi 1.0.11 → 1.0.13

package/server/routes/data/controllers/data.js

@@ -1,98 +1,94 @@
 
-// import getTemplate from '@opengis/fastify-table/table/controllers/utils/getTemplate.js';
-import autoIndex from '@opengis/fastify-table/pg/funcs/autoIndex.js';
-import pgClients from '@opengis/fastify-table/pg/pgClients.js';
+
+//import autoIndex from '@opengis/fastify-table/pg/funcs/autoIndex.js';
+// import pgClients from '@opengis/fastify-table/pg/pgClients.js';
+
+import { getPGAsync, autoIndex, pgClients, getSelectVal } from '@opengis/fastify-table/utils.js';
 import chartSQL from './util/chartSQL.js';
 import normalizeData from './util/normalizeData.js';
 
-
-import { getTemplate } from '@opengis/fastify-table/utils.js';
+import { getWidget } from '../../../../utils.js';
 
 export default async function data({
-  pg = pgClients.client, funcs = {}, query = {},
+  funcs = {}, query = {},
 }) {
   const time = Date.now();
-  const { config = {} } = funcs;
-  const { dashboard, widget } = query;
-
-  if (!widget && !dashboard) {
-    return { message: 'not enough params: widget or dashboard required', status: 400 };
-  }
-  const dashboardData = dashboard ? await getTemplate('dashboard', dashboard) : null;
-
-  const { id, tableName } = !dashboardData && pg.pk['bi.dashboard'] && dashboard ?
-    await pg.query(`select dashboard_id as id, table_name as "tableName" from bi.dashboard where $1 in (dashboard_id, name)`, [dashboard]).then((res1) => res1.rows?.[0] || {}) : {};
-
-
-  if (!dashboardData && dashboard && !id) return 'dashboard not found';
-
-  // return { t: 111, data: dashboardData, dashboard }
-
-  const widgetData = dashboard ? dashboardData?.find(el => el[0]?.includes(widget))?.[1] : await getTemplate('widget', widget);
+  const { dashboard, widget, filter, search, samples } = query;
 
+  const widgetData = await getWidget({ dashboard, widget });
 
-  if (dashboardData && !widgetData) {
-    return widgetData
-  }
-
-  if (!id && !dashboardData && !widgetData) {
-    return { message: { root: config?.local ? dashboardDir : undefined, error: `not found`, widget, dashboard }, status: 404 };
-  }
+  if (widgetData.status) return widgetData;
 
-  const q = `select *, coalesce(data::jsonb, '{}'::jsonb) || jsonb_build_object('table', table_name) as data from bi.widget where dashboard_id=$1 and name=$2`;
-  const { type, text, data, controls, style, options } = widgetData || await pg.query(q, [id || dashboard, widget]).then((res1) => res1.rows?.[0] || {});
-
-  if (typeof widgetData === 'string') {
-    return { title: false, source: widgetData };
-  }
+  const { type, text, data = {}, controls, style, options } = widgetData;
 
-  if (!data?.table && tableName) {
-    Object.assign(data, { table: tableName });
-  }
+  const pg = data.db ? await getPGAsync(data.db) : pgClients.client
 
-  if (!data?.table) {
-    return { error: /* json.error || */ `invalid ${widget ? 'widget' : 'dashboard'}: 1`, status: 500 };
-  }
+  const { fields: cols } = await pg.query(`select * from ${data.table} limit 0`);
+  const columnTypes = cols.map(el => ({ name: el.name, type: pg.pgType?.[el.dataTypeID] }))
 
   // data param 
-  const { x, metric, table, where, groupby, xName } = normalizeData(data, query);
+  const { x, cls, metric, table, where, tableSQL, groupby, xName } = normalizeData(widgetData, query, columnTypes);
 
   // auto Index
-  if (pg.pk[data.table]) {
-    autoIndex({ table: data.table, columns: [data?.time].concat([xName]).concat([groupby]).filter(el => el) }).catch(err => console.log(err))
+  if (pg.pk?.[data.table]) {
+    autoIndex({ table: data.table, pg, columns: [data?.time].concat([xName]).concat([groupby]).filter(el => el) }).catch(err => console.log(err))
   }
 
   // get group 
-  const groupData = groupby ? await pg.query(`select ${groupby} as name ,count(*) from ${table} group by ${groupby} order by count(*) desc limit 20`).then(el => el.rows) : null;
+  const groupData = groupby ? await pg.query(`select ${groupby} as name ,count(*) from ${tableSQL || table} group by ${groupby} order by count(*) desc limit 20`).then(el => el.rows) : null;
+
+  if (query.sql === '2') return { x, metric, table, tableSQL, data, groupData };
 
-  if (query.sql === '2') return { x, metric, table, data, groupData };
+  const order = data.order || (type === 'listbar' ? 'metric desc' : null);
 
-  const sql = (chartSQL[type] || chartSQL['chart'])({ where, metric, table, x, groupData, groupby });
+  const { optimizedSQL = `select * from ${tableSQL || table}` } = filter || search ? await funcs.getFilterSQL({
+    pg, table, filter, search,
+  }) : {};
 
+  const sql = (chartSQL[type] || chartSQL['chart'])({ where, metric, table: `(${optimizedSQL})q`, x, groupData, groupby, order, samples });
 
   if (query.sql) return sql;
 
   if (!sql || sql?.includes('undefined')) {
-    return { message: { error: 'invalid sql', type, sql, where, metric, table, x, groupData, groupby }, status: 500 };
+    return { message: { error: 'invalid sql', type, sql, where, metric, table: `(${optimizedSQL})q`, x, groupData, groupby }, status: 500 };
   }
 
   const { rows, fields } = await pg.query(sql); // test with limit
 
-  const dimensions = fields.map(el => el.name)
+  if (cls) {
+    const values = rows.map((row) => row[x])?.filter((el, idx, arr) => el && arr.indexOf(el) === idx);
+    const vals = await getSelectVal({ pg, name: cls, values });
+    rows.filter((row) => row[x]).forEach((row) => {
+      Object.assign(row, { [x]: vals?.[row[x]] || row[x] });
+    });
+  }
+
+  const dimensions = fields.map(el => el.name);
 
   const res = {
     time: Date.now() - time,
     dimensions,
 
-    dimensionsType: fields.map(el => pg.pgType[el.dataTypeID]),
+    dimensionsType: fields.map(el => pg.pgType?.[el.dataTypeID]),
     type,
 
-    text: text ? text : data.text,
+    text: text ? text : (widgetData?.title || data.text),
     //data: query.format === 'data' ? dimensions.map(el => rows.map(r => r[el])) : undefined,
     source: query.format === 'array' ? dimensions.map(el => rows.map(r => r[el])) : rows,
     style,
     options,
     controls,
+    params: {
+      x,
+      cls,
+      metric,
+      table,
+      tableSQL,
+      where,
+      groupby,
+      sql,
+    },
+    columnTypes,
   };
   return res;
 

package/server/routes/data/controllers/util/chartSQL.js

@@ -1,19 +1,20 @@
-function number({ metric, where, table }) {
-    const sql = `select ${metric} from ${table} where ${where}`
+function number({ metric, where, table, samples }) {
+    const sql = `select ${metric} from ${table} where ${where} ${samples ? 'limit 10' : ''}`
     return sql;
 }
-function table({ columns, table, where }) {
-    return `select ${columns.map(el => el.name || el)}::text from ${table} where ${where} limit 20 `
+function table({ columns, table, where, samples }) {
+    return `select ${columns.map(el => el.name || el)}::text from ${table} where ${where} ${samples ? 'limit 10' : 'limit 20'} `
 }
 
-function chart({ metric, where, table, x, groupby, groupData }) {
+function chart({ metric, where, table, x, groupby, groupData, order, samples }) {
 
-    const metricData = groupData?.map(el => `${metric} filter (where ${groupby}='${el.name}') as "${el.name}"`).join(',') || metric
+    const metricData = groupData?.map(el => `${metric} filter (where ${groupby}='${el.name}') as "${el.name}"`).join(',') || `${metric} as metric`
     const sql = `select ${x}, ${metricData} 
     from ${table}
     where ${where} 
     group by ${x}
-    order by ${x}`;
+    order by ${order || x}
+    ${samples ? 'limit 10' : 'limit 100'}`;
     return sql;
 }
 

package/server/routes/data/controllers/util/normalizeData.js

@@ -1,21 +1,34 @@
-function normalizeData(data, query = {}) {
+function normalizeData(data, query = {}, columnTypes = []) {
+    ['x', 'groupby', 'granularity'].forEach(el => {
+        //console.log(el, query[el], columnTypes.find(col => col.name == query[el]))
+        if (!columnTypes.find(col => col.name == query[el])) { delete query[el]; }
+    });
 
+    if (!columnTypes.find(col => col.type === 'numeric' && col.name == query.metric)) { delete query.metric; }
 
-    const granularity = query.granularity || data.granularity;
+    const xName = query.x || (Array.isArray(data.x) ? data.x[0] : data.x);
+    const xTYpe = columnTypes.find(el => el.name == xName)?.type;
 
+    const granularity = xTYpe === 'date' || xTYpe?.includes('timestamp') ? (query.granularity || data.granularity || 'year') : null;
 
-    const xName = Array.isArray(data.x) ? data.x[0] : data.x || query.x;
-
-    const x = (granularity ? `date_trunc('${granularity}',${xName})::date` : null) || xName;
+    const x = (granularity ? `date_trunc('${granularity}',${xName})::date::text` : null) || xName;
 
     const metrics = Array.isArray(data.metrics) ? data.metrics : [data.metrics];
-    const metric = metrics.length ? metrics?.filter(el => el).map(el => `${el.operator || 'sum'}(${el.name || el})`) : 'count(*)';
+    const metric = (query.metric ? `sum(${query.metric})` : null) || (metrics.length ? metrics?.filter(el => el).map(el => el.fx || `${el.operator || 'sum'}(${el.name || el})`) : 'count(*)');
 
-    const table = data.table;
-    const where = data.query || 'true';
+    const { cls, table, filterCustom } = data;
     const groupby = query.groupby || data.groupby;
     //const orderby = query.orderby || data.orderby || 'count(*)';
 
-    return { x, metric, table, where, groupby, xName }
+    const custom = query?.filterCustom?.split(',')
+    ?.map((el) => filterCustom?.find((item) => item?.name === el)?.sql)
+    ?.filter((el) => el)?.join(' and ');
+    const where = `${data.query || '1=1'} and ${custom || 'true'}`;
+
+    const tableSQL = data.tableSQL?.length
+        ? `(select * from ${data?.table} t ${data.tableSQL.join(' \n ')} where ${where})q`
+        : undefined;
+
+    return { x, cls, metric, table, where, tableSQL, groupby, xName }
 }
 export default normalizeData;

package/server/routes/edit/controllers/dashboard.add.js

@@ -1,7 +1,11 @@
 export default async function widgetAdd({ pg, funcs, params = {}, body }) {
   try {
     const time = Date.now();
-    console.log(body);
+    const tableName = body.table_name;
+    const checkTable = await pg.query(`select * from bi.dashboard where $1 in (table_name)`, [
+      tableName
+    ]);
+    if (!checkTable.rows.length) return { message: 'bad params', status: 401 };
     const res = await funcs.dataInsert({
       table: 'bi.dashboard',
       data: body

package/server/routes/edit/controllers/dashboard.edit.js

@@ -8,7 +8,11 @@ export default async function dashboardEdit({
         status: 400,
       }
     }
-
+    const tableName = body.table_name;
+    const checkTable = await pg.query(`select * from bi.dashboard where $1 in (table_name)`, [
+      tableName
+    ]);
+    if (!checkTable.rows.length) return { message: 'bad params', status: 401 };
     const { name: dashboardName } = params;
     const row = await pg.query(`select dashboard_id from bi.dashboard where $1 in (dashboard_id, name)`, [dashboardName]).then((res1) => res1.rows?.[0] || {});
     const { dashboard_id: dashboardId } = row;

package/server/routes/edit/controllers/widget.add.js

@@ -1,15 +1,26 @@
-export default async function widgetAdd({
-  pg, funcs, params = {}, body = {},
-}) {
+export default async function widgetAdd({ pg, funcs, params = {}, body = {} }) {
   const { name: dashboardName } = params;
   if (!dashboardName) {
     return { message: 'not enough params: id', status: 400 };
   }
-
+  const tableName = body.table_name;
   try {
-    const row = await pg.query(`select dashboard_id, widgets, panels from bi.dashboard where $1 in (dashboard_id,name)`, [dashboardName]).then((res) => res.rows?.[0] || {});
+    const row = await pg
+      .query(
+        `select dashboard_id, widgets, panels from bi.dashboard where $1 in (dashboard_id,name)`,
+        [dashboardName]
+      )
+      .then((res) => res.rows?.[0] || {});
+
+    const checkTable = await pg.query(`select * from bi.widget where $1 in (table_name)`, [
+      tableName
+    ]);
+    if (!checkTable.rows.length) return { message: 'bad params', status: 401 };
+
     const { dashboard_id: dashboardId } = row;
 
+    const generatedName = generateUniqueName(body.type);
+    body.name = generatedName;
     const res = await funcs.dataUpdate({
       table: 'bi.dashboard',
       id: dashboardId,
@@ -20,14 +31,19 @@ export default async function widgetAdd({
     });
     const res2 = await funcs.dataInsert({
       table: 'bi.widget',
-      data: { ...body, data: body, dashboard_id: dashboardId },
+      data: { ...body, data: body, dashboard_id: dashboardId }
     });
     return {
       message: `Added widget to ${dashboardName}`,
       status: 200,
-      rows: res,
+      rows: res
     };
   } catch (err) {
     return { error: err.toString(), status: 500 };
   }
 }
+function generateUniqueName(prefix = 'bar') {
+  const randomPart = Math.floor(Math.random() * 10000);
+  const timestamp = Date.now();
+  return `${prefix}_${randomPart}_${timestamp}`;
+}

package/server/routes/edit/controllers/widget.del.js

@@ -14,7 +14,7 @@ export default async function widgetDel({ pg = {}, params = {} }) {
     const row = await pg
       .query(
         `select a.widget_id, b.dashboard_id from bi.widget a, bi.dashboard b
-      where a.name=$2 and $1 in (b.dashboard_id, b.name) order by 1,2`,
+      where $2 in (a.widget_id, a.name) and $1 in (b.dashboard_id, b.name) order by 1,2`,
         [dashboardName, widgetName]
       )
       .then((res1) => res1.rows?.[0] || {});

package/server/routes/edit/controllers/widget.edit.js

@@ -1,7 +1,7 @@
 import dataUpdate from '@opengis/fastify-table/crud/funcs/dataUpdate.js';
 export default async function widgetEdit({ pg = {}, funcs = {}, body = {}, params = {} }) {
   const { widget: widgetName, name: dashboardName } = params;
-
+  const tableName = body.table_name;
   if (!widgetName || !dashboardName) {
     return {
       message: 'not enough params: dashboard and widget name',
@@ -13,12 +13,15 @@ export default async function widgetEdit({ pg = {}, funcs = {}, body = {}, param
     const row = await pg
       .query(
         `select a.widget_id, b.dashboard_id from bi.widget a, bi.dashboard b
-    where a.name=$2 and $1 in (b.dashboard_id, b.name) order by 1,2`,
+    where $2 in (a.widget_id, a.name) and $1 in (b.dashboard_id, b.name) order by 1,2`,
         [dashboardName, widgetName]
       )
       .then((res1) => res1.rows?.[0] || {});
-
+    const checkTable = await pg.query(`select * from bi.widget where $1 in (table_name)`, [
+      tableName
+    ]);
     const { widget_id: widgetId, dashboard_id: dashboardId } = row || {};
+    if (!checkTable.rows.length) return { message: 'bad params', status: 401 };
 
     if (!widgetId) {
       return { message: `widget not found ${widgetName}`, status: 404 };
@@ -47,7 +50,7 @@ export default async function widgetEdit({ pg = {}, funcs = {}, body = {}, param
       Array.isArray(bodyDashboard.panels) && bodyDashboard.panels?.length
         ? bodyDashboard.panels?.map((panel) => {
             if (panel.widget === widgetName) {
-              panel.col = body.col; 
+              panel.col = body.col;
             }
             return panel;
           })
@@ -56,7 +59,7 @@ export default async function widgetEdit({ pg = {}, funcs = {}, body = {}, param
       Array.isArray(bodyDashboard.widgets) && bodyDashboard?.widgets?.length
         ? bodyDashboard.widgets?.map((widget) => {
             if (widget.name === widgetName) {
-              return body; 
+              return body;
             }
             return widget;
           })

package/server/routes/map/controllers/cluster.js

@@ -0,0 +1,75 @@
+
+import { getWidget } from '../../../../utils.js';
+
+export default async function cluster({
+    pg, funcs, query = {}, log,
+}) {
+    const {
+        widget, filter, dashboard, search,
+    } = query;
+
+    if (!widget) {
+        return { message: 'not enough params: widget', status: 400 };
+    }
+
+    const { data } = await getWidget({ dashboard, widget })
+
+    try {
+
+        const pkey = pg.pk?.[data?.table];
+
+        if (!pkey) {
+            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: table pk not found (${data?.table})`, status: 400 };
+        }
+
+        // data param 
+        const { table, query: where = '1=1', metrics = [], cluster, clusterTable = {} } = data;
+
+        if (!cluster) {
+            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: cluster column not specified`, status: 400 };
+        }
+
+        if (!metrics.length) {
+            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: metric columns not found`, status: 400 };
+        }
+
+        if (!clusterTable?.name) {
+            return { message: 'not enough widget params: clusterTable name', status: 400 };
+        }
+
+        if (clusterTable?.name && !pg.pk?.[clusterTable?.name]) {
+            return { message: 'invalid widget params: clusterTable pkey not found', status: 404 };
+        }
+
+        const { total = 0 } = pg.pk?.[table]
+            ? await pg.queryCache(`select oid::regclass as table, reltuples AS total from pg_class`)
+                .then((res) => res.rows?.find((row) => row.table === table))
+            : {};
+
+        const { bbox } = await pg.query(`select st_asgeojson(box2d(geom))::json as bbox from ${table} where ${where || '1=1'}`).then((res1) => res1.rows?.[0] || {});
+
+        // get sql
+        const { optimizedSQL } = filter || search
+            ? await funcs.getFilterSQL({ pg, table, filter, search })
+            : {};
+
+        const q = `select "${cluster}" as name, sum("${metrics[0]}")::float as metric 
+        from ${optimizedSQL ? `(${optimizedSQL})` : table} q 
+        left join lateral (select "${pg.pk?.[clusterTable?.name]}" as id from ${clusterTable?.name} where ${clusterTable?.title}=q."${cluster}" limit 1)b on 1=1
+        where ${where} group by ${cluster}, b.id`;
+
+        if (query.sql === '1') return q;
+
+        // auto Index
+        //  funcs.autoIndex({ table, columns: (metrics || []).concat([cluster]) });
+
+        const { rows = [] } = await pg.query(q);
+        const vals = rows.map(el => el.metric - 0).sort((a, b) => a - b);
+        const len = vals.length;
+        const sizes = [vals[0], vals[Math.floor(len / 4)], vals[Math.floor(len / 2)], vals[Math.floor(len * 0.75)], vals[len - 1]]
+        return { sizes, rows, bbox, count: rows.length, total };
+    } catch (err) {
+        log.error('bi/cluster', { error: err.toString(), query });
+        return { error: err.toString(), status: 500 };
+    }
+}

package/server/routes/map/controllers/clusterVtile.js

@@ -0,0 +1,143 @@
+import Sphericalmercator from '@mapbox/sphericalmercator';
+
+import path from 'path';
+import { createHash } from 'crypto';
+import { writeFile, mkdir } from 'fs/promises';
+
+import { getWidget } from '../../../../utils.js';
+
+const mercator = new Sphericalmercator({ size: 256 });
+
+const clusterExists = {};
+
+export default async function clusterVtile(req, reply) {
+    const {
+        pg, funcs, params = {}, query = {}, log,
+    } = req;
+    const { z, y } = params;
+    const x = params.x?.split('.')[0] - 0;
+
+    if (!x || !y || !z) {
+        return { message: 'not enough params: xyz', status: 400 };
+    }
+
+    const {
+        widget, filter, dashboard, search, clusterZoom, nocache, pointZoom,
+    } = query;
+
+    if (!widget) {
+        return { message: 'not enough params: widget', status: 400 };
+    }
+
+
+    const { data } = await getWidget({ dashboard, widget })
+
+
+    const headers = {
+        'Content-Type': 'application/x-protobuf',
+        'Cache-Control': nocache || query.sql
+            ? 'no-cache'
+            : 'public, max-age=86400',
+    };
+
+    const hash = [pointZoom, filter].filter((el) => el).join();
+
+    const root = funcs.getFolder(req);
+    const file = path.join(root, `/map/vtile/${widget}/${hash ? `${createHash('sha1').update(hash).digest('base64')}/` : ''}${z}/${x}/${y}.mvt`);
+
+    try {
+
+
+        if (!data?.table) {
+            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: table not specified`, status: 400 };
+        }
+
+        const pkey = pg.pk?.[data?.table];
+
+        if (!pkey) {
+            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: table pk not found (${data?.table})`, status: 400 };
+        }
+
+        // data param 
+        const { table, query: where = '1=1', metrics = [], cluster, clusterTable = {} } = data;
+        if (!clusterTable?.name) {
+            Object.assign(data, { clusterTable: { name: 'bi.cluster', title, query: `type='${data.cluster}'` } });
+        }
+
+        if (!clusterExists[data?.cluster]) {
+            // const res = await fetch('https://cdn.softpro.ua/data/bi/region-ua.json');
+            // if (res?.status !== 200) {
+            // }
+            // await pg.query(`insert into bi.cluster (title,type,geom) values()`);
+            // clusterExists[data?.cluster] = 1;
+        }
+
+        if (!cluster) {
+            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: cluster column not specified`, status: 400 };
+        }
+
+        if (!metrics.length) {
+            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: metric columns not found`, status: 400 };
+        }
+
+        // get sql
+        const { optimizedSQL } = filter || search
+            ? await funcs.getFilterSQL({ pg, table, filter, search })
+            : {};
+
+        const q = `select "${cluster}" as name, sum("${metrics[0]}")::float as metric, b.* 
+        from ${optimizedSQL ? `(${optimizedSQL})` : table} q 
+            left join lateral (select "${pg.pk?.[clusterTable?.name]}" as id,
+                ${clusterTable?.geom || 'geom'} as geom from ${clusterTable?.name} 
+                where ${clusterTable?.query || '1=1'} and ${clusterTable?.title}=q."${cluster}" limit 1
+            )b on 1=1 
+        where ${where} group by 
+        ${cluster}, b.id, b.${clusterTable?.geom || 'geom'}`;
+
+        if (query.sql === '1') return q;
+
+        const geomCol = parseInt(z, 10) < parseInt(pointZoom, 10) ? `ST_Centroid(${clusterTable?.geom || data?.geom || 'geom'})` : clusterTable?.geom || data?.geom || 'geom';
+
+        const bbox = mercator.bbox(+y, +x, +z, false/* , '900913' */);
+        const bbox2d = `'BOX(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d`;
+
+        const q1 = `SELECT ST_AsMVT(q, 'bi', 4096, 'geom','row') as tile
+            FROM (
+                SELECT  
+                floor(random() * 100000 + 1)::int + row_number() over() as row,
+
+                ${pg.pk?.[clusterTable?.name] ? 'id,' : ''} name, metric,
+
+                ST_AsMVTGeom(st_transform(${geomCol}, 3857),ST_TileEnvelope(${z},${y},${x})::box2d,4096,256,false) as geom
+
+                FROM (select * from (${q})q where geom && ${bbox2d} 
+                
+                and geom is not null and st_srid(geom) >0
+
+                and ST_GeometryType(geom) = any ('{ "ST_Polygon", "ST_MultiPolygon" }')
+                
+                limit 3000)q
+            ) q`;
+
+        if (query.sql === '2') return q1;
+
+        // auto Index
+        funcs.autoIndex({ table, columns: (metrics || []).concat([cluster]) });
+
+        const { rows = [] } = await pg.query(q1);
+
+        if (query.sql === '3') return rows.map((el) => el.tile);
+
+        const buffer = Buffer.concat(rows.map((el) => Buffer.from(el.tile)));
+
+        if (!nocache) {
+            await mkdir(path.dirname(file), { recursive: true });
+            await writeFile(file, buffer, 'binary');
+        }
+
+        return reply.headers(headers).send(buffer);
+    } catch (err) {
+        log.error('bi/clusterVtile', { error: err.toString(), query, params });
+        return { error: err.toString(), status: 500 };
+    }
+}

package/server/routes/map/controllers/geojson.js

@@ -8,6 +8,8 @@ import { existsSync, /*readdirSync, */ readFileSync } from 'fs';
 import yaml from '../../dashboard/controllers/utils/yaml.js';
 import normalizeData from '../../data/controllers/util/normalizeData.js';
 
+import { getWidget } from '../../../../utils.js';
+
 const types = { point: 'ST_Point' /* ,ST_MultiPoint */, polygon: 'ST_Polygon,ST_MultiPolygon' };
 const hourMs = 3.6e+6;
 
@@ -19,20 +21,12 @@ export default async function geojson(req, reply) {
 
   const { filter, widget, sql, type, nocache, id, dashboard, geom = 'geom', pointZoom = 0 } = query;
 
-  const { config = {} } = funcs;
-
   if (!widget && !dashboard) {
     return { message: 'not enough params: widget', status: 400 };
   }
 
-  const cwd = process.cwd();
-  const widgetDir = dashboard ? path.join(cwd, 'server/templates/dashboard', dashboard) : path.join(cwd, 'server/templates/widget');
-
-  const filePath = dashboard ? path.join(widgetDir, widget || 'index' + '.yml') : path.join(widgetDir, widget + '.yml');
-
-  if (!existsSync(filePath)) {
-    return { message: { root: config?.local ? widgetDir : undefined, error: `not found`, widget }, status: 404 };
-  }
+  const data = await getWidget({ dashboard, widget });
+  if (data.status) return data;
 
   const hash = [pointZoom, filter].filter((el) => el).join();
 
@@ -50,29 +44,21 @@ export default async function geojson(req, reply) {
   }
 
   try {
-    const fileData = readFileSync(filePath, 'utf-8');
-    const { data = {}, table_name: tableName } = filePath.includes('.yml') ? yaml.loadSafe(fileData) : {};
-    if (!data?.table && tableName) Object.assign(data, { table: tableName });
-
-    if (!data?.table) {
-      return { message: `invalid ${widget ? 'widget' : 'dashboard'}: table not specified`, status: 400 };
-    }
-
     const pkey = pg.pk?.[data?.table];
     if (!pkey) {
       return { message: `invalid ${widget ? 'widget' : 'dashboard'}: table pk not found (${data?.table})`, status: 400 };
     }
 
     // data param 
-    const { table, where = '1=1', xName = {}, x } = normalizeData(data, query);
+    const { table, where = '1=1', xName, x } = normalizeData(data, query);
 
-    if (!xName?.name && !x) {
+    if (!xName && !x) {
       return { message: `invalid ${widget ? 'widget' : 'dashboard'}: x axis column not specified`, status: 400 };
     }
 
     // get sql
     const filterQ = filter ? await funcs.getFilterSQL({ pg, table, filter, query }) : undefined;
-    const q = `select "${pkey}", "${xName?.name || x}", /* st_asgeojson(geom)::json as */ ${geom} as geom from ${filterQ ? `(${filterQ})` : table} q where ${where}`;
+    const q = `select "${pkey}", "${xName || x}", /* st_asgeojson(geom)::json as */ ${geom} as geom from ${filterQ ? `(${filterQ})` : table} q where ${where}`;
 
     if (sql === '1') return q;
 
@@ -85,7 +71,7 @@ export default async function geojson(req, reply) {
       ? `st_transform(${type === 'centroid' ? `st_centroid(${geom})` : geom},${query.srid})`
       : `${type === 'centroid' || query.point || query.centroid ? `st_centroid(${geom})` : geom}`}), 6, 0)::json as geometry,    
       (select row_to_json(tc) from (select ${'' ? `${''} as status, ` : ''} 
-      ${xName?.name ? `${xName?.name},` : ''} 
+      ${xName ? `${xName},` : ''} 
       ${data.style?.colorAttr ? `${data.style.colorAttr},` : ''}
       ${pkey} as id,(select file_path from crm.files 
         where entity_id=q.${pkey}::text and file_status <>'3' and ext in ('png','jpg') limit 1) as image
@@ -99,7 +85,7 @@ export default async function geojson(req, reply) {
     if (sql === '2') return q1;
     
     // auto Index
-    funcs.autoIndex({ table, columns: [xName.name] });
+    funcs.autoIndex({ table, columns: [xName] });
 
     const res = await pg.query(q1).then((res) => res.rows?.[0] || {});