@opengis/fastify-table 1.3.71 → 1.3.73

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

@@ -0,0 +1,110 @@
+import {
+  getTemplate, getMeta, metaFormat, applyHook, handlebars, pgClients,
+} from '../../../../utils.js';
+
+export default async function tableInfo(req, reply) {
+    const {
+        pg = pgClients.client, params = {}, query = {}, user = {},
+    } = req;
+
+    const time = Date.now();
+
+    const { uid } = user;
+
+    if (!uid) {
+        return reply.status(403).send('access restricted: uid');
+    }
+
+    if (!params?.id || !params?.table) {
+        return reply.status(400).send('not enougn params');
+    }
+
+    const loadTable = await getTemplate('table', params.table);
+
+    if (!loadTable) {
+        return reply.status(404).send('template not found');
+    }
+
+    const {
+        table, columns = [], sql, cardSql, filters, form, meta, public: ispublic,
+    } = loadTable;
+
+    if (!meta?.info) {
+        return reply.status(400).send('empty meta info');
+    }
+
+    const tableMeta = await getMeta({ pg, table });
+
+    if (tableMeta?.view) {
+        if (!loadTable?.key) {
+            return reply.status(404).send(`key not found: ${table}`);
+        }
+        Object.assign(tableMeta, { pk: loadTable?.key });
+    }
+
+    const { pk } = tableMeta || {};
+
+    if (!pk) {
+        return reply.status(404).send(`table not found: ${table}`);
+    }
+
+    const sqlTable = sql
+        ?.filter?.((el) => !el?.disabled && el?.sql?.replace)
+        ?.map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ${el.name || `t${i}`} on 1=1 `)
+        ?.join('') || '';
+
+    const cardSqlFiltered = params.id ? (cardSql?.filter?.((el) => !el?.disabled && el?.name && el?.sql?.replace) || []) : [];
+    const cardSqlTable = cardSqlFiltered.length ? cardSqlFiltered.map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ct${i}  on 1=1 `).join('\n') || '' : '';
+
+    const interfaceQuery = params?.query ? await handlebars.compile(params?.query)({ user, uid }) : undefined;
+    const where = [params.id ? `"${pk}" = $1` : null, loadTable.query, interfaceQuery].filter((el) => el).filter((el) => (user?.user_type === 'superadmin' ? !el.includes('{{uid}}') : true));
+
+    const { fields = [] } = await pg.query(`select * from ${table} where ${sqlTable ? 'true' : (where.join(' and ') || 'true')} limit 0`, ([sqlTable ? null : params.id].filter(el => el)) );
+    const columnList = fields.map(el => el.name);
+
+    const metaInfoCols = meta.info.split(',').filter(el => columnList.includes(el)).map((el) => `"${el}"`);
+
+    if (!metaInfoCols.length) {
+        return reply.status(400).send('invalid meta info: columns not found');
+    }
+
+    const q = `select  ${pk ? `"${pk}" as id,` : ''} 
+                        ${metaInfoCols.join(',')} 
+                        from (select * from ${table} where ${sqlTable ? 'true' : (where.join(' and ') || 'true')}) t 
+                        ${sqlTable} 
+                        ${cardSqlTable} 
+                        where ${where.join(' and ') || 'true'} 
+                        limit 1`
+        .replace(/{{uid}}/g, uid);
+
+    if (query.sql === '1') { return q; }
+
+    const { rows } = await pg.query(q, [params.id]);
+
+    const qCount = `select 
+                count(*)::int as total,  
+                count(*) FILTER(WHERE ${[interfaceQuery].filter(el => el).join(' and ') || 'true'})::int as filtered 
+                from ${table} t ${sqlTable} 
+                where ${[loadTable.query].filter(el => el).join(' and ') || 'true'} `
+        .replace(/{{uid}}/g, uid);
+
+    const { total, filtered } = params.id ? rows.length
+        : await pg.queryCache(qCount, { table: loadTable.table, time: 5 }).then(el => el?.rows?.[0] || {});
+
+    const cls = meta.info.split(',').filter(el => columnList.includes(el))
+        .map(el => ({ name: el, data: columns.find(col => col.name === el)?.data }))
+        .filter(el => el.data)
+        .reduce((acc, curr) => Object.assign(acc, { [curr.name]: curr.data }), {});
+
+    await metaFormat({ rows, cls /* , sufix: false */ }, pg);
+
+    const res = {
+        time: Date.now() - time, public: ispublic, card: loadTable.card, total, filtered, count: rows.length, pk, form, rows, meta, columns, filters,
+    };
+
+    const result = await applyHook('afterData', {
+        table: loadTable.table, payload: res, user,
+    });
+
+    return result || res;
+}

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

@@ -0,0 +1,12 @@
+import { getOpt, getToken } from '../../../../utils.js';
+
+export default async function tokenInfo(req, reply) {
+    const { params = {}, user } = req;
+
+    if (user.user_type !== 'admin') {
+        return reply.status(403).send('access restricted');
+    }
+
+    const tokenData = await getToken({ uid: user.uid, token: params.token }) || await getOpt(params.token, user.uid);
+    return tokenData;
+}

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

@@ -0,0 +1,31 @@
+import { config, setToken } from "@opengis/fastify-table/utils.js";
+
+export default function assignTokens({
+    rows = [], ispublic, uid, loadTable = {},
+}) {
+    if (config?.security?.disableToken) return;
+
+    if (!config?.auth?.disable && !ispublic && !uid) throw new Error('empty user');
+    if (!loadTable?.table || !(loadTable?.form || loadTable?.add_form)) return null;
+
+    const form = loadTable?.form || loadTable?.add_form;
+    const addTokens = setToken({
+        ids: [JSON.stringify({ add: loadTable.table, form })],
+        mode: 'a',
+        uid: config?.auth?.disable || ispublic ? '1' : uid,
+        array: 1,
+    });
+    if (!rows.length) return addTokens[0];
+
+    rows.forEach((row) => {
+        const editTokens = setToken({
+            ids: [JSON.stringify({ id: row.id, table: loadTable.table, form })],
+            mode: 'w',
+            uid: config?.auth?.disable || ispublic ? '1' : uid,
+            array: 1,
+        });
+        Object.assign(row, { token: editTokens[0] });
+    });
+    return addTokens[0];
+
+}

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

@@ -0,0 +1,19 @@
+function onCheck(rule, data) {
+    const val = data[rule[0]];
+    if (rule[1] === '==') return val === rule[2];
+    if (rule[1] === '!=') return val !== rule[2];
+    if (rule[1] === 'in' && rule[2].split) return rule[2].split(',').includes(val);
+    if (rule[1] === 'in' && rule[2].includes) return rule[2].includes(val);
+
+    if (rule[1] === 'not in' && rule[2].split) return !rule[2].split(',').includes(val);
+    if (rule[1] === 'not in' && rule[2].includes) return !rule[2].includes(val);
+
+    if (rule[1] === '>') return val > rule[2];
+    if (rule[1] === '<') return val < rule[2];
+    return false;
+}
+export default function conditions(rules, data) {
+    if (!rules?.length) return true;
+    const result = Array.isArray(rules[0]) ? !rules.filter(el => !onCheck(el, data)).length : onCheck(rules, data);
+    return result;
+}

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

@@ -0,0 +1,9 @@
+import { getTemplate } from "@opengis/fastify-table/utils.js";
+
+export default async function getColumns({
+    columns = [], params = {}, opt = {}, loadTable = {}, form, table, dbColumns = [], mode = 'table',
+}) {
+    const columnList = dbColumns.map((el) => el.name || el).join(',');
+    const cols = columns.filter((el) => columnList.includes(el?.name) && el?.name !== 'geom').map((el) => el?.name || el).join(',');
+    return { cols, columnList };
+}

package/server/routes/data/index.mjs

@@ -0,0 +1,22 @@
+import tableData from './controllers/tableData.js';
+import tokenInfo from './controllers/tokenInfo.js';
+import cardTabData from './controllers/cardTabData.js';
+import cardData from './controllers/cardData.js';
+import tableFilter from './controllers/tableFilter.js';
+import tableInfo from './controllers/tableInfo.js';
+
+import {
+ tableDataSchema, tableDataIdSchema, tableFilterSchema, cardTabDataSchema,
+} from './schema.js';
+
+const policy = ['user'];
+
+export default async function route(app, config = {}) {
+    const { prefix = '/api' } = config;
+    app.get(`${prefix}/table-data/:table`, { config: { policy: ['user', 'no-sql'] }, schema: tableDataSchema }, tableData);
+    app.get(`${prefix}/token-info/:token`, { config: { policy: ['admin'] } }, tokenInfo);
+    app.get(`${prefix}/card-data/:token`, { config: { policy }, scheme: cardTabDataSchema }, cardTabData);
+    app.get(`${prefix}/table-data/:table/:id`, { config: { policy }, schema: tableDataIdSchema }, cardData);
+    app.get(`${prefix}/table-filter/:table`, { config: { policy }, schema: tableFilterSchema }, tableFilter);
+    app.get(`${prefix}/table-info/:table/:id?`, { config: { policy }, schema: tableDataSchema }, tableInfo);
+}

package/server/routes/data/schema.js

@@ -0,0 +1,54 @@
+const tableDataSchema = {
+    querystring: {
+        limit: { type: 'string', pattern: '^(\\d+)$' },
+        page: { type: 'string', pattern: '^(\\d+)$' },
+        // filter: { type: 'string', pattern: '^([\\w\\d_-]+)=([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
+        // search: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
+        order: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+        desc: { type: 'string', pattern: '^(\\d+)$' },
+        state: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+        custom: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+        bbox: { type: 'string', pattern: '^([\\d\\s,.-]+)$' },
+        polyline: { type: 'string', pattern: '^([\\d\\w|@{}~_`]+)$' },
+        // key: { type: 'string', pattern: '^([\\d\\w_]+)$' },
+        sql: { type: 'string', pattern: '^(\\d)$' },
+    },
+    params: {
+        id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+        table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+    }
+};
+
+const tableDataIdSchema = {
+    params: {
+        id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+        name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+    }
+};
+
+const tableFilterSchema = {
+    params: {
+        name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+    }
+};
+
+const cardDataSchema = {
+    params: {
+        id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+        table: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+    }
+};
+
+const cardTabDataSchema = {
+    querystring: {
+        sql: { type: 'string', pattern: '^(\\d)$' }
+    },
+    params: {
+        token: { type: 'string', pattern: '^([\\d\\w]+)$' },
+    }
+};
+export { 
+    tableDataSchema, tableDataIdSchema, tableFilterSchema,
+    cardDataSchema, cardTabDataSchema
+ }
+export default null;

package/server/routes/dblist/index.mjs

@@ -1,18 +1,20 @@
 import readItemList from './controllers/readItems.js';
 import setItem from './controllers/setItem.js';
 
-export default async function plugin(fastify) {
+const policy = ['site'];
 
-  fastify.route({
+export default async function plugin(app, config = {}) {
+  const { prefix = '/api' } = config;
+  app.route({
     method: 'GET',
-    url: '/db-list',
-    config: { policy: ['site'] },
+    url: `${prefix}/db-list`,
+    config: { policy },
     handler: readItemList,
   });
-  fastify.route({
+  app.route({
     method: 'GET',
-    url: '/db-list/:id',
-    config: { policy: ['site'] },
+    url: `${prefix}/db-list/:id`,
+    config: { policy },
     handler: setItem,
   });
 }

package/server/routes/logger/controllers/logger.file.js

@@ -1,93 +1,93 @@
-import path from 'node:path';
-import { lstat, readdir, readFile } from 'node:fs/promises';
-import { createReadStream, existsSync } from 'node:fs';
-import readline from 'node:readline';
-
-import checkUserAccess from './utils/checkUserAccess.js';
-import getRootDir from './utils/getRootDir.js';
-
-/**
- *
- * @method GET
- * @summary API для перегляду логів
- *
- */
-
-export default async function loggerFile({
-  params = {}, user = {}, query = {}, originalUrl,
-}, reply) {
-  const limit = 200000;
-  // console.log(user);
-  const access = checkUserAccess({ user });
-  // log.info('Сервер запущен по адресу?'); // test!
-
-  if (access?.status !== 200) return access;
-
-  // absolute / relative path
-  const rootDir = getRootDir();
-
-  const filepath = path.join(rootDir, params['*'] || '');
-
-  if (!existsSync(filepath)) {
-    return { message: 'file not exists', status: 404 };
-  }
-  const stat = await lstat(filepath);
-  const isFile = stat.isFile();
-
-  if (query.download && isFile) {
-    const buffer = await readFile(filepath, { buffer: true });
-    return buffer;
-  }
-
-  if (query.full && isFile) {
-    if (stat.size > 20 * 1000 * 1000) {
-      return { message: 'file size > 20MB' };
-    }
-    const buffer = await readFile(filepath, { buffer: true });
-    return buffer;
-  }
-
-  if (isFile) {
-    const ext = path.extname(filepath);
-
-    const lines = await new Promise((resolve) => {
-      const rl = readline.createInterface({
-        input: createReadStream(filepath, { start: stat.size > limit ? stat.size - limit : 0 }),
-      });
-      const lines1 = [];
-      rl.on('close', () => resolve(lines1));
-      rl.on('line', (line) => lines1.push(line));
-    });
-
-    if (ext === '.html') {
-      const buffer = await readFile(filepath, { buffer: true });
-      reply.headers({ 'Content-type': 'text/html; charset=UTF-8' });
-      return buffer;
-    }
-
-    reply.headers({ 'Content-type': 'text/plain; charset=UTF-8' });
-    return stat.size > limit && lines.length > 1
-      ? lines.reverse().slice(0, -1).join('\n')
-      : lines.reverse().join('\n');
-  }
-
-  // dir
-  const files = await readdir(filepath);
-
-  if (query.dir) {
-    return files.filter((el) => !['backup', 'marker_icon', 'error', 'migration'].includes(el));
-  }
-
-  const lstatsArr = await Promise.all(files.map(async (file) => [file, await lstat(path.join(filepath, file))]));
-  const lstats = Object.fromEntries(lstatsArr);
-
-  const message = (params['*'] ? '<a href="/logger-file/">...</a><br>' : '')
-    + files.map((file) => `<a href="${originalUrl}/${file}">${file}</a> (${lstats[file].size} bytes)`).join('</br>');
-
-  reply.headers({
-    'Content-Type': 'text/html; charset=UTF-8',
-    'Content-Security-Policy': "default-src 'none'",
-    'X-Content-Type-Options': 'nosniff',
-  });
-  return message;
-}
+import path from 'node:path';
+import { lstat, readdir, readFile } from 'node:fs/promises';
+import { createReadStream, existsSync } from 'node:fs';
+import readline from 'node:readline';
+
+import checkUserAccess from './utils/checkUserAccess.js';
+import getRootDir from './utils/getRootDir.js';
+
+/**
+ *
+ * @method GET
+ * @summary API для перегляду логів
+ *
+ */
+
+export default async function loggerFile({
+  params = {}, user = {}, query = {}, originalUrl,
+}, reply) {
+  const limit = 200000;
+  // console.log(user);
+  const access = checkUserAccess({ user });
+  // log.info('Сервер запущен по адресу?'); // test!
+
+  if (access?.status !== 200) return access;
+
+  // absolute / relative path
+  const rootDir = getRootDir();
+
+  const filepath = path.join(rootDir, params['*'] || '');
+
+  if (!existsSync(filepath)) {
+    return { message: 'file not exists', status: 404 };
+  }
+  const stat = await lstat(filepath);
+  const isFile = stat.isFile();
+
+  if (query.download && isFile) {
+    const buffer = await readFile(filepath, { buffer: true });
+    return buffer;
+  }
+
+  if (query.full && isFile) {
+    if (stat.size > 20 * 1000 * 1000) {
+      return { message: 'file size > 20MB' };
+    }
+    const buffer = await readFile(filepath, { buffer: true });
+    return buffer;
+  }
+
+  if (isFile) {
+    const ext = path.extname(filepath);
+
+    const lines = await new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: createReadStream(filepath, { start: stat.size > limit ? stat.size - limit : 0 }),
+      });
+      const lines1 = [];
+      rl.on('close', () => resolve(lines1));
+      rl.on('line', (line) => lines1.push(line));
+    });
+
+    if (ext === '.html') {
+      const buffer = await readFile(filepath, { buffer: true });
+      reply.headers({ 'Content-type': 'text/html; charset=UTF-8' });
+      return buffer;
+    }
+
+    reply.headers({ 'Content-type': 'text/plain; charset=UTF-8' });
+    return stat.size > limit && lines.length > 1
+      ? lines.reverse().slice(0, -1).join('\n')
+      : lines.reverse().join('\n');
+  }
+
+  // dir
+  const files = await readdir(filepath);
+
+  if (query.dir) {
+    return files.filter((el) => !['backup', 'marker_icon', 'error', 'migration'].includes(el));
+  }
+
+  const lstatsArr = await Promise.all(files.map(async (file) => [file, await lstat(path.join(filepath, file))]));
+  const lstats = Object.fromEntries(lstatsArr);
+
+  const message = (params['*'] ? '<a href="/logger-file/">...</a><br>' : '')
+    + files.map((file) => `<a href="${originalUrl}/${file}">${file}</a> (${lstats[file].size} bytes)`).join('</br>');
+
+  reply.headers({
+    'Content-Type': 'text/html; charset=UTF-8',
+    'Content-Security-Policy': "default-src 'none'",
+    'X-Content-Type-Options': 'nosniff',
+  });
+  return message;
+}

package/server/routes/logger/controllers/utils/checkUserAccess.js

@@ -1,19 +1,19 @@
-import config from '../../../../../config.js';
-
-/**
- *
- * @summary check user access to logger interface - per admin user type or user group
- * @returns {Object} message, status
- */
-
-export default function checkUserAccess({ user = {} }) {
-  // console.log(user);
-  if (user.user_type !== 'admin' && !config?.local) {
-    return { message: 'access restricted', status: 403 };
-  }
-
-  /* if (!['admin', 'superadmin']?.includes(user.user_type) && count === '0') {
-    return { message: 'access restricted', status: 403 };
-  } */
-  return { message: 'access granted', status: 200 };
-}
+import config from '../../../../../config.js';
+
+/**
+ *
+ * @summary check user access to logger interface - per admin user type or user group
+ * @returns {Object} message, status
+ */
+
+export default function checkUserAccess({ user = {} }) {
+  // console.log(user);
+  if (user.user_type !== 'admin' && !config?.local) {
+    return { message: 'access restricted', status: 403 };
+  }
+
+  /* if (!['admin', 'superadmin']?.includes(user.user_type) && count === '0') {
+    return { message: 'access restricted', status: 403 };
+  } */
+  return { message: 'access granted', status: 200 };
+}

package/server/routes/logger/controllers/utils/getRootDir.js

@@ -1,26 +1,26 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-import config from '../../../../../config.js';
-
-// import { existsSync } from 'fs';
-let logDir = null;
-export default function getRootDir() {
-  // absolute / relative path
-  if (logDir) return logDir;
-  const file = ['config.json', '/data/local/config.json'].find(el => (fs.existsSync(el) ? el : null));
-  const root = file === 'config.json' ? process.cwd() : '/data/local';
-  logDir = config.logDir || path.join(root, config.log?.dir || 'log');
-  console.log({ logDir });
-  return logDir;
-
-  // windows debug support
-  /* const customLogDir = process.cwd().includes(':') ? 'c:/data/local' : '/data/local';
-  // docker default path
-  if (existsSync(customLogDir)) {
-    return path.join(customLogDir, config.folder || '', 'log');
-  }
-
-  // non-docker default path
-  return path.join(config.root || '/data/local', config.folder || '', 'log'); */
-}
+import fs from 'node:fs';
+import path from 'node:path';
+
+import config from '../../../../../config.js';
+
+// import { existsSync } from 'fs';
+let logDir = null;
+export default function getRootDir() {
+  // absolute / relative path
+  if (logDir) return logDir;
+  const file = ['config.json', '/data/local/config.json'].find(el => (fs.existsSync(el) ? el : null));
+  const root = file === 'config.json' ? process.cwd() : '/data/local';
+  logDir = config.logDir || path.join(root, config.log?.dir || 'log');
+  console.log({ logDir });
+  return logDir;
+
+  // windows debug support
+  /* const customLogDir = process.cwd().includes(':') ? 'c:/data/local' : '/data/local';
+  // docker default path
+  if (existsSync(customLogDir)) {
+    return path.join(customLogDir, config.folder || '', 'log');
+  }
+
+  // non-docker default path
+  return path.join(config.root || '/data/local', config.folder || '', 'log'); */
+}

package/server/routes/logger/index.js

@@ -1,17 +1,17 @@
-import loggerFile from './controllers/logger.file.js';
-
-// import loggerTest from './controllers/logger.test.api.js';
-
-const loggerSchema = {
-  querystring: {
-    download: { type: 'string', pattern: '^(\\d+)$' },
-    full: { type: 'string', pattern: '^(\\d+)$' },
-    dir: { type: 'string', pattern: '^(\\d+)$' },
-  },
-};
-
-async function plugin(fastify) {
-  fastify.get('/logger-file/*', { config: { policy: ['site'] }, schema: loggerSchema }, loggerFile);
-}
-
-export default plugin;
+import loggerFile from './controllers/logger.file.js';
+
+// import loggerTest from './controllers/logger.test.api.js';
+
+const loggerSchema = {
+  querystring: {
+    download: { type: 'string', pattern: '^(\\d+)$' },
+    full: { type: 'string', pattern: '^(\\d+)$' },
+    dir: { type: 'string', pattern: '^(\\d+)$' },
+  },
+};
+
+async function plugin(app) {
+  app.get('/logger-file/*', { config: { policy: ['site'] }, schema: loggerSchema }, loggerFile);
+}
+
+export default plugin;