@opengis/bi 1.2.0 → 1.2.2

package/server/routes/dataset/utils/executeQuery.js

@@ -0,0 +1,46 @@
+import { pgClients } from '@opengis/fastify-table/utils.js';
+
+import insertDataQuery from './insertDataQuery.js';
+
+const insertDataset = `insert into bi.dataset 
+(name, table_name, dataset_file_path, column_list, pk, data_source, uid)
+values($1,$2,$3,$4,$5,$6,$7) returning dataset_id`;
+
+const updateAppeal = 'update datasets_appeal.appeal set dataset_id=$1, data_key=$2 where ap_id=$3';
+
+export default async function executeQuery({
+  pg = pgClients.client, sql, data, name, id, table, relPath, columns, pkey, source, user, url, dataKey,
+}) {
+  const client = await pg.connect();
+  try {
+    await client.query('BEGIN');
+
+    // create table
+    await client.query(sql);
+
+    // insert data
+    if (data) {
+      const insertData = insertDataQuery(columns, data, table);
+      await client.query(insertData);
+    }
+
+    // create dataset
+    const args = [name || id, table, relPath, columns ? JSON.stringify(columns) : null, pkey, JSON.stringify({ type: source, appeal: id, url }), user?.uid];
+    const datasetId = await client.query(insertDataset, args).then(el => el.rows?.[0]?.dataset_id);
+
+    if (id) {
+      // update appeal for public only, admin w/o appeal
+      await client.query(updateAppeal, [datasetId, dataKey, id]);
+    }
+
+    await client.query('COMMIT');
+    return { datasetId };
+  }
+  catch (err) {
+    await client.query('ROLLBACK');
+    return { error: err.toString(), status: 500 };
+  }
+  finally {
+    client.release();
+  }
+}

package/server/routes/dataset/utils/getLayersData.js

@@ -0,0 +1,107 @@
+import descriptionList from "./descriptionList.js";
+import metaFormat from "./metaFormat.js";
+
+async function getDataByLatLng({ pg, layer, table, id, lat, lng, time = [] }) {
+    // const rclient = getRedis();
+    // const redisKey = `${pg.options.database}:gis-format:${layer}:${lat}:${lng}`;
+    // const cacheData = await rclient.get(redisKey);
+    // if (cacheData && !config.local) return JSON.parse(cacheData);
+
+    const { rows: styles = [] } = await pg.query(`select style_id as id, dataset 
+    from gis.style where style_id=any($1::text[])
+      union all
+    select dataset_id as id, json_build_array(json_build_object('pk', pk, 'table', table_name, 'query', query, 'card', setting->>'card', 'columns', column_list)) as dataset 
+    from bi.dataset a where dataset_id=any($1::text[])`, [layer.split(',')]);
+    time.push(Date.now());
+
+    if (!styles?.length) {
+        return { message: `style not found: ${layer}`, status: 400 };
+    }
+
+    const { srids } = await pg.queryCache?.('select json_agg(srid) as srids from spatial_ref_sys').then((res1) => res1.rows?.[0] || {}) || {};
+
+    const layers = styles.reduce((acc, curr) => {
+        curr.dataset?.filter((el) => el.table && (el.pk || pg.pk?.[el.table]))
+            ?.forEach((el) => acc.push({
+                layer: curr.id,
+                pk: el.pk || pg.pk?.[el.table],
+                key: el.key,
+                table: el.table,
+                query: el.query,
+                template: el.card,
+                column_list: el.column_list,
+                columns: el.columns || el.column_list?.map((el) => el.name)?.join(','),
+                srid: el.srid || '4326',
+                geom: el.geom || 'geom',
+                step: srids?.includes(el.srid - 0) && el.srid !== '4326' ? 10 : 0.0002,
+            }));
+        return acc;
+    }, [])
+        .filter((el) => el.pk && el.layer)
+        .filter((el) => table ? el.table === table : true);
+
+    if (!layers.length) {
+        return { message: 'data not found', status: 404 };
+    }
+
+    const point = `srid=4326;point(${lng} ${lat})`;
+
+    // ${el.columns?.split?.filter?.((el) => el) ? `,${el.columns?.split?.filter?.((el) => el) || ''}` : ''}
+
+    const q = layers.map((el) => `select ${el.pk}, '${el.layer}' as layer,
+    row_to_json(t) as data,
+    st_asgeojson(${el.geom})::json as geom from ${el.table} t 
+    where ${el.query || '1=1'} and ${id ? `${el.pk}::text='${id.replace(/'/g, "''")}'` : '1=1'}
+    and case
+      when ST_GeometryType(geom) in ('ST_Polygon','ST_MultiPolygon')
+      then st_intersects(geom,st_buffer('${point}',${el.step}))
+  
+      when ST_GeometryType(geom) in ('ST_Line','ST_MultiLineString')
+      then st_distance(geom,'${point}') < ${el.step}
+    else false end`).join(' union all ');
+
+    // if (config.local && config.debug) console.log(q);
+    const { rows: objects = [] } = await pg.query(q) || {};
+    time.push(Date.now());
+
+    const rows = objects.map((row) => {
+        const layerData = layers.find((el) => el.layer === row?.layer) || {};
+        const rowData = layerData?.columns?.split?.filter?.((el) => el) ? layerData?.columns?.split?.filter?.((el) => el).reduce((acc, curr) => Object.assign(acc, { [curr]: row.data?.[curr] }), {}) : row.data;
+        return {
+            ...rowData,
+            ...row,
+            ...layerData,
+            data: undefined,
+            id: layerData.pk ? row?.[layerData.pk] : undefined,
+            geom: row.geom,
+        };
+    });
+
+    const { pk, layer: layerId, card, template } = rows[0] || {};
+
+    const dataset = layers.find((el) => el.layer === rows?.[0]?.layer) || {};
+
+    const columnList = (dataset.column_list || dataset.columns)?.reduce?.((acc, curr) => Object.assign(acc, { [curr.name]: curr.title || curr.ua || curr.name }), {}) || {};
+
+    const columns = card
+        ? Object.keys(card).map(el => `${el}| ${card[el]}`).join('|')
+        : Object.keys(columnList)?.map((key) => `${columnList[key]}| ${key}`).join('|');
+
+    const html = columns && rows?.[0] ? await descriptionList(rows[0], { hash: { columns } }) : undefined;
+    time.push(Date.now());
+
+    await Promise.all(rows.map(async () => {
+        const layerData = layers.find((el) => el.layer === rows?.[0]?.layer) || {};
+        const columns = layerData.column_list || layerData.columns;
+        if (columns?.length && Array.isArray(columns)) {
+            await metaFormat({ rows, columns });
+        }
+    }));
+    time.push(Date.now());
+
+    const resp = { id: rows?.[0]?.[pk], layers: layerId, template, data: rows?.[0], rows, html };
+
+    // await rclient.set(redisKey, JSON.stringify(resp), 'EX', 5 * 60);
+    return resp;
+}
+export default getDataByLatLng

package/server/routes/dataset/utils/getTableData.js

@@ -0,0 +1,47 @@
+import { handlebars } from "@opengis/fastify-table/utils.js";
+
+import descriptionList from "./descriptionList.js";
+// import metaFormat from "./metaFormat.js";
+
+async function getDataById({ pg, table, id, time = [] }) {
+    const dataset = await pg.query(`select dataset_id as id, pk, query, table_name, column_list, setting
+    from bi.dataset where dataset_id=$1`, [table]).then((res) => res.rows[0] || {});
+    time.push(Date.now());
+
+    if (!dataset?.id) {
+        return { message: `dataset not found: ${table}`, status: 400 };
+    }
+
+    if (!dataset?.table_name) {
+        return { message: 'invalid dataset: empty params table', status: 400 };
+    }
+
+    const pk = dataset.pk || pg.pk?.[dataset.table_name];
+
+    const { rows = [] } = pk ? await pg.query(`select *, ${pk}, geom::json from ${dataset.table_name} where ${dataset.query || '1=1'} and ${pk}=$1`, [id]) || {} : {};
+    if (pk) rows.forEach((row) => Object.assign(row, { id: row?.[pk] }));
+    time.push(Date.now());
+
+    // sql columns
+    const sql = `select attname as name, pg_catalog.col_description(attrelid,attnum) as title, atttypid::regtype as type from  pg_catalog.pg_attribute a 
+                        where attrelid='${dataset.table_name}'::regclass and attnum>0 
+                        and attname not in ('editor_id','editor_date','cdate','geom','id','uid','cdate')
+                        and atttypid::regtype not in ('json','geometry')`;
+
+    // card or auto
+    const type = dataset.setting?.card_type || 'auto';
+    const list = dataset.setting?.card_list || [];
+    const { rows: all } = await pg.query(sql).then(el => el);
+    const columns = all.filter(el => type === 'list' ? list.includes(el.name) : true)
+        .map(el => `${el.title || el.name}| ${el.name}`).join('|')
+
+
+    const { body } = type === 'html' && dataset?.setting?.card ? await pg.query(`select body->>'body' as body from admin.doc_template where title=$1`, [dataset?.setting?.card]).then(el => el.rows[0] || {}) : {}
+
+    const html = body ? await handlebars.compile(body)(rows[0]) : await descriptionList(rows[0], { hash: { columns } });
+    time.push(Date.now());
+
+
+    return { id: rows?.[0]?.id, template: dataset?.setting?.card, rows, html, body };
+}
+export default getDataById

package/server/routes/dataset/utils/insertDataQuery.js

@@ -0,0 +1,12 @@
+export default function insertDataQuery(columns, data, table) {
+  const columnList = columns?.map((el) => el.name)?.join(',');
+  const features = data?.features || [];
+  if (!features?.length) return null;
+
+  const insertData = `INSERT into ${table} (geom ${columns?.length ? ','.concat(columnList) : ''}) SELECT public.ST_GeomFromGeoJSON((features->>'geometry')::json) AS geom 
+        ${columns?.length ? ','.concat(columns?.map((el) => `features->'properties'->>'${el.title}'`)?.join(',')) : ''} FROM 
+        (SELECT json_array_elements('${JSON.stringify(features).replace(/'/g, "''")}'::json) AS features)q`;
+
+  // console.log(insertData);
+  return insertData;
+}

package/server/routes/dataset/utils/metaFormat.js

@@ -0,0 +1,24 @@
+import { getSelectVal } from '@opengis/fastify-table/utils.js';
+
+export default async function metaFormat({ rows, columns }) {
+  const selectCols = columns?.filter?.((el) => el.data);
+  if (!selectCols?.length) return rows;
+
+  await Promise.all(selectCols.map(async (attr) => {
+    const values = [...new Set(rows?.map((el) => el[attr.name]).flat())].filter((el) => (typeof el === 'boolean' ? true : el));
+    if (!values.length) return null;
+
+    const cls = await getSelectVal({ name: attr.data, values });
+    if (!cls) return null;
+
+    rows.forEach(el => {
+      const val = el[attr.name]?.map?.(c => cls[c.toString()] || cls[c] || c) || cls[el[attr.name]?.toString()] || cls[el[attr.name]] || el[attr.name];
+      if (!val) return;
+      Object.assign(el, { [val?.color ? `${attr.name}_data` : `${attr.name}_text`]: (val.color ? val : val.text || val) });
+    });
+
+    return null;
+  }));
+
+  return rows;
+}

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

@@ -0,0 +1,36 @@
+import { pgClients, dataInsert, getPGAsync } from "@opengis/fastify-table/utils.js";
+
+export default async function dashboardAdd(req, reply) {
+  const {
+    pg = pgClients.client,
+    body = {},
+  } = req;
+  const time = Date.now();
+
+  if (body?.db) {
+    try {
+      const pg1 = await getPGAsync(body.db);
+      await pg1.query('select 1');
+    } catch (err) {
+      return reply.status(400).send('Некоректна база даних');
+    }
+  }
+
+  const res = await dataInsert({
+    pg,
+    table: 'bi.dashboard',
+    data: body,
+  }).then(el => el.rows?.[0] || {});
+
+  if (res.dashboard_id && body.dataset) {
+    await pg.query(`update bi.dataset set dashboard_list=coalesce(dashboard_list, '{}'::text[]) || array[$1]
+    where dataset_id=$2`, [res.dashboard_id, body.dataset]);
+  }
+
+  return {
+    time: Date.now() - time,
+    id: res.dashboard_id,
+    title: res.title,
+    name: res.name,
+  };
+}

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

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import { existsSync, readdirSync } from 'node:fs';
+
+import { pgClients, dataDelete } from '@opengis/fastify-table/utils.js';
+
+const cwd = process.cwd();
+const dashboardDir = path.join(cwd, 'server/templates/dashboard');
+
+export default async function dashboardDelete({ pg = pgClients.client, params = {}, user }, reply) {
+  if (!params?.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+
+  const dirContent = existsSync(dashboardDir)
+    ? readdirSync(dashboardDir)
+    : [];
+
+  if (dirContent.includes(params.id)) {
+    return reply.status(403).send(`access restricted: ${params.id}`);
+  }
+
+  const { rowCount = 0 } = pg.pk?.['bi.dashboard']
+    ? await pg.query('select * from bi.dashboard where $1 in (dashboard_id,name)', [params.id])
+    : {};
+
+  if (rowCount === 0) {
+    return reply.status(404).send(`not found ${params.id}`);
+  }
+
+  await pg.query(`delete from bi.widget where $1 in (dashboard_id)`, [params.id]);
+  await dataDelete({
+    pg,
+    table: 'bi.dashboard',
+    id: params.id,
+    uid: user?.uid,
+  });
+
+  return reply.status(200).send('successfully deleted');
+}

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

@@ -0,0 +1,61 @@
+import { dataUpdate, pgClients, getPGAsync } from "@opengis/fastify-table/utils.js";
+
+export default async function dashboardEdit({
+  pg = pgClients.client, params = {}, body = {},
+}, reply) {
+  const { name: dashboardName } = params;
+  const { panels, widgets, table_name: tableName } = body;
+
+  if (body?.db) {
+    try {
+      const pg1 = await getPGAsync(body.db);
+      await pg1.query('select 1');
+    } catch (err) {
+      return reply.status(400).send('Некоректна база даних');
+    }
+  }
+
+  if (!dashboardName) {
+    return reply.status(400).send('not enough params: name');
+  }
+
+  if (!tableName) {
+    return reply.status(400).send('not enough params: table_name');
+  }
+
+  const row = await pg.query('select dashboard_id, widgets, panels from bi.dashboard where $1 in (dashboard_id, name)', [dashboardName])
+    .then(el => el.rows?.[0] || {});
+  const { dashboard_id: dashboardId } = row;
+
+  if (!dashboardId) {
+    return reply.status(400).send('dashboard not found');
+  }
+
+  if (panels?.length && !widgets?.length) {
+    row.widgets.forEach((el) => {
+      const { title } = panels?.find?.(item => item.widget === el.name) || {};
+      if (el.data) {
+        // console.log('el.title', el.title, 'title', title);
+        el.data.title = title;
+      }
+    });
+    Object.assign(body, { widgets: row.widgets });
+  }
+
+  const res = await dataUpdate({
+    pg,
+    table: 'bi.dashboard',
+    id: dashboardId,
+    data: body,
+  });
+
+  if (!Object.keys(res)?.length) {
+    return reply.status(404).send('not found data');
+  }
+
+  return {
+    message: `updated ${dashboardName}`,
+    status: 200,
+    rows: res,
+  };
+}

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

@@ -0,0 +1,78 @@
+import { createHash } from 'node:crypto';
+import { dataInsert, dataUpdate, getPGAsync, pgClients } from "@opengis/fastify-table/utils.js";
+
+/* eslint-disable import/extensions */
+import { yamlSafe } from '../../../../utils.js';
+
+function generateUniqueName(prefix = 'bar') {
+  const randomPart = Math.floor(Math.random() * 10000);
+  const timestamp = Date.now();
+  return `${prefix}_${randomPart}_${timestamp}`;
+}
+
+export default async function widgetAdd({ pg = pgClients.client, params = {}, body = {} }) {
+  const { name: dashboardName } = params;
+  if (!dashboardName) {
+    return { message: 'not enough params: id', status: 400 };
+  }
+  const data = body.yml ? yamlSafe.load(body.yml) : body;
+
+  const row = await pg.query(`select dashboard_id, widgets, panels, table_name, db from bi.dashboard 
+  where $1 in (dashboard_id,name)`, [dashboardName]).then(el => el.rows?.[0] || {});
+
+  const pg1 = row?.db ? await getPGAsync(row.db) : pg;
+
+  const tableName = data.data?.table
+    || data?.table
+    || data.table_name
+    || row.table_name;
+
+  const loadTemplate = pg1.pk?.['admin.doc_template'] ? await pg1.query(
+    'select body from admin.doc_template where doc_type=5 and title=$1',
+    [tableName]
+  ).then(el => el.rows?.[0]?.body) : null;
+
+  if (!tableName || !(pg.pk?.[loadTemplate?.table || tableName] || pgClients[data.db || row.db || 'client']?.pk?.[loadTemplate?.table || tableName])) {
+    return { message: 'bad params: table', status: 400 };
+  }
+
+  const { dashboard_id: dashboardId } = row;
+
+  const metric = data.data?.metrics || data.data?.metric || data?.metrics || data?.metric;
+  Object.assign(data, {
+    name: generateUniqueName(data.type),
+    table_name: tableName,
+    metrics: Array.isArray(metric) ? metric[0] : metric,
+  });
+
+  data.widget_id = createHash('md5').update([data?.name, dashboardId].join()).digest('hex').substr(0, 10);
+
+  const res = await dataUpdate({
+    pg,
+    table: 'bi.dashboard',
+    id: dashboardId,
+    data: {
+      widgets: [data].concat(row.widgets || []),
+      panels: [{ widget: data.name, col: data.col || 3, height: data.data?.height }].concat(
+        row.panels || []
+      ),
+    },
+  });
+
+  const widgetData = { ...data, data, dashboard_id: dashboardId };
+  if (body?.yml) Object.assign(widgetData, { yml: body.yml });
+
+  await dataInsert({
+    pg,
+    table: 'bi.widget',
+    data: widgetData,
+  });
+
+  return {
+    dashboard: dashboardName,
+    widgetId: data.widget_id,
+    widgetName: data.name,
+    status: 200,
+    rows: res,
+  };
+}

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

@@ -0,0 +1,58 @@
+import { dataDelete, dataUpdate, pgClients } from '@opengis/fastify-table/utils.js';
+
+export default async function widgetDel({ pg = pgClients.client, params = {} }) {
+  const { widget: widgetName, name: dashboardName } = params;
+
+  if (!widgetName || !dashboardName) {
+    return {
+      message: 'not enough params: dashboard and widget name',
+      status: 400,
+    };
+  }
+
+  const row = await pg.query(`select a.widget_id, b.dashboard_id from bi.widget a, bi.dashboard b
+    where $2 in (a.widget_id, a.name) and $1 in (b.dashboard_id, b.name) order by 1,2`, [dashboardName, widgetName])
+    .then(el => el.rows?.[0] || {});
+
+  const { widget_id: widgetId, dashboard_id: dashboardId } = row || {};
+
+  if (!widgetId) {
+    return { message: `widget not found ${widgetName}`, status: 404 };
+  }
+
+  await dataDelete({
+    pg,
+    table: 'bi.widget',
+    id: widgetId,
+  });
+
+  const currentDashboard = await pg.query('select * from  bi.dashboard where $1 in (dashboard_id, name)', [dashboardName])
+    .then(el => el.rows?.[0] || {});
+
+  const body = currentDashboard;
+
+  if (!currentDashboard) {
+    return { message: `dashboard not found ${dashboardName}`, status: 404 };
+  }
+  body.panels =
+    Array.isArray(body.panels) && body.panels?.length
+      ? body.panels?.filter((panel) => panel.widget !== widgetName)
+      : undefined;
+  body.widgets =
+    Array.isArray(body.widgets) && body?.widgets?.length
+      ? body.widgets?.filter((widget) => widget.name !== widgetName)
+      : undefined;
+
+  const res1 = await dataUpdate({
+    pg,
+    table: 'bi.dashboard',
+    id: dashboardId,
+    data: body,
+  });
+
+  return {
+    message: `Deleted widget ${widgetName}`,
+    status: 200,
+    rows: res1,
+  };
+}

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

@@ -0,0 +1,106 @@
+import { dataUpdate, pgClients } from '@opengis/fastify-table/utils.js';
+
+import { getWidget, yamlSafe } from '../../../../utils.js';
+
+export default async function widgetEdit({ pg = pgClients.client, body, params }) {
+  const { widget: widgetName, name: dashboardName } = params;
+  const data = body.yml && !body.style ? yamlSafe.load(body.yml) : body;
+  const yml = body.yml ?? yamlSafe.dump(body.data);
+  // console.log(body.data, data, body.yml, yml);
+
+  if (!widgetName || !dashboardName) {
+    return {
+      message: 'not enough params: dashboard and widget name',
+      status: 400,
+    };
+  }
+
+  const { widget_id: widgetId, dashboard_id: dashboardId, widgets } = await pg.query(
+    `select a.widget_id , b.dashboard_id, b.widgets from bi.widget a, bi.dashboard b
+    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] || {});
+
+  // get Data
+  const templateData = await getWidget({ pg, dashboard: dashboardName, widget: widgetName });
+  if (!templateData) {
+    return { message: `widget not found ${widgetName}`, status: 404 };
+  }
+
+  if (data?.data) {
+    Object.assign(data, {
+      data: Object.keys(data.data || {})
+        ?.reduce?.((acc, curr) => ({ ...acc, [curr]: data.data[curr] === 'null' ? null : data.data[curr] }), {})
+    });
+  }
+  const widgetData = ['style', 'data', 'type', 'title', 'controls', 'query', 'cls', 'x']
+    .filter(el => data[el])
+    .reduce((p, el) => ({ ...p, [el]: data[el] }), {});
+
+  // get table
+  const tableName = body.table
+    || widgetData.data?.table_name
+    || widgetData.data?.table
+    || widgetData?.table_name
+    || templateData.table;
+
+  const loadTemplate = pg.pk?.['admin.doc_template'] ? await pg.query(
+    'select body from admin.doc_template where doc_type=5 and title=$1',
+    [tableName]
+  ).then(el => el.rows?.[0]?.body) : null;
+
+  if (!tableName || !(pg.pk?.[loadTemplate?.table || tableName] || pgClients[widgetData?.data?.db || templateData?.db || 'client']?.pk?.[loadTemplate?.table || tableName])) {
+    return { message: 'bad params: table ' + tableName, status: 400 };
+  }
+
+  if (yml) {
+    Object.assign(widgetData, { yml })
+  }
+
+  Object.assign(widgetData, { table_name: tableName, data: { ...widgetData?.data || {}, table_name: tableName } });
+  console.log(widgetData);
+  const rows = await dataUpdate({
+    pg,
+    table: 'bi.widget',
+    id: widgetId,
+    data: widgetData,
+  });
+
+  const idx = widgets?.findIndex?.(el => el.name === widgetName)?.toString?.() || -1;
+  if (widgetData.hasOwnProperty('table_name') && idx > -1) {
+    widgets[idx].table_name = tableName;
+    widgets[idx].table = tableName;
+  }
+  if (widgetData.hasOwnProperty('data') && idx > -1) {
+    widgets[idx].data = widgetData.data
+  }
+  if (widgetData.hasOwnProperty('yml') && idx > -1) {
+    widgets[idx].yml = widgetData.yml;
+  }
+  if (widgetData.hasOwnProperty('style') && idx > -1) {
+    widgets[idx].style = widgetData.style;
+  }
+  if (widgetData.hasOwnProperty('type') && idx > -1) {
+    widgets[idx].type = widgetData.type;
+  }
+  if (widgetData.data?.type === 'text' && idx > -1) {
+    widgets[idx].data.text = widgetData.data?.text;
+  }
+  if (typeof widgetData?.query === 'string' && idx > -1) {
+    widgets[idx].data.query = widgetData.query;
+  }
+  if (typeof widgetData?.cls === 'string' && idx > -1) {
+    widgets[idx].data.cls = widgetData.cls;
+  }
+  if (typeof widgetData?.x === 'string' && idx > -1) {
+    widgets[idx].data.x = widgetData.x;
+  }
+
+  await dataUpdate({
+    pg,
+    table: 'bi.dashboard',
+    id: dashboardId,
+    data: { widgets },
+  });
+
+  return { message: rows, status: 200 };
+}

package/server/routes/edit/index.mjs

@@ -0,0 +1,33 @@
+/* eslint-disable import/extensions */
+import widgetAdd from './controllers/widget.add.js';
+import widgetEdit from './controllers/widget.edit.js';
+import widgetDel from './controllers/widget.del.js';
+import dashboardEdit from './controllers/dashboard.edit.js';
+import dashboardAdd from './controllers/dashboard.add.js';
+import dashboardDelete from './controllers/dashboard.delete.js';
+
+const biSchema = {
+  type: 'object',
+  properties: {
+    querystring: {
+      widget: { type: 'string', pattern: '^([\\d\\w]+)$' },
+      dashboard: { type: 'string', pattern: '^([\\d\\w]+)$' },
+      list: { type: 'string', pattern: '^([\\d])$' },
+      sql: { type: 'string', pattern: '^([\\d])$' },
+    },
+    params: {
+      name: { type: 'string', pattern: '^([\\d\\w]+)$' },
+      widget: { type: 'string', pattern: '^([\\d\\w]+)$' },
+    },
+  },
+};
+
+export default async function route(fastify) {
+  fastify.post(`/bi-dashboard/:name`, { schema: biSchema }, widgetAdd);
+  fastify.put(`/bi-dashboard/:name/:widget`, { schema: biSchema }, widgetEdit);
+  fastify.delete(`/bi-dashboard/:name/:widget`, { schema: biSchema }, widgetDel);
+
+  fastify.post(`/bi-dashboard`, { schema: biSchema }, dashboardAdd);
+  fastify.put(`/bi-dashboard/:name`, { schema: biSchema }, dashboardEdit);
+  fastify.delete(`/bi-dashboard/:id`, {}, dashboardDelete);
+}