@opengis/bi 1.0.14 → 1.0.16

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

@@ -15,7 +15,10 @@ function chart({
   groupData,
   order,
   samples,
+  xType,
 }) {
+  const xCol = x && xType?.includes('[]') ? `unnest(${x})` : x;
+
   const metricData =
     groupData
       ?.map(
@@ -23,11 +26,11 @@ function chart({
           `${metric} filter (where ${groupby}='${el.name}') as "${el.name}"`
       )
       .join(',') || `${metric} as metric`;
-  const sql = `select ${x}, ${metricData} 
+  const sql = `select ${xCol}, ${metricData} 
     from ${table}
     where ${where} 
-    group by ${x}
-    order by ${order || x}
+    ${xCol ? `group by ${xCol}` : ''}
+    ${order || xCol ? `order by ${order || xCol}` : ''}
     ${samples ? 'limit 10' : 'limit 100'}`;
   return sql;
 }

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

@@ -15,10 +15,10 @@ function normalizeData(data, query = {}, columnTypes = []) {
   }
 
   const xName = query.x || (Array.isArray(data.x) ? data.x[0] : data.x);
-  const xTYpe = columnTypes.find((el) => el.name == xName)?.type;
+  const xType = columnTypes.find((el) => el.name == xName)?.type;
 
   const granularity =
-    xTYpe === 'date' || xTYpe?.includes('timestamp')
+    xType === 'date' || xType?.includes('timestamp')
       ? query.granularity || data.granularity || 'year'
       : null;
 
@@ -31,10 +31,13 @@ function normalizeData(data, query = {}, columnTypes = []) {
   const metric =
     (query.metric ? `sum(${query.metric})` : null) ||
     (metrics.length
-      ? metrics
-          ?.filter((el) => el)
-          .map((el) => el.fx || `${el.operator || 'sum'}(${el.name || el})`)
+      ? (metrics
+        ?.filter((el) => el && columnTypes.find((col) => col.name == (el?.name || el)))
+        ?.map((el) => el.fx || `${el.operator || 'sum'}(${el.name || el})`)?.join(',') || 'count(*)')
       : 'count(*)');
+  
+  const yName = metrics?.[0]?.name || metrics?.[0];
+  const yType = columnTypes.find((el) => el.name == yName)?.type;
 
   const { cls, table, filterCustom } = data;
   const groupby = query.groupby || data.groupby;
@@ -51,6 +54,6 @@ function normalizeData(data, query = {}, columnTypes = []) {
     ? `(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, xType, yName, yType };
 }
 export default normalizeData;

package/server/routes/data/index.mjs

@@ -4,9 +4,14 @@ import data from './controllers/data.js';
 
 const biSchema = {
   querystring: {
-    widget: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    dashboard: { type: 'string', pattern: '^([\\d\\w]+)$' },
+    widget: { type: 'string', pattern: '^([\\d\\w_]+)$' },
+    dashboard: { type: 'string', pattern: '^([\\d\\w_]+)$' },
     sql: { type: 'string', pattern: '^([\\d])$' },
+    // metric: { type: 'string', pattern: '^([\\d\\w_]+)$' },
+    x: { type: 'string', pattern: '^([\\d\\w_]+)$' },
+    granularity: { type: 'string', pattern: '^(week|month|quarter|year)$' },
+    groupby: { type: 'string', pattern: '^([\\d\\w_]+)$' },
+    filterCustom: { type: 'string', pattern: '^([\\d\\w_,]+)$' },
   },
   params: {
     id: { type: 'string', pattern: '^([\\d\\w]+)$' },

package/server/routes/dataset/controllers/bi.dataset.demo.add.js

@@ -0,0 +1,97 @@
+import path from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+
+import { getPG } from '@opengis/fastify-table/utils.js';
+
+const host = 'https://cdn.softpro.ua/demo/bi';
+
+
+const root = process.cwd();
+const send = (msg) => console.log(msg)
+async function downloadFile(fileName) {
+    const pg = getPG();
+    send(`${fileName} - checking if already downloaded...`);
+
+    const demoPath = path.join(root, '/log/temp/', fileName);
+    // const fileExists = await isFileExists(demoPath);
+
+    // send(`${host}/${fileName}` + demoPath)
+    const response = await fetch(`${host}/${fileName}`);
+    const body = await response.text();
+    //send(body)
+    if (response?.status !== 200) {
+        return { [fileName]: { result: 'file not found', status: 404 } };
+    }
+
+    await mkdir(path.dirname(demoPath), { recursive: true });
+
+    await writeFile(demoPath, body, 'utf8');
+
+    await pg.query(`drop table if exists ${path.parse(fileName).name}`);
+    const { exists } = await pg.query(`select to_regclass($1) is not null as exists`, [path.parse(fileName).name])
+        .then((res1) => res1.rows?.[0] || {});
+
+
+    if (exists) {
+        send(`${fileName} - dataset table already exists!`);
+        return { [fileName]: { result: 'dataset table already exists', status: 200 } };
+    }
+
+    const sql = await readFile(demoPath, 'utf8');
+    await pg.query(sql);
+    return { [fileName]: { result: 'success', status: 200 } };
+}
+
+/**
+ * Імпорт demo даних dashboard
+ *
+ * @method GET
+ * @summary Імпорт demo даних dashboard
+ * @priority 4
+ * @type api
+ * @tag bi
+ * @errors 400,500
+ * @returns {Number} status Номер помилки
+ * @returns {String} error Опис помилки
+ * @returns {Object} rows Масив з колонками таблиці
+ */
+
+const demoList = {
+    'demo.orders.sql': 'Статистика продажів (demo)',
+    'demo.cleaned_sales_data.sql': 'Статистика продажів (demo 2)',
+    'demo.video_game_sales.sql': 'Статистика продажів відеоігор (demo)',
+};
+
+export default async function biDatasetDemoAdd(req) {
+    const { pg, query = {} } = req;
+    //    const send = () => { }; // eventStream?
+
+
+
+    const sqlList = [];
+
+    const tables = Object.keys(demoList)?.map((el) => {
+        const table = path.parse(el).name;
+        sqlList.push(`insert into bi.dataset(dataset_id,name,table_name)
+            select '${el}', '${demoList?.[el]}', '${table}' on conflict(dataset_id) do update set 
+            name=excluded.name, table_name=excluded.table_name
+            returning dataset_id as id`);
+        return table;
+    });
+
+    const { count } = await pg.query(`select count(*) from pg_catalog.pg_tables where schemaname||'.'||tablename = any($1)`, [tables]).then((res1) => res1.rows?.[0] || {});
+
+    if (count === '3' && !query.nocache) {
+        const result = await pg.query(sqlList.join(';\n'));
+        const ids = (Array.isArray(result) ? result : [result]).filter((el) => el).map((el) => el?.rows?.[0]?.id);
+        return { message: { ids, message: 'all datasets already downloaded' }, status: 200 };
+    }
+
+    const res = {};
+    const resultAll = await Promise.all(Object.keys(demoList).map(async (fileName) => await downloadFile(fileName))).catch(err => console.log(err));
+
+    const result = await pg.query(sqlList.join(';\n'));
+    const ids = (Array.isArray(result) ? result : [result]).filter((el) => el).map((el) => el?.rows?.[0]?.id);
+    return { message: { ids, message: res, resultAll }, status: 200 };
+
+};

package/server/routes/dataset/controllers/bi.dataset.import.js

@@ -0,0 +1,67 @@
+import { randomBytes } from 'node:crypto';
+
+import createTableFunc from './util/create.table.js';
+import prepareData from './util/prepare.data.js';
+
+/**
+ * Імпорт даних до BI набору
+ *
+ * @method POST
+ * @summary Імпорт даних до BI набору
+ * @priority 4
+ * @alias biDatasetPost
+ * @type api
+ * @tag bi
+ * @param {Object} params.id Dashboard ID
+ * @errors 400,500
+ * @returns {Number} status Номер помилки
+ * @returns {String} error Опис помилки
+ * @returns {Object} rows Масив з колонками таблиці
+ */
+
+export default async function biDatasetPost(req) {
+  const {
+    pg, params = {}, body = {}, session = {},
+  } = req;
+  const { uid } = session?.passport?.user || {};
+
+  if (!uid) {
+    return { message: 'access restricted', status: 403 };
+  }
+
+  if (!Array.isArray(body?.data) && body?.data?.features?.[0]?.type !== 'Feature') {
+    return { message: 'body data param is invalid', status: 400 };
+  }
+
+  // await pg.query(`insert into bi.dataset(dataset_id,name, uid) values($1,$1,$2) on conflict (dataset_id) do update set table_name=null`, [params?.id, uid]);
+  const dataset = await pg.query('select dataset_id as id, name, table_name as table from bi.dataset where dataset_id=$1', [params?.id]).then((res) => res.rows?.[0] || {});
+  if (!dataset.id) {
+    return { message: `dataset not found: ${params?.id}`, status: 404 };
+  }
+
+  const tableName = randomBytes(64).toString('hex').substring(0, 24).replace(/^\d+/, '');
+  const pkey = tableName.concat('_id');
+  const table = `bi_data.${tableName}`;
+  const { columns, insertData } = await prepareData({ req, table, data: body?.data });
+  const createTable = createTableFunc({ table, pkey, columns });
+  const updateDataset = `update bi.dataset set table_name='${table}', editor_id='${uid}' where dataset_id='${params?.id}'`;
+  const sqlList = [createTable, insertData, updateDataset];
+  if (dataset.name) {
+    sqlList.push(`comment on table ${table} is '${dataset.name}'`);
+  }
+  const q = sqlList.filter((el) => el).join(';');
+  await pg.query('create extension if not exists postgis;create schema if not exists bi_data;');
+
+  // await pg.query(createTable);
+
+  //const result = {}
+  const result = await pg.query(q);
+
+  return {
+    message: {
+      id: params?.id, action: 'import', result: 'success', total: result?.find((el) => el.command === 'INSERT')?.rowCount,
+    },
+    status: 200,
+  };
+
+};

package/server/routes/dataset/controllers/util/create.table.js

@@ -0,0 +1,22 @@
+export default function createTableFunc({
+  table, pkey, columns,
+}) {
+  const columnType1 = {
+    text: 'text', select: 'text', date: 'date', 'yes/no': 'boolean', badge: 'text', number: 'numeric', tags: 'text[]', geom: 'geom',
+  };
+
+  const createQuery = `create table if not exists ${table} (
+  ${pkey} text not null default public.uuid_generate_v4(), 
+  geom public.geometry, ${columns ? `
+  ${columns?.map((el) => `${el.name} ${columnType1[el.format] || 'text'}`).join(', ')},` : ''} 
+  cdate timestamp without time zone not null default now(), 
+  editor_date timestamp without time zone, 
+  uid text, 
+  editor_id text, 
+  files json, 
+  constraint ${table.replace(/\./g, '_')}_constraint_pkey PRIMARY KEY (${pkey}) )`;
+
+  const commentQuery = columns?.filter((el) => el.ua)?.map((el) => `comment on column ${table}.${el.name} is '${el.ua}'`).join(';');
+
+  return [createQuery, commentQuery].join(';');
+};

package/server/routes/dataset/controllers/util/prepare.data.js

@@ -0,0 +1,49 @@
+import path from 'node:path';
+
+import { getFolder, isFileExists } from '@opengis/fastify-table/utils.js';
+
+import { file2json } from '@opengis/fastify-file/utils.js';
+
+function getFileColumns({ data }) {
+  if (data?.features) {
+    return Object.keys(data?.features[0]?.properties); // geojson / shapefile
+  }
+  if (Array.isArray(data)) {
+    return Object.keys(data[0])?.filter((el) => el); // csv / xls
+  }
+  return Object.values(data[Object.keys(data)?.[0]]?.[0]); // else?
+}
+
+export default async function prepareData({
+  req, table, file_path: filePath, data: data1,
+}) {
+  const rootDir = getFolder(req);
+  const fullPath = path.join(rootDir, filePath || '');
+  const fileExists = await isFileExists(fullPath);
+  if (!fileExists && !data1) {
+    return { message: `file not found: ${filePath}`, status: 404 };
+  }
+
+  const data11 = data1 || await file2json(fullPath);
+  const data = (['.xls', '.xlsx'].includes(path.extname(fullPath)) && !Array.isArray(data11)) ? data11[Object.keys(data11)[0]] : data11;
+
+  /* generate column list based on input data */
+  const columns = getFileColumns({ data })
+    ?.filter((el) => !['editor_date', 'cdate', 'uid', 'editor_id', 'files'].includes(el.toLowerCase()))
+    ?.map((el, index) => ({ name: `col_${index}`, ua: el, format: 'text' }));
+
+  const columnList1 = columns?.map((el) => el.name)?.join(',');
+  const columns1 = ','.concat(columns?.map((el) => `features->'properties'->>'${el?.ua}'`)?.join(','));
+  const columns2 = columns?.map((el) => `d->>'${el.ua}'`).join(',');
+  const q1 = data?.features ? `(SELECT json_array_elements('${JSON.stringify(data.features).replace(/'/g, "''")}'::json) AS features)q` : null;
+  const q2 = !data?.features ? `( SELECT json_array_elements('${JSON.stringify(Array.isArray(data)
+    ? data
+    : data[Object?.keys(data)?.[0]])
+    .replace(/'/g, "''")
+    .replace(/\\"/g, '`')}'::json) AS d )q`
+    : null;
+  const insertData = data?.features
+    ? `INSERT into ${table} (geom ${','.concat(columnList1)}) SELECT public.ST_GeomFromGeoJSON((features->>'geometry')::json) AS geom ${columns1} FROM ${q1}`
+    : `INSERT into ${table} (${columnList1}) SELECT ${columns2} FROM ${q2}`;
+  return { columns, insertData };
+};

package/server/routes/dataset/index.mjs

@@ -0,0 +1,19 @@
+import biDatasetPost from './controllers/bi.dataset.import.js';
+import biDatasetDemoAdd from './controllers/bi.dataset.demo.add.js';
+
+const biSchema = {};
+
+export default async function route(fastify, opts) {
+  fastify.route({
+    method: 'POST',
+    url: '/bi-dataset/:id',
+    schema: biSchema,
+    handler: biDatasetPost,
+  });
+  fastify.route({
+    method: 'GET',
+    url: '/bi-dataset-demo',
+    schema: biSchema,
+    handler: biDatasetDemoAdd,
+  });
+}

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

@@ -1,4 +1,6 @@
-export default async function widgetAdd({ pg, funcs, params = {}, body }) {
+import { dataInsert } from "@opengis/fastify-table/utils.js";
+
+export default async function widgetAdd({ pg, body }) {
   try {
     const time = Date.now();
     const tableName = body.table_name;
@@ -7,7 +9,7 @@ export default async function widgetAdd({ pg, funcs, params = {}, body }) {
       [tableName]
     );
     if (!checkTable.rows.length) return { message: 'bad params', status: 401 };
-    const res = await funcs.dataInsert({
+    const res = await dataInsert({
       table: 'bi.dashboard',
       data: body,
     });

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

@@ -1,5 +1,7 @@
+import { dataUpdate } from "@opengis/fastify-table/utils.js";
+
 export default async function dashboardEdit(
-  { pg, funcs, params = {}, body = {} },
+  { pg, params = {}, body = {} },
   reply
 ) {
   try {
@@ -24,7 +26,7 @@ export default async function dashboardEdit(
       .then((res1) => res1.rows?.[0] || {});
     const { dashboard_id: dashboardId } = row;
 
-    const res = await funcs.dataUpdate({
+    const res = await dataUpdate({
       table: 'bi.dashboard',
       id: dashboardId,
       data: body,

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

@@ -1,3 +1,5 @@
+import { dataInsert, dataUpdate } from "@opengis/fastify-table/utils.js";
+
 /* eslint-disable import/extensions */
 import { yamlSafe } from '../../../../utils.js';
 
@@ -7,7 +9,7 @@ function generateUniqueName(prefix = 'bar') {
   return `${prefix}_${randomPart}_${timestamp}`;
 }
 
-export default async function widgetAdd({ pg, funcs, params = {}, body = {} }) {
+export default async function widgetAdd({ pg, params = {}, body = {} }) {
   const { name: dashboardName } = params;
   if (!dashboardName) {
     return { message: 'not enough params: id', status: 400 };
@@ -46,7 +48,7 @@ export default async function widgetAdd({ pg, funcs, params = {}, body = {} }) {
         data?.metrics,
     });
 
-    const res = await funcs.dataUpdate({
+    const res = await dataUpdate({
       table: 'bi.dashboard',
       id: dashboardId,
       data: {
@@ -58,7 +60,7 @@ export default async function widgetAdd({ pg, funcs, params = {}, body = {} }) {
     });
     const widgetData = { ...data, data, dashboard_id: dashboardId };
     if (body?.yml) Object.assign(widgetData, { yml: body.yml });
-    await funcs.dataInsert({
+    await dataInsert({
       table: 'bi.widget',
       data: widgetData,
     });

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

@@ -1,5 +1,4 @@
-import dataDelete from '@opengis/fastify-table/crud/funcs/dataDelete.js';
-import dataUpdate from '@opengis/fastify-table/crud/funcs/dataUpdate.js';
+import { dataDelete, dataUpdate } from '@opengis/fastify-table/utils.js';
 
 export default async function widgetDel({ pg = {}, params = {} }) {
   const { widget: widgetName, name: dashboardName } = params;

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

@@ -2,14 +2,10 @@ import { dataUpdate } from '@opengis/fastify-table/utils.js';
 
 import { yamlSafe } from '../../../../utils.js';
 
-export default async function widgetEdit({
-  pg = {},
-  funcs = {},
-  body = {},
-  params = {},
-}) {
+export default async function widgetEdit({ pg, body, params, }) {
   const { widget: widgetName, name: dashboardName } = params;
-  const data = body.yml ? yamlSafe.load(body.yml) : body;
+  const data = body.yml && !body.style ? yamlSafe.load(body.yml) : body;
+
   const tableName =
     data.data?.table || data?.table || data.table_name || body.table_name;
 
@@ -20,84 +16,37 @@ export default async function widgetEdit({
     };
   }
 
-  try {
-    const row = await pg
-      .query(
-        `select a.widget_id, b.dashboard_id from bi.widget a, bi.dashboard b
+
+  const { widget_id: widgetId } = 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((res1) => res1.rows?.[0] || {});
-    const { widget_id: widgetId, dashboard_id: dashboardId } = row || {};
+    [dashboardName, widgetName]
+  ).then((res1) => res1.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 };
-    // }
+  if (!widgetId) {
+    return { message: `widget not found ${widgetName}`, status: 404 };
+  }
 
-    if (!tableName || !pg.pk?.[tableName]) {
-      return { message: 'bad params: table', status: 400 };
-    }
+  if (!tableName || !pg.pk?.[tableName]) {
+    return { message: 'bad params: table', status: 400 };
+  }
 
-    if (!widgetId) {
-      return { message: `widget not found ${widgetName}`, status: 404 };
-    }
 
-    const widgetData = { ...data, data };
-    if (body?.yml) Object.assign(widgetData, { yml: body.yml });
-    await funcs.dataUpdate({
-      table: 'bi.widget',
-      id: widgetId,
-      data: widgetData,
-    });
 
-    // \====================
-    const currentDashboard = await pg
-      .query(
-        `select * from  bi.dashboard 
-    where $1 in (dashboard_id, name)`,
-        [dashboardName]
-      )
-      .then((res1) => res1.rows?.[0] || {});
-    const bodyDashboard = currentDashboard;
+  // const widgetData = { ...data, data };
+  const widgetData = body.yml && !body.style ? data : { style: data.style, data: { x: data.x, metrics: data.metrics }, controls: data.controls, type: data.type, title: data.title, table_name: data.table_name };
+  // console.log(widgetId, widgetData)
+  if (body?.yml) Object.assign(widgetData, { yml: body.yml });
+  const rows = await dataUpdate({
+    table: 'bi.widget',
+    id: widgetId,
+    data: widgetData,
+  });
 
-    if (!currentDashboard) {
-      return { message: `dashboard not found ${dashboardName}`, status: 404 };
-    }
-    bodyDashboard.panels =
-      Array.isArray(bodyDashboard.panels) && bodyDashboard.panels?.length
-        ? bodyDashboard.panels?.map((panel) => {
-            if (panel.widget === widgetName) {
-              panel.col = body.col;
-            }
-            return panel;
-          })
-        : undefined;
-    bodyDashboard.widgets =
-      Array.isArray(bodyDashboard.widgets) && bodyDashboard?.widgets?.length
-        ? bodyDashboard.widgets?.map((widget) => {
-            if (widget.name === widgetName) {
-              return body;
-            }
-            return widget;
-          })
-        : undefined;
+  return {
+    message: rows,
+    status: 200,
 
-    const res1 = await dataUpdate({
-      table: 'bi.dashboard',
-      id: dashboardId,
-      data: bodyDashboard,
-    });
+  };
 
-    return {
-      message: `Edited widget ${widgetName}`,
-      status: 200,
-      rows: res1,
-    };
-  } catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
 }

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

@@ -1,6 +1,12 @@
+import { getFilterSQL } from '@opengis/fastify-table/utils.js';
+
 import { getWidget } from '../../../../utils.js';
 
-export default async function cluster({ pg, funcs, query = {}, log }) {
+import downloadClusterData from './utils/downloadClusterData.js';
+
+const clusterExists = {};
+
+export default async function cluster({ pg, query = {}, log }) {
   const { widget, filter, dashboard, search } = query;
 
   if (!widget) {
@@ -43,10 +49,17 @@ export default async function cluster({ pg, funcs, query = {}, log }) {
     }
 
     if (!clusterTable?.name) {
-      return {
-        message: 'not enough widget params: clusterTable name',
-        status: 400,
-      };
+      Object.assign(clusterTable, {
+        name: 'bi.cluster',
+        title: 'title',
+        query: `type='${cluster}'`,
+      });
+    }
+
+    if (cluster && !clusterExists[cluster]) {
+      const res = await downloadClusterData({ pg, log, cluster });
+      if (res) return res;
+      clusterExists[cluster] = 1;
     }
 
     if (clusterTable?.name && !pg.pk?.[clusterTable?.name]) {
@@ -56,35 +69,27 @@ export default async function cluster({ pg, funcs, query = {}, log }) {
       };
     }
 
-    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] || {});
+    const { bounds, extentStr } = 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 ${table} where ${where || '1=1'}`).then((res) => res.rows?.[0] || {});
+    const extent = extentStr ? extentStr.split(',') : undefined;
 
     // get sql
     const { optimizedSQL } =
       filter || search
-        ? await funcs.getFilterSQL({ pg, table, filter, search })
+        ? await 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`;
+        where ${where} group by ${cluster}, b.id order by sum("${metrics[0]}")::float desc`;
 
     if (query.sql === '1') return q;
 
     // auto Index
-    //  funcs.autoIndex({ table, columns: (metrics || []).concat([cluster]) });
+    //  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);
@@ -96,7 +101,7 @@ export default async function cluster({ pg, funcs, query = {}, log }) {
       vals[Math.floor(len * 0.75)],
       vals[len - 1],
     ];
-    return { sizes, rows, bbox, count: rows.length, total };
+    return { sizes, rows, bounds, extent, count: rows.length, total: rows?.reduce((acc, curr) => (curr.metric || 0) + acc, 0) };
   } catch (err) {
     log.error('bi/cluster', { error: err.toString(), query });
     return { error: err.toString(), status: 500 };