@opengis/bi 1.0.1 → 1.0.2

package/dist/style.css

@@ -0,0 +1 @@
+.list-bar[data-v-07e206e1]{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji}.vs-chart{width:100%;height:100%}.vs-chart-tooltip{border-radius:7px;max-height:100px;max-width:340px;min-width:140px;background-color:#fff;box-shadow:0 0 8px #0000002e}.vs-chart-tooltip__head{padding:5px;border-bottom:1px solid #eee;margin-bottom:5px}.vs-chart-tooltip__head-title{font-size:14px;font-weight:700;display:flex;align-items:center}.vs-chart-tooltip__head-value{margin-right:5px}.vs-chart-tooltip__head-series{font-size:14px;display:flex;align-items:center}.vs-chart-tooltip__color{width:12px;height:12px;display:block;border-radius:50%;margin-right:5px}.vs-chart-tooltip__body{padding:5px;font-size:14px;display:flex;align-items:start;flex-direction:column}.vs-chart-tooltip__body .vs-chart-tooltip__color{border-radius:3px}.vs-chart-tooltip__item{width:100%;display:flex;align-items:center;justify-content:space-between}.vs-chart-tooltip__text{margin-right:auto}.vs-chart-tooltip__body svg{margin-right:8px}

package/index.js

@@ -1,7 +1,10 @@
 import fp from 'fastify-plugin';
 import config from './config.js';
 
-import biPlugin from './dashboard/index.mjs';
+import biDashboard from './server/routes/dashboard/index.mjs';
+import biData from './server/routes/data/index.mjs';
+import biEdit from './server/routes/edit/index.mjs';
+import biMap from './server/routes/map/index.mjs';
 
 async function plugin(fastify, opt) {
   config.folder = opt.folder;
@@ -23,6 +26,9 @@ async function plugin(fastify, opt) {
     });
   }
 
-  biPlugin(fastify); // { prefix: config.prefix }
+  biDashboard(fastify); // { prefix: config.prefix }
+  biData(fastify); // { prefix: config.prefix }
+  biEdit(fastify); // { prefix: config.prefix }
+  biMap(fastify); // { prefix: config.prefix }
 }
 export default fp(plugin);

package/package.json

@@ -1,24 +1,63 @@
 {
   "name": "@opengis/bi",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "BI data visualization module",
   "main": "index.js",
   "type": "module",
+  "files": [
+    "dist/*",
+    "server/*",
+    "plugin.js",
+    "config.js"
+  ],
   "scripts": {
+    "debug": "node --watch-path=server server",
+    "dev": "vite",
+    "build": "vite build",
+    "build-app": "cross-env APP=true vite build",
     "lint": "eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore",
-    "test": "node --test"
+    "test": "node --test",
+    "test21": "node --test ./test/plugins/*",
+    "start": "node --watch-path=server server.js",
+    "prod": "cross-env NODE_ENV=production npm run start",
+    "docs:local": "cross-env docs=local vitepress build docs",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "docs-dev:local": "cross-env docs=local vitepress build docs-dev",
+    "docs-dev:dev": "vitepress dev docs-dev",
+    "docs-dev:build": "vitepress build docs-dev",
+    "docs-dev:preview": "vitepress preview docs-dev"
   },
   "keywords": [],
   "author": "Softpro",
   "license": "ISC",
   "dependencies": {
+    "@mapbox/sphericalmercator": "^1.2.0",
+    "@opengis/fastify-table": "^1.1.7",
+    "@opengis/v3-core": "^0.1.94",
+    "axios": "^1.3.1",
+    "cross-env": "^7.0.3",
+    "d3-format": "^3.1.0",
+    "echarts": "^5.5.1",
     "fastify": "^4.26.1",
     "fastify-plugin": "^4.0.0",
-    "@opengis/fastify-table": "^1.0.36",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "marked": "^14.1.2",
+    "vite": "^5.1.5",
+    "vue": "^3.4.27",
+    "vue-router": "^4.4.3"
   },
   "devDependencies": {
     "eslint": "^8.49.0",
-    "eslint-config-airbnb": "^19.0.4"
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-plugin-vue": "^9.17.0",
+    "prettier": "^3.0.3",
+    "sass": "^1.77.0",
+    "typescript": "~5.4.0",
+    "vitepress": "^1.1.4",
+    "vitepress-plugin-mermaid": "^2.0.16",
+    "vitepress-plugin-tabs": "^0.5.0",
+    "vitepress-sidebar": "^1.22.0"
   }
 }

package/plugin.js

@@ -0,0 +1,10 @@
+import config from './config.js';
+config.prefix = config.prefix || '/api'
+export default async function (fastify, opts) {
+
+  // API
+  fastify.register(import('./server/routes/dashboard/index.mjs'), config);
+  fastify.register(import('./server/routes/data/index.mjs'), config);
+  fastify.register(import('./server/routes/edit/index.mjs'), config);
+
+}

package/server/plugins/docs.js

@@ -0,0 +1,47 @@
+'use strict'
+
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+const dir = dirname(fileURLToPath(import.meta.url));
+const root = `${dir}/../../`;
+
+async function plugin(fastify, opts) {
+    fastify.get('/docs-dev*', async (req, reply) => {
+        if (!fs.existsSync(path.join(root, 'docs-dev/.vitepress/dist/'))) {
+            return reply.status(404).send('docs not exists');
+        }
+
+        const { params } = req;
+        const url = params['*'];
+
+        const filePath = url && url[url.length - 1] !== '/' ? path.join(root, 'docs-dev/.vitepress/dist/', url) : path.join(root, 'docs-dev/.vitepress/dist/', url, 'index.html');
+
+        if (!fs.existsSync(filePath)) {
+            return reply.status(404).send('File not found');
+        }
+
+        const ext = path.extname(filePath);
+        const mime = {
+            '.js': 'text/javascript',
+            '.css': 'text/css',
+            '.woff2': 'application/font-woff',
+            '.png': 'image/png',
+            '.svg': 'image/svg+xml',
+            '.jpg': 'image/jpg',
+            '.html': 'text/html',
+            '.json': 'application/json',
+            '.pdf': 'application/pdf'
+        }[ext];
+
+        const stream = fs.createReadStream(filePath);
+        stream.on('error', (err) => {
+            reply.status(500).send('Error reading file');
+        });
+
+        return mime ? reply.type(mime).send(stream) : reply.send(stream);
+    });
+}
+
+export default plugin;

package/server/plugins/vite.js

@@ -0,0 +1,49 @@
+import fs from 'fs';
+import path from 'path';
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+async function plugin(fastify) {
+  // vite server
+  if (!isProduction) {
+    const vite = await import('vite');
+    const viteDevMiddleware = (
+      await vite.createServer({
+        server: {
+          middlewareMode: true,
+        },
+      })
+    ).middlewares;
+
+    // this is middleware for vite's dev servert
+    fastify.addHook('onRequest', async (req, reply) => {
+      const { user } = req.session?.passport || {};
+
+
+      const next = () => new Promise((resolve) => {
+        viteDevMiddleware(req.raw, reply.raw, () => resolve());
+      });
+      await next();
+    });
+    fastify.get('*', async () => { });
+    return;
+  }
+
+  // From Build
+  fastify.get('*', async (req, reply) => {
+
+    const stream = fs.createReadStream('dist/index.html');
+    return reply.type('text/html').send(stream);
+  });
+  fastify.get('/assets/:file', async (req, reply) => {
+    const stream = fs.createReadStream(`dist/assets/${req.params.file}`);
+    const ext = path.extname(req.params.file);
+    const mime = {
+      '.js': 'text/javascript', '.css': 'text/css', '.woff2': 'application/font-woff', '.png': 'image/png',
+    }[ext];
+    //reply.cacheControl('max-age', '1d');
+    return reply.headers({ 'Cache-Control': 'public, max-age=3600' }).type(mime).send(stream);
+  });
+}
+
+export default plugin;

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

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

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

@@ -0,0 +1,60 @@
+import path from 'path';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+
+import pgClients from '@opengis/fastify-table/pg/pgClients.js';
+import getTemplatePath from '@opengis/fastify-table/table/controllers/utils/getTemplatePath.js';
+import { getTemplate } from '@opengis/fastify-table/utils.js';
+
+
+export default async function data({
+  pg = pgClients.client, params = {},
+}) {
+  const time = Date.now();
+  const { id } = params;
+
+  if (!id) {
+    return { message: 'not enough params: dashboard required', status: 400 };
+  }
+  const dashboards = await getTemplatePath('dashboard');
+
+  const fileDashboard = dashboards.find(el => el[0] === id)
+  if (!fileDashboard) {
+    const sql = `select title, description, table_name, panels, grid, widgets, filters, style 
+    from bi.dashboard where $1 in (dashboard_id, name)`;
+
+    const data = await pg.query(sql, [id]).then((res) => res.rows?.[0] || {});
+    data.type = 'bd';
+    const { table_name: table } = data;
+
+    if (!table) {
+      return { message: 'not enough params: table required', status: 400 };
+    }
+
+    const { fields = [] } = table && pg.pk?.[table] ? await pg.query(`select * from ${table} limit 1`) : {};
+
+    const columns = table ? fields.map(({ name, dataTypeID }) => ({ name, type: pg.pgType?.[dataTypeID] })) : [];
+    return { ...data, error: table && !pg.pk?.[table] ? `table pkey not found: ${table}` : undefined, table_name: 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 };
+  // console.log(fileData)
+  const widgets = fileData.filter(el => el[0] !== 'index.yml').map(el => el[1]).map(el => el.data ? ({ name: el.name, type: el.type, text: el.text, style: el.style, data: el.data }) : { text: el });
+
+  const { fields = [] } = table ? await pg.query(`select * from ${table} limit 1`) : {};
+
+  const columns = fields.map(({ name, dataTypeID }) => ({ name, type: pg.pgType?.[dataTypeID] }));
+
+  return { ...data, table_name: table, time: Date.now() - time, columns, widgets };
+}

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

@@ -0,0 +1,39 @@
+import { readFileSync, readdirSync } from 'fs';
+import path from 'path';
+import pgClients from '@opengis/fastify-table/pg/pgClients.js';
+import { getTemplate } from '@opengis/fastify-table/utils.js';
+import getTemplatePath from '@opengis/fastify-table/table/controllers/utils/getTemplatePath.js';
+
+import yaml from './utils/yaml.js';
+//import getTemplate from '@opengis/fastify-table/table/controllers/utils/getTemplate.js';
+
+
+const cwd = process.cwd();
+
+
+const q = `select dashboard_id as name, 'db' as type, title, description, table_name from bi.dashboard`;
+
+export default async function data({ pg = pgClients.client }) {
+  const time = Date.now();
+  const data = await getTemplatePath('dashboard');
+  const dir = await Promise.all(
+    data.map(async ([filename]) => {
+
+      const data = await getTemplate('dashboard', filename);
+      const index = data.find(el => el[0] === 'index.yml')[1]
+      const { table_name, description, title } = index || {};
+
+      return { name: filename, type: 'file', title, description, table_name };
+    })
+  );
+
+  const { rows = [] } = await pg.query(q);
+
+  const list = dir.concat(rows);
+
+  const res = {
+    time: Date.now() - time,
+    rows: list,
+  };
+  return res;
+}

package/server/routes/dashboard/index.mjs

@@ -0,0 +1,23 @@
+import config from '../../../config.js';
+
+import dashboard from './controllers/dashboard.js';
+import dashboardList from './controllers/dashboard.list.js';
+import dashboardDelete from './controllers/dashboard.delete.js';
+const biSchema = {
+  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]+)$' },
+  },
+};
+
+
+export default async function route(fastify) {
+  fastify.get(`/api/bi-dashboard/:id`, { schema: biSchema }, dashboard);
+  fastify.get(`/api/bi-dashboard`, dashboardList);
+  fastify.delete(`/api/bi-dashboard/:id`, dashboardDelete);
+}

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

@@ -0,0 +1,100 @@
+import path from 'path';
+// import getTemplate from '@opengis/fastify-table/table/controllers/utils/getTemplate.js';
+import autoIndex from '@opengis/fastify-table/pg/funcs/autoIndex.js';
+import pgClients from '@opengis/fastify-table/pg/pgClients.js';
+import chartSQL from './util/chartSQL.js';
+import normalizeData from './util/normalizeData.js';
+
+const cwd = process.cwd();
+const dashboardDir = path.join(cwd, 'server/templates/dashboard');
+const widgetDir = path.join(cwd, 'server/templates/widget');
+
+import { existsSync, readdirSync, readFileSync } from 'fs';
+
+import yaml from '../../dashboard/controllers/utils/yaml.js';
+
+export default async function data({
+  pg = pgClients.client, funcs = {}, query = {},
+}) {
+  const time = Date.now();
+  const { config = {} } = funcs;
+  const { dashboard, widget } = query;
+
+  if (!widget && !dashboard) {
+    return { message: 'not enough params: widget or dashboard required', status: 400 };
+  }
+
+  const fileList = dashboard && existsSync(path.join(dashboardDir, dashboard)) ? readdirSync(path.join(dashboardDir, dashboard)) : []
+  const filePath = dashboard ? fileList.filter(el => el.includes(widget)).map(el => path.join(dashboardDir, dashboard, el))[0] : path.join(widgetDir, widget + '.yml')
+
+  const { id, tableName } = !existsSync(filePath) ? await pg.query(`select dashboard_id as id, table_name as "tableName" from bi.dashboard where $1 in (dashboard_id, name)`, [dashboard]).then((res1) => res1.rows?.[0] || {}) : {};
+
+  if (!id && !existsSync(filePath)) {
+    return { message: { root: config?.local ? dashboardDir : undefined, error: `not found`, widget, dashboard }, status: 404 };
+  }
+
+  const fileData = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
+
+  const jsonData = filePath?.includes('.yml') ? yaml.loadSafe(fileData) : {};
+
+  const q = `select *, coalesce(data::jsonb, '{}'::jsonb) || jsonb_build_object('table', table_name) as data from bi.widget where dashboard_id=$1 and name=$2`;
+  const { type, text, data, options, controls, style } = existsSync(filePath)
+    ? jsonData
+    : await pg.query(q, [id || dashboard, widget])
+      .then((res1) => res1.rows?.[0] || {});
+
+  if (type === 'text' || filePath?.includes('.md')) {
+
+    return fileData;
+  }
+
+  if (!data?.table && tableName) {
+    Object.assign(data, { table: tableName });
+  }
+
+  if (!data?.table) {
+    return { error: /* json.error || */ `invalid ${widget ? 'widget' : 'dashboard'}: 1`, status: 500 };
+  }
+
+  // data param 
+  const { x, metric, table, where, groupby, xName } = normalizeData(data, query);
+
+  // auto Index
+  autoIndex({ table: data.table, columns: [data?.time].concat([xName]).concat([groupby]).filter(el => el) })
+
+  // get group 
+  const groupData = groupby ? await pg.query(`select ${groupby} as name ,count(*) from ${table} group by ${groupby} order by count(*) desc limit 20`).then(el => el.rows) : null;
+
+  if (query.sql === '2') return { x, metric, table, data, groupData };
+
+  const sql = (chartSQL[type] || chartSQL['chart'])({ where, metric, table, x, groupData, groupby });
+
+
+  if (query.sql) return sql;
+
+  if (!sql || sql?.includes('undefined')) {
+    return { message: { error: 'invalid sql', type, sql, where, metric, table, x, groupData, groupby }, status: 500 };
+  }
+
+  const { rows, fields } = await pg.query(sql); // test with limit
+
+  const dimensions = fields.map(el => el.name)
+
+  const res = {
+    time: Date.now() - time,
+    dimensions,
+
+    dimensionsType: fields.map(el => pg.pgType[el.dataTypeID]),
+    type,
+    text: text ? text : 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,
+  };
+  return res;
+
+
+
+}

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

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

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

@@ -0,0 +1,21 @@
+function normalizeData(data, query = {}) {
+
+
+    const granularity = query.granularity || data.granularity;
+
+
+    const xName = Array.isArray(data.x) ? data.x[0] : data.x;
+
+    const x = (granularity ? `date_trunc('${granularity}',${xName})::date` : null) || xName;
+
+    const metrics = Array.isArray(data.metrics) ? data.metrics : [data.metrics];
+    const metric = metrics.length ? metrics?.filter(el => el).map(el => `${el.operator || 'sum'}(${el.name || el})`) : 'count(*)';
+
+    const table = data.table;
+    const where = data.query || 'true';
+    const groupby = query.groupby || data.groupby;
+    //const orderby = query.orderby || data.orderby || 'count(*)';
+
+    return { x, metric, table, where, groupby, xName }
+}
+export default normalizeData;

package/server/routes/data/index.mjs

@@ -0,0 +1,26 @@
+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])$' }
+  },
+  params: {
+    id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+  },
+};
+
+
+export default async function route(fastify, opts) {
+  const prefix = opts?.prefix || config.prefix || '/api';
+  fastify.route({
+    method: 'GET',
+    url: '/api/bi-data',
+    schema: biSchema,
+    handler: data,
+  });
+}

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

@@ -0,0 +1,19 @@
+export default async function widgetAdd({ pg, funcs, params = {}, body }) {
+  try {
+    const time = Date.now();
+    console.log(body);
+    const res = await funcs.dataInsert({
+      table: 'bi.dashboard',
+      data: body
+    });
+
+    return {
+      time: Date.now() - time,
+      message: `Added new dashboard, ID: '${res.rows[0].title}'`,
+      status: 200,
+      rows: res.rows
+    };
+  } catch (err) {
+    return { error: err.toString(), status: 500 };
+  }
+}

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

@@ -0,0 +1,33 @@
+export default async function dashboardEdit({
+  pg, funcs, params = {}, body = {},
+}, reply) {
+  try {
+    if (!params.name) {
+      return {
+        message: "not enough params: dashboard name required",
+        status: 400,
+      }
+    }
+
+    const { name: dashboardName } = params;
+    const row = await pg.query(`select dashboard_id from bi.dashboard where $1 in (dashboard_id, name)`, [dashboardName]).then((res1) => res1.rows?.[0] || {});
+    const { dashboard_id: dashboardId } = row;
+
+    const res = await funcs.dataUpdate({
+      table: 'bi.dashboard',
+      id: dashboardId,
+      data: body,
+    });
+    if (!Object.keys(res)?.length) {
+      return { message: 'not found data', status: 404 };
+    }
+
+    return {
+      message: `updated ${dashboardName}`,
+      status: 200,
+      rows: res,
+    };
+  } catch (err) {
+    return reply.status(500).send(err.toString());
+  }
+}

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

@@ -0,0 +1,33 @@
+export default async function widgetAdd({
+  pg, funcs, params = {}, body = {},
+}) {
+  const { name: dashboardName } = params;
+  if (!dashboardName) {
+    return { message: 'not enough params: id', status: 400 };
+  }
+
+  try {
+    const row = await pg.query(`select dashboard_id, widgets, panels from bi.dashboard where $1 in (dashboard_id,name)`, [dashboardName]).then((res) => res.rows?.[0] || {});
+    const { dashboard_id: dashboardId } = row;
+
+    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 || [])
+      }
+    });
+    const res2 = await funcs.dataInsert({
+      table: 'bi.widget',
+      data: { ...body, data: body, dashboard_id: dashboardId },
+    });
+    return {
+      message: `Added widget to ${dashboardName}`,
+      status: 200,
+      rows: res,
+    };
+  } catch (err) {
+    return { error: err.toString(), status: 500 };
+  }
+}