@opengis/bi 1.0.13 → 1.0.14

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

@@ -1,17 +1,19 @@
-
-
-//import autoIndex from '@opengis/fastify-table/pg/funcs/autoIndex.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 yaml from 'js-yaml';
+
+import {
+  getPGAsync,
+  autoIndex,
+  pgClients,
+  getSelectVal,
+} from '@opengis/fastify-table/utils.js';
 import chartSQL from './util/chartSQL.js';
 import normalizeData from './util/normalizeData.js';
 
 import { getWidget } from '../../../../utils.js';
 
-export default async function data({
-  funcs = {}, query = {},
-}) {
+export default async function dataAPI({ funcs = {}, query = {} }) {
   const time = Date.now();
   const { dashboard, widget, filter, search, samples } = query;
 
@@ -21,63 +23,119 @@ export default async function data({
 
   const { type, text, data = {}, controls, style, options } = widgetData;
 
-  const pg = data.db ? await getPGAsync(data.db) : pgClients.client
+  const pg = data.db ? await getPGAsync(data.db) : pgClients.client;
 
-  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] }))
+  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, cls, metric, table, where, tableSQL, groupby, xName } = normalizeData(widgetData, query, columnTypes);
+  // data param
+  const { x, cls, metric, table, where, tableSQL, groupby, xName } =
+    normalizeData(widgetData, query, columnTypes);
 
   // auto Index
   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))
+    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 ${tableSQL || table} group by ${groupby} order by count(*) desc limit 20`).then(el => el.rows) : null;
+  // get group
+  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 };
 
   const order = data.order || (type === 'listbar' ? 'metric desc' : null);
 
-  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 });
+  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: `(${optimizedSQL})q`, 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
 
   if (cls) {
-    const values = rows.map((row) => row[x])?.filter((el, idx, arr) => el && arr.indexOf(el) === idx);
+    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] });
-    });
+    rows
+      .filter((row) => row[x])
+      .forEach((row) => {
+        Object.assign(row, { [x]: vals?.[row[x]] || row[x] });
+      });
   }
 
-  const dimensions = fields.map(el => el.name);
+  const yml = widgetData.yml || yaml.dump(extractYml(widgetData));
+  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 : (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,
+    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,
+    yml,
     params: {
       x,
       cls,
@@ -91,7 +149,9 @@ export default async function data({
     columnTypes,
   };
   return res;
-
-
-
 }
+
+function extractYml(sourceData) {
+  const { title, description, type, data, style, controls } = sourceData;
+  return { title, description, type, data, style, controls };
+}

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

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

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

@@ -1,34 +1,56 @@
 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 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 x = (granularity ? `date_trunc('${granularity}',${xName})::date::text` : null) || xName;
-
-    const metrics = Array.isArray(data.metrics) ? data.metrics : [data.metrics];
-    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 { cls, table, filterCustom } = data;
-    const groupby = query.groupby || data.groupby;
-    //const orderby = query.orderby || data.orderby || 'count(*)';
-
-    const custom = query?.filterCustom?.split(',')
+  ['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 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 x =
+    (granularity
+      ? `date_trunc('${granularity}',${xName})::date::text`
+      : null) || xName;
+
+  const metrics = Array.isArray(data.metrics) ? data.metrics : [data.metrics];
+  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 { cls, table, filterCustom } = data;
+  const groupby = query.groupby || data.groupby;
+  // const orderby = query.orderby || data.orderby || 'count(*)';
+
+  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'}`;
+    ?.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;
+  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 }
+  return { x, cls, metric, table, where, tableSQL, groupby, xName };
 }
-export default normalizeData;
+export default normalizeData;

package/server/routes/data/index.mjs

@@ -2,19 +2,17 @@ import config from '../../../config.js';
 
 import data from './controllers/data.js';
 
-
 const biSchema = {
   querystring: {
     widget: { type: 'string', pattern: '^([\\d\\w]+)$' },
     dashboard: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    sql: { type: 'string', pattern: '^([\\d])$' }
+    sql: { type: 'string', pattern: '^([\\d])$' },
   },
   params: {
     id: { type: 'string', pattern: '^([\\d\\w]+)$' },
   },
 };
 
-
 export default async function route(fastify, opts) {
   const prefix = opts?.prefix || config.prefix || '/api';
   fastify.route({

package/server/routes/db/controllers/dbTablePreview.js

@@ -0,0 +1,63 @@
+const q = `select nspname||'.'||relname as table, json_agg(json_build_object('name',attname, 'type', a.atttypid::regtype, 'description', coalesce(col_description(attrelid, attnum),attname))) as columns
+from pg_attribute a
+left join pg_catalog.pg_attrdef d ON (a.attrelid, a.attnum) = (d.adrelid, d.adnum)
+JOIN pg_class AS i
+  ON i.oid = a.attrelid 
+JOIN pg_namespace AS NS ON i.relnamespace = NS.OID
+where a.attnum > 0 and nspname||'.'||relname = $1
+and not a.attisdropped
+group by nspname||'.'||relname limit 1`;
+
+export default async function dbTablePreview({ pg, params = {}, query = {} }) {
+  if (!params?.name) {
+    return { message: 'not enough params: name', status: 400 };
+  }
+
+  if (query.sql) return q;
+  try {
+    const { table, columns } = await pg
+      .query(q, [params.name])
+      .then((res) => res.rows?.[0] || {});
+    if (!table) {
+      return { message: 'table not found', status: 404 };
+    }
+
+    const { count = 0 } = await pg
+      .query(
+        `select reltuples as count from pg_class where oid  = to_regclass($1)`,
+        [params.name]
+      )
+      .then((res) => res.rows?.[0] || {});
+    const geom = columns.find((el) => el.type === 'geometry')?.name;
+    const { bounds, extentStr } = geom
+      ? await pg
+          .query(
+            `select count(*),
+      st_asgeojson(st_extent(${geom}))::json as bounds,
+      replace(regexp_replace(st_extent(${geom})::box2d::text,'BOX\\(|\\)','','g'),' ',',') as "extentStr"
+    from ${params.name}`
+          )
+          .then((res) => res.rows?.[0] || {})
+      : {};
+    const extent = extentStr ? extentStr.split(',') : undefined;
+
+    const systemColumns = [
+      'uid',
+      'files',
+      'editor_date',
+      'cdate',
+      'editor_id',
+      geom,
+    ];
+    const columnList = columns
+      .map((el) => el?.name)
+      .filter((el) => !systemColumns.includes(el));
+    const { rows = [] } = await pg.query(
+      `select ${columnList.join(',')} ${geom ? `, st_asgeojson(geom)::json as geom` : ''} from ${table} limit 10`
+    );
+
+    return { count, geom: !!geom, bounds, extent, columns, rows };
+  } catch (err) {
+    return { error: err.toString(), status: 500 };
+  }
+}

package/server/routes/db/controllers/dbTables.js

@@ -0,0 +1,36 @@
+export default async function dbTables({ pg, query = {} }) {
+  const q = `select 
+  t.table_schema ||'.'|| t.table_name as table, 
+  obj_description(to_regclass(t.table_schema ||'."'|| t.table_name||'"')) as description,
+  t.table_schema as schema,
+  (select reltuples from pg_class where oid  = to_regclass(t.table_schema ||'."'|| t.table_name||'"') ) as total,
+  coalesce(isgeom,false) as isgeom
+  
+  from information_schema.tables t
+  left join lateral(
+    select true as isgeom from information_schema.columns c 
+    where c.table_name = t.table_name 
+    and c.table_schema = t.table_schema and 'geometry'=c.udt_name limit 1
+  )c on 1=1
+  
+  where t.table_type = 'BASE TABLE'
+  and t.table_schema not in ('public','log','admin','feature_ir','gis', 'setting')
+  and t.table_name not like '%.%'
+  and regexp_replace(t.table_name, '^[[:digit:]]', '', 'g') = t.table_name
+  and 1=(SELECT count(*) FROM pg_catalog.pg_constraint con 
+    INNER JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
+    INNER JOIN pg_catalog.pg_namespace nsp ON nsp.oid = connamespace 
+    WHERE nsp.nspname = t.table_schema AND rel.relname = t.table_name and contype='p'
+  )
+  and ${query.schema ? `t.table_schema=$1` : '1=1'} order by total desc`;
+  if (query.sql) return q;
+  try {
+    const { rows = [] } = await pg.query(
+      q,
+      [query.schema].filter((el) => el)
+    );
+    return { rows };
+  } catch (err) {
+    return { error: err.toString(), status: 500 };
+  }
+}

package/server/routes/db/index.mjs

@@ -0,0 +1,17 @@
+import dbTables from './controllers/dbTables.js';
+import dbTablePreview from './controllers/dbTablePreview.js';
+
+export default async function route(fastify, opts) {
+  fastify.route({
+    method: 'GET',
+    url: '/db-tables',
+    schema: {},
+    handler: dbTables,
+  });
+  fastify.route({
+    method: 'GET',
+    url: '/db-tables/:name',
+    schema: {},
+    handler: dbTablePreview,
+  });
+}

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

@@ -2,20 +2,21 @@ export default async function widgetAdd({ pg, funcs, params = {}, body }) {
   try {
     const time = Date.now();
     const tableName = body.table_name;
-    const checkTable = await pg.query(`select * from bi.dashboard where $1 in (table_name)`, [
-      tableName
-    ]);
+    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
+      data: body,
     });
 
     return {
       time: Date.now() - time,
       message: `Added new dashboard, ID: '${res.rows[0].title}'`,
       status: 200,
-      rows: res.rows
+      rows: res.rows,
     };
   } catch (err) {
     return { error: err.toString(), status: 500 };

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

@@ -1,20 +1,27 @@
-export default async function dashboardEdit({
-  pg, funcs, params = {}, body = {},
-}, reply) {
+export default async function dashboardEdit(
+  { pg, funcs, params = {}, body = {} },
+  reply
+) {
   try {
     if (!params.name) {
       return {
-        message: "not enough params: dashboard name required",
+        message: 'not enough params: dashboard name required',
         status: 400,
-      }
+      };
     }
     const tableName = body.table_name;
-    const checkTable = await pg.query(`select * from bi.dashboard where $1 in (table_name)`, [
-      tableName
-    ]);
+    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 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;
 
     const res = await funcs.dataUpdate({

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

@@ -1,49 +1,73 @@
+/* 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, funcs, params = {}, body = {} }) {
   const { name: dashboardName } = params;
   if (!dashboardName) {
     return { message: 'not enough params: id', status: 400 };
   }
-  const tableName = body.table_name;
+  const data = body.yml ? yamlSafe.load(body.yml) : body;
   try {
     const row = await pg
       .query(
-        `select dashboard_id, widgets, panels from bi.dashboard where $1 in (dashboard_id,name)`,
+        'select dashboard_id, widgets, panels, table_name 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 tableName =
+      data.data?.table || data?.table || data.table_name || row.table_name;
+
+    // const checkTable = await pg.query(
+    //   'select * from bi.widget where $1 in (table_name)',
+    //   [tableName]
+    // );
+    // if (!checkTable.rows.length) {
+    //   return { message: 'bad params', status: 400 };
+    // }
+    if (!tableName || !pg.pk?.[tableName]) {
+      return { message: 'bad params: table', status: 400 };
+    }
 
     const { dashboard_id: dashboardId } = row;
 
-    const generatedName = generateUniqueName(body.type);
-    body.name = generatedName;
+    Object.assign(data, {
+      name: generateUniqueName(data.type),
+      table_name: tableName,
+      metrics:
+        (data.data?.metrics || data?.metrics)?.[0] ||
+        data.data?.metrics ||
+        data?.metrics,
+    });
+
     const res = await funcs.dataUpdate({
       table: 'bi.dashboard',
       id: dashboardId,
       data: {
-        widgets: [body].concat(row.widgets || []),
-        panels: [{ widget: body.name, col: body.col }].concat(row.panels || [])
-      }
+        widgets: [data].concat(row.widgets || []),
+        panels: [{ widget: data.name, col: data.col || 3 }].concat(
+          row.panels || []
+        ),
+      },
     });
-    const res2 = await funcs.dataInsert({
+    const widgetData = { ...data, data, dashboard_id: dashboardId };
+    if (body?.yml) Object.assign(widgetData, { yml: body.yml });
+    await funcs.dataInsert({
       table: 'bi.widget',
-      data: { ...body, data: body, dashboard_id: dashboardId }
+      data: widgetData,
     });
     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

@@ -1,12 +1,13 @@
 import dataDelete from '@opengis/fastify-table/crud/funcs/dataDelete.js';
 import dataUpdate from '@opengis/fastify-table/crud/funcs/dataUpdate.js';
+
 export default async function widgetDel({ pg = {}, params = {} }) {
   const { widget: widgetName, name: dashboardName } = params;
 
   if (!widgetName || !dashboardName) {
     return {
       message: 'not enough params: dashboard and widget name',
-      status: 400
+      status: 400,
     };
   }
 
@@ -27,7 +28,7 @@ export default async function widgetDel({ pg = {}, params = {} }) {
 
     const res = await dataDelete({
       table: 'bi.widget',
-      id: widgetId
+      id: widgetId,
     });
 
     const currentDashboard = await pg
@@ -43,19 +44,25 @@ export default async function widgetDel({ pg = {}, params = {} }) {
     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;
+    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({
       table: 'bi.dashboard',
       id: dashboardId,
-      data: body
+      data: body,
     });
 
     return {
       message: `Deleted widget ${widgetName}`,
       status: 200,
-      rows: res1
+      rows: res1,
     };
   } catch (err) {
     return { error: err.toString(), status: 500 };