@opengis/bi 1.2.0 → 1.2.1

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

@@ -0,0 +1,103 @@
+import path from 'node:path';
+
+import {
+    config, logger, pgClients, getTemplate, getTemplatePath, dataInsert, dataUpdate,
+} from '@opengis/fastify-table/utils.js';
+
+export default async function dashboardImport({ pg = pgClients.client, query = {}, user = {} }, reply) {
+    const time = Date.now();
+
+    if (!query?.dashboard) {
+        return reply.status(400).send('not enough query params: dashboard');
+    }
+
+    const list = getTemplatePath('dashboard').filter(el => el[0] === query.dashboard);
+
+    if (!list?.length) {
+        return reply.status(404).send(`dashboard not found`);
+    }
+
+    const client = await pg.connect();
+    Object.assign(client, {
+        options: pg.options,
+        pk: pg.pk,
+        pgType: pg.pgType,
+        tlist: pg.tlist,
+    });
+
+    const ids = [];
+    try {
+        await client.query('BEGIN');
+        const rows = await Promise.all(list.map(async ([filename]) => {
+
+            const obj = await getTemplate('dashboard', filename);
+            const index = obj?.find((el) => el[0] === 'index.yml')?.[1];
+            const { db = pg.options?.database, description, filters, panels, table_name, title, tags, style, grid } = index || {};
+
+            const dashboardId = await dataInsert({
+                pg,
+                table: 'bi.dashboard',
+                data: {
+                    db,
+                    name: filename,
+                    description,
+                    filters,
+                    panels,
+                    table_name,
+                    title,
+                    words: tags?.join(','),
+                    style,
+                    grid,
+                    source: 'file',
+                },
+                uid: user?.uid,
+            }).then(el => el.rows?.[0]?.dashboard_id);
+            ids.push(dashboardId);
+
+            const widgetList = panels?.reduce((acc, curr) => {
+                curr.widgets?.forEach(item => acc.push(item));
+                if (curr.widget) acc.push(curr.widget);
+                return acc;
+            }, []).filter(el => el) || [];
+
+            const widgets = widgetList.length
+                ? await Promise.all(obj.filter(el => widgetList.includes(path.parse(el[0]).name)).map(async ([widget, widgetData]) => {
+                    const { ext, name } = path.parse(widget);
+                    const data = ext === '.yml' ? widgetData : { type: 'text', data: { text: widgetData } };
+                    Object.assign(data, { name, x: widgetData?.data?.x, table_name: widgetData?.data?.table, dashboard_id: dashboardId });
+
+                    const res = await dataInsert({
+                        pg: client,
+                        table: 'bi.widget',
+                        data,
+                        uid: user?.uid,
+                    }).then(el => el.rows?.[0] || {});
+                    return res;
+                }))
+                : [];
+            const test = await dataUpdate({
+                pg: client,
+                table: 'bi.dashboard',
+                id: dashboardId,
+                data: {
+                    widgets,
+                },
+                uid: user?.uid,
+            });
+            return { dashboardId, name: filename, widgets };
+        }));
+
+        await client.query('COMMIT');
+        return { time: Date.now() - time, rows };
+    } catch (err) {
+        await client.query('ROLLBACK');
+        if (ids.length) {
+            const { rowCount = 0 } = await pg.query('delete from bi.dashboard where dashboard_id = any($1)', [ids]);
+            console.log('ROLLBACK delete', rowCount, 'dashboard');
+            // const { rowCount: rowCount1 = 0 } = await pg.query('delete from bi.widget where dashboard_id = any($1)', [ids]);
+            // console.log('delete', rowCount1, 'widget');
+        }
+        logger.file('bi/dashboardImport/error', { error: err.toString(), stack: err.stack, ids });
+        return reply.status(500).send(config.debug ? err.toString() : 'import error');
+    }
+}

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

@@ -0,0 +1,157 @@
+import yaml from 'js-yaml';
+import {
+  pgClients,
+  getTemplatePath,
+  getTemplate,
+  getPGAsync,
+  getMeta,
+} from '@opengis/fastify-table/utils.js';
+
+export default async function dashboard({
+  pg: pg1 = pgClients.client, params = {},
+}) {
+  const time = Date.now();
+  const { id } = params;
+
+  if (!id) {
+    return { message: 'not enough params: dashboard required', status: 400 };
+  }
+  const dashboards = getTemplatePath('dashboard');
+
+  const fileDashboard = dashboards.find((el) => el[0] === id);
+  if (!fileDashboard) {
+    const sql = `select title, description, table_name, panels, grid, widgets, filters, style, words, db, public 
+    from bi.dashboard where $1 in (dashboard_id, name)`;
+
+    const data = await pg1.query(sql, [id]).then(el => el.rows?.[0] || {});
+
+    let pg = pg1;
+    try {
+      pg = data.pg || (data.db ? await getPGAsync(data.db) : null) || pg1;
+    } catch (err) {
+      data.error = err.toString();
+    }
+
+    data.type = 'bd';
+    const { table_name: table } = data;
+
+    if (!table) {
+      return { message: 'not enough params: table required', status: 400 };
+    }
+
+    const loadTemplate = pg.pk?.['admin.doc_template'] ? await pg.query(
+      'select body from admin.doc_template where doc_type=5 and title=$1',
+      [table]
+    ).then(el => el.rows?.[0]?.body) : null;
+
+    const sqlList = loadTemplate?.sql ? loadTemplate?.sql
+      ?.filter?.(el => !el.disabled && el?.sql?.replace)
+      ?.map?.((el, i) => `left join lateral (${el.sql.replace(/limit 1/ig, '')}) t${i} on 1=1`)?.join?.(' ') : '';
+
+    const { fields = [] } = table && pg.pk?.[loadTemplate?.table || table] ? await pg.query(`select * from ${loadTemplate?.table || table} t ${sqlList || ''} limit 0`) : {};
+
+    data?.widgets?.forEach?.(el => {
+      const { style, data = {}, type, title, x, metrics } = el;
+      el.yml = yaml.dump({ title, type, data: { x, metrics, ...data }, style, })
+      // el.yml = yaml.dump({ style, data, type, title });
+    });
+
+    data.panels?.forEach?.(el => {
+      const { title, type } = data?.widgets?.find(item => item.name === el.widget) || {};
+      Object.assign(el, { title, type });
+    });
+
+    const meta = table ? await getMeta({ pg, table: loadTemplate?.table || table }) : {};
+    const columnIndexes = meta?.columns?.reduce((acc, curr, idx) => Object.assign(acc, { [curr.name]: idx }), {}) || [];
+
+    const columns = fields?.map(el => ({ name: el.name, title: meta?.columns[columnIndexes[el.name]]?.title || el.name, type: pg.pgType?.[el.dataTypeID] }));
+
+    return {
+      ...data || {},
+      widgets: data?.widgets?.filter?.(el => el?.widget_id) || [],
+      panels: data?.panels?.filter?.(el => el?.widget) || [],
+      geom: !meta?.geom,
+      error:
+        table && !pg.pk?.[loadTemplate?.table || table] ? `table pkey not found: ${loadTemplate?.table || table}` : undefined,
+      table_name: table,
+      templateTable: loadTemplate?.table,
+      time: Date.now() - time,
+      columns,
+    };
+  }
+
+  const fileData = await getTemplate('dashboard', id);
+  const index = fileData.find((el) => el[0] === 'index.yml')[1];
+
+  if (!index) {
+    return { message: `not found ${id}`, status: 404 };
+  }
+
+  const data = index;
+  data.type = 'file';
+  const { table } = data?.data || { table: data?.table_name };
+
+  let pg = pg1;
+  try {
+    pg = data.pg || (data.db ? await getPGAsync(data.db) : null) || pg1;
+  } catch (err) {
+    data.error = err.toString();
+  }
+
+  const { fields = [] } = table ? await pg.query(`select * from ${table} limit 0`) : {};
+
+  const meta = await getMeta({ pg: pg1, table });
+
+  const columns = meta?.columns
+    ?.filter(el => fields.map(field => field.name).includes(el.name))
+    ?.map(el => ({ name: el.name, title: el.title, type: pg.pgType?.[el.dataTypeID] }));
+
+  const checks = index?.filters?.filter((el) => el?.id && fields.map((el) => el?.name).includes(el?.id) && el?.type === 'Check');
+  if (checks?.length) {
+    await Promise.all(checks.map(async (el) => {
+      if (el?.data) {
+        const options = await getTemplate('cls', el.data);
+        Object.assign(el, { options });
+      } else if (index?.table_name || index?.table) {
+        const { rows = [] } = await pg.query(`select "${el.id}" as id, count(*) from ${index?.table_name || index?.table} group by "${el.id}"`);
+        Object.assign(el, { options: rows });
+      }
+    }));
+  }
+  const ranges = index?.filters?.filter((el) => el?.id && fields.map((el) => el?.name).includes(el?.id) && el?.type === 'Range');
+  if (ranges?.length) {
+    await Promise.all(ranges.map(async (el) => {
+      const rows = await pg.query(`select array[
+        percentile_cont(0) within group (order by ${el.id}), percentile_cont(0.25) within group (order by ${el.id}), 
+        percentile_cont(0.5) within group (order by ${el.id}), percentile_cont(0.75) within group (order by ${el.id}), 
+        percentile_cont(1.0) within group (order by ${el.id})
+      ] from ${index?.table_name || index?.table}`).then(el => el.rows?.[0]?.array || []);
+      Object.assign(el, { options: rows });
+    }));
+  }
+
+  // console.log(fileData)
+  const widgets = fileData
+    .filter((el) => el[0] !== 'index.yml')
+    .map((el) =>
+      el[1].data
+        ? {
+          name: el[0].split('.')[0],
+          type: el[1].type,
+          title: el[1].title,
+          style: el[1].style,
+          data: el[1].data,
+
+        }
+        : { name: el[0].split('.')[0], title: el[1] }
+    );
+
+  return {
+    ...data,
+    geom: !!meta?.geom,
+    table_name: table,
+    time: Date.now() - time,
+    columns,
+    widgets,
+  };
+}

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

@@ -0,0 +1,40 @@
+import { pgClients, getTemplatePath, getTemplate } from '@opengis/fastify-table/utils.js';
+
+const q = `select dashboard_id as name, 'db' as type, title, description, table_name, words, public from bi.dashboard`;
+
+export default async function data({
+  pg = pgClients.client, query = {}, user = {}
+}) {
+  const time = Date.now();
+  const { type = 'file' } = query;
+
+  const data = getTemplatePath('dashboard');
+  const dir = type === 'file' ? await Promise.all(
+    data.map(async ([filename, filepath]) => {
+      const obj = await getTemplate('dashboard', filename);
+      const index = obj?.find?.((el) => el[0] === 'index.yml')?.[1];
+      const { table_name, description, title } = index || {};
+
+      return { name: filename, path: user?.user_type?.includes('admin') ? filepath : undefined, type: 'file', title, description, table_name };
+    })
+  ) : [];
+
+  const { rows = [] } = ['db', 'viewer'].includes(type) ? await pg.query(q) : {};
+
+  if (type === 'viewer') {
+    return {
+      time: Date.now() - time,
+      db: pg.options?.database,
+      rows: rows.filter(el => el.table_name && !el.table_name.startsWith('demo.')),
+    };
+  }
+
+  const list = dir.concat(rows);
+
+  const res = {
+    time: Date.now() - time,
+    db: pg.options?.database,
+    rows: list,
+  };
+  return res;
+}

package/server/routes/dashboard/controllers/utils/yaml.js

@@ -0,0 +1,11 @@
+import yaml from 'js-yaml';
+
+yaml.loadSafe = (yml) => {
+  try {
+    return yaml.load(yml);
+  } catch (err) {
+    return { error: err.toString() };
+  }
+};
+
+export default yaml;

package/server/routes/dashboard/index.mjs

@@ -0,0 +1,26 @@
+import dashboard from './controllers/dashboard.js';
+import dashboardList from './controllers/dashboard.list.js';
+import dashboardImport from './controllers/dashboard.import.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: {
+      id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+    },
+  },
+};
+
+const policy = ['public'];
+
+export default async function route(fastify) {
+  fastify.get(`/bi-dashboard/:id`, { config: { policy }, schema: biSchema }, dashboard);
+  fastify.get(`/bi-dashboard`, { config: { policy } }, dashboardList);
+  fastify.get(`/bi-dashboard-import`, { config: { policy } }, dashboardImport);
+}

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

@@ -0,0 +1,229 @@
+import yaml from 'js-yaml';
+
+import {
+  config,
+  autoIndex,
+  pgClients,
+  getSelect,
+  getSelectVal,
+  getFilterSQL,
+  getMeta,
+  logger,
+} from '@opengis/fastify-table/utils.js';
+
+import chartSQL from './util/chartSQL.js';
+import normalizeData from './util/normalizeData.js';
+
+import { getWidget } from '../../../../utils.js';
+
+const maxLimit = 100;
+
+export default async function dataAPI(req, reply) {
+  const time = Date.now();
+
+  const { query = {}, user = {}, unittest } = req;
+
+  query.metric = Array.isArray(query.metric) ? query.metric.pop() : query.metric;
+
+  const { dashboard, widget, filter, search, samples } = query;
+
+  const widgetData = await getWidget({ pg: req.pg, dashboard, widget });
+
+  if (widgetData.status) return widgetData;
+
+  const { type, text, data = {}, controls, style, options } = widgetData;
+
+  const pg = widgetData.pg || req.pg || pgClients.client;
+
+  const error1 = {};
+  const { fields: cols = [] } = await pg.query(
+    `select * from ${data.table} t ${widgetData.tableSQL || data.tableSQL || ''} limit 0`
+  ).catch(err => Object.assign(error1, { error: err.toString() })) || {};
+  const columnTypes = cols?.map?.((el) => ({
+    name: el.name,
+    type: pg.pgType?.[el.dataTypeID],
+  }));
+
+  // data param
+  const { x, cls, groupbyCls, metric, table, where, tableSQL, groupby, xName, yName, xType, yType, error = error1 } =
+    normalizeData(widgetData, query, columnTypes);
+
+  // if (error) { return reply.status(400).send(error); }
+
+  // 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));
+  }
+
+  const { pk, columns = [], view } = await getMeta({ pg, table: data.table });
+
+  if (!view && !pk) {
+    return { message: `table not found: ${data.table} (${pg.options?.database})`, status: 404 };
+  }
+
+  // const columnList = columns.map(col => col.name);
+  const groupbyColumnNotExists = groupby?.split?.(',')?.filter?.(el => !columnTypes.map(el => el.name).includes(el.trim()));
+
+  if (groupby && groupbyColumnNotExists?.length) {
+    return { message: `groupby column not found: ${groupbyColumnNotExists} (${data.table}/${pg.options?.database})`, status: 404 };
+  }
+
+  // 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' && cols.find(el => el.name === 'metric') ? 'metric desc' : null);
+
+  const fData =
+    filter || search
+      ? await getFilterSQL({
+        pg,
+        table,
+        filter,
+        search,
+        filterList: widgetData.filters,
+      })
+      : {};
+
+  const optimizedSQL = widgetData?.sql
+    ? `${widgetData.sql} ${fData?.q && false ? fData?.q : ''} limit ${Math.min(query.limit || widgetData.limit || maxLimit, maxLimit)}`
+    : (fData?.optimizedSQL || `select * from ${tableSQL || table}`);
+
+  if (type?.includes('bar') && !metric?.length) {
+    return { message: 'empty widget params: metrics', status: 400 };
+  }
+
+  const sql = widgetData.sql ? optimizedSQL : (chartSQL[type] || chartSQL.chart)({
+    where: config.local && user?.user_type === 'superadmin' ? 'true' : where, // test
+    metric,
+    yType, // metric type
+    columns: widgetData.columns,
+    table: `(${optimizedSQL})q`,
+    x,
+    groupData,
+    groupby,
+    order,
+    samples,
+    limit: Math.min(query.limit || maxLimit, maxLimit),
+    xType,
+    fx: widgetData.fx,
+  });
+
+  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,
+    };
+  }
+
+  if (config.trace) console.log(sql, user?.uid);
+
+  const { rows = [], fields = [], errorSql } = await pg.query(sql.replace('{{uid}}', user?.uid)).catch(err => {
+    logger.file('bi/data', { error: err.toString(), sql });
+    return { errorSql: err.toString() };
+  }); // test with limit
+
+  if (groupbyCls) {
+    const { arr = [] } = await getSelect(groupbyCls, pg) || {};
+    if (arr.length) {
+      const ids = arr.map(el => el.id);
+      const text = arr.reduce((acc, curr) => ({ ...acc, [curr.id]: curr.text }), {});
+      rows.forEach(row => {
+        ids.reduce((acc, curr) => {
+          Object.assign(row, { [text[curr]]: row[curr] });
+          delete row[curr];
+          return acc;
+        }, {});
+      });
+    }
+  }
+
+  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]]?.text || vals?.[row[x]] || row[x] });
+      });
+  }
+
+  const metaTitles = columns.reduce((acc, curr) => Object.assign(acc, { [curr.name]: curr.title || curr.ua }), {});
+  const titles = Array.isArray(widgetData?.columns)
+    ? widgetData.columns.reduce((acc, curr) => Object.assign(acc, { [curr.name]: curr.title || curr.ua }), {})
+    : Object.keys(widgetData?.columns || {}).reduce((acc, curr) => Object.assign(acc, { [curr]: widgetData?.columns?.[curr] }), {});
+
+  const rows1 = type === 'table' ? rows.map(row => Object.keys(row || {}).reduce((acc, curr) => Object.assign(acc, { [titles?.[curr] || metaTitles?.[curr] || curr]: row?.[curr] }), {})) : rows;
+
+  const yml = widgetData.yml || yaml.dump(extractYml(widgetData));
+  const dimensions = fields.map((el) => el.name);
+
+  const res = {
+    time: Date.now() - time,
+    error: error || errorSql || (!widgetData.sql ? widgetData.error : undefined),
+    dimensions,
+    filter: xName,
+    dimensionsType: [xType, yType].filter((el) => el)?.length
+      ? [xType, yType].filter((el) => el)
+      : fields.map((el) => pg.pgType?.[el.dataTypeID]),
+    type,
+
+    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) => rows1.map((r) => r[el]))
+        : rows1,
+    style,
+    options,
+    controls,
+    yml,
+    data: widgetData.data,
+    id: query.widget,
+    columns: columnTypes.map(el => Object.assign(el, { title: titles[el.name] || metaTitles?.[el.name] || el.name })),
+    params: config?.local || unittest ? {
+      x,
+      cls,
+      metric,
+      table,
+      tableSQL,
+      where,
+      groupby,
+      sql,
+    } : undefined,
+  };
+  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

@@ -0,0 +1,49 @@
+function number({ metric, where, table, samples, fx }) {
+  const sql = `select ${fx || metric} from ${table} where ${where} ${samples ? 'limit 10' : ''}`;
+  return sql;
+}
+function table({ columns = [], table, where, samples }) {
+  const cols = Array.isArray(columns)
+    ? columns.map((el) => `"${(el.name || el).replace(/'/g, "''")}"`).join(',')
+    : Object.keys(columns).map(key => `"${key.replace(/'/g, "''")}"`).join(',');
+  return `select ${cols || '*'} from ${table} where ${where} ${samples ? 'limit 10' : 'limit 20'} `;
+}
+
+function chart({
+  metric,
+  yType, // metric type
+  where,
+  table,
+  x,
+  groupby,
+  groupData,
+  order,
+  samples,
+  limit = 100,
+  xType,
+  fx, // agg function
+}) {
+  const xCol = x && xType?.includes('[]') ? `unnest(${x})` : x;
+
+  const metricData =
+    groupData
+      ?.filter(el => el.name)
+      ?.map(
+        (el) =>
+          `${metric} filter (where '${el.name.toString().replace(/'/g, "''")}'=${yType?.includes('[]') ? `any(${groupby.replace(/'/g, "''")}::text[])` : groupby.replace(/'/g, "''")}) as "${el.name.toString().replace(/'/g, "''")}"`
+      )
+      .join(',') || `${fx || metric} as metric`;
+  const sql = `select ${xCol} ${x && xType?.includes('[]') ? `as ${x}` : ''}, ${metricData} 
+    from ${table}
+    where ${where} 
+    ${xCol ? `group by ${xCol}` : ''}
+    ${order || xCol ? `order by ${order || xCol}` : ''}
+    ${samples ? 'limit 10' : `limit ${limit}`}`;
+  return sql;
+}
+
+function text() {
+  return undefined;
+}
+
+export default { number, chart, table };

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

@@ -0,0 +1,65 @@
+function normalizeData(data, query = {}, columnTypes = []) {
+  const skip = [];
+  ['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])) {
+      if (query[el] && query[el] !== 'null') {
+        if (el === 'granularity' && !['week', 'month', 'quarter', 'year'].includes(query[el])) {
+          skip.push(`invalid granularity option: ${query[el]}`);
+        } else if (el !== 'granularity') { skip.push(`column not found: ${query[el]}`); }
+      }
+      if (!(el === 'granularity' || (el === 'groupby' && query[el] === 'null'))) 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.metric) ? (data.metrics || data.metric) : [data.metrics || data.metric];
+  const metric =
+    (query.metric ? `sum(${query.metric})` : null) ||
+    (metrics.length
+      ? (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, groupbyCls, table, filterCustom } = data;
+  const groupby = (query.groupby || data.groupby) === 'null' ? null : (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'}`;
+
+  const tableSQL = data.tableSQL?.length
+    ? `(select * from ${data?.table} t ${data.tableSQL || ''} where ${where})q`
+    : undefined;
+
+  return { x, cls, groupbyCls, metric, table, where, tableSQL, groupby, xName, xType, yName, yType, error: skip.length ? skip.join(',') : undefined };
+}
+export default normalizeData;