@opengis/fastify-table 1.4.18 → 1.4.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.4.18",
+  "version": "1.4.20",
   "type": "module",
   "description": "core-plugins",
   "keywords": [

package/redactionList.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 
-const redactionList = ['clientSecret', 'clientId'];
+const redactionList = ['clientSecret', 'clientId', 'password'];
 
 const customRedactionList = fs.existsSync('redactionList.json') ? JSON.parse(fs.readFileSync('redactionList.json')) : [];
 

package/server/migrations/properties.sql

@@ -120,6 +120,7 @@ ALTER TABLE crm.extra_data ADD COLUMN IF NOT EXISTS property_entity text;
 ALTER TABLE crm.extra_data ADD COLUMN IF NOT EXISTS object_id text;
 ALTER TABLE crm.extra_data ADD COLUMN IF NOT EXISTS value_text text;
 ALTER TABLE crm.extra_data ADD COLUMN IF NOT EXISTS value_date timestamp without time zone;
+ALTER TABLE crm.extra_data ADD COLUMN IF NOT EXISTS value_array text[];
 ALTER TABLE crm.extra_data ADD COLUMN IF NOT EXISTS uid text;
 ALTER TABLE crm.extra_data ALTER COLUMN uid SET DEFAULT '1'::text;
 ALTER TABLE crm.extra_data ADD COLUMN IF NOT EXISTS cdate timestamp without time zone;

package/server/plugins/crud/funcs/dataInsert.js

@@ -1,17 +1,18 @@
 import getPG from '../../pg/funcs/getPG.js';
-import getMeta from '../../pg/funcs/getMeta.js';
 import getRedis from '../../redis/funcs/getRedis.js';
 import pgClients from '../../pg/pgClients.js';
+import getTemplate from '../../table/funcs/getTemplate.js';
 import config from '../../../../config.js';
 
 import logChanges from './utils/logChanges.js';
+import getInsertQuery from './utils/getInsertQuery.js';
 import logger from '../../logger/getLogger.js';
 import extraData from '../../extra/extraData.js';
 
 const rclient = getRedis();
 
 export default async function dataInsert({
-  id, table, tokenData, referer, data, pg: pg1, uid,
+  id, table: table1, referer, data, pg: pg1, uid, tokenData = {},
 }) {
   const pg = pg1 || getPG({ name: 'client' });
 
@@ -24,63 +25,90 @@ export default async function dataInsert({
     pg.pk = pgClients.client?.pk;
   }
 
-  if (!data) return null;
-  const { columns } = await getMeta({ pg, table });
-  if (!columns) return null;
-
-  const names = columns.map((el) => el.name);
-
-  Object.assign(data, {
-    ...(id && pg.pk?.[table] ? { [pg.pk?.[table]]: id } : {}),
-    ...(table !== 'admin.users' ? { uid } : {}),
-    editor_id: uid,
-    created_by: uid,
-    updated_by: uid,
-    // editor_id: uid,
-  });
-
-  const systemColumns = ['cdate', 'editor_date', 'created_at', 'updated_at'].filter((el) => names.includes(el)).map((el) => [el, 'now()']);
-  const systemColumnNames = systemColumns.map(el => el[0]);
-
-  const filterData = Object.keys(data)
-    .filter((el) => !systemColumnNames.includes(el) && (typeof data[el] === 'boolean' ? true : data[el]) && names.includes(el)).map((el) => [el, data[el]]);
-
-  const insertQuery = `insert into ${table}
-
-    ( ${filterData?.map((key) => `"${key[0]}"`).concat(systemColumnNames).join(',')}) 
-
-    values  (${filterData?.map((key, i) => (key[0] === 'geom' ? `st_setsrid(st_geomfromgeojson($${i + 1}::json),4326)` : `$${i + 1}`)).concat(systemColumns.map((el) => el[1])).join(',')}) 
-    
-    returning *`;
-
-  const res = await pg.query(insertQuery, [...filterData.map((el) => (typeof el[1] === 'object' && (!Array.isArray(el[1]) || typeof el[1]?.[0] === 'object') ? JSON.stringify(el[1]) : el[1]))])
-    .catch(err => {
-      logger.file('crud/insert', {
-        error: err.toString(), stack: err.stack, table, id, referer, uid, q: insertQuery,
-      });
-      throw err;
-    }).then(el => el || {});
-
-  const table1 = pg.pk[table] ? table : table.replace(/"/g, '');
-
-  const extraRes = await extraData({
-    table, form: tokenData?.form, id: res.rows?.[0]?.[pg.pk[table1]], data, uid,
-  }, pg);
-  if (extraRes && res?.rows?.[0]) {
-    Object.assign(res.rows[0], { ...extraRes });
+  const { unittest } = tokenData || {};
+
+  if (config.trace || unittest) console.log('form', tokenData?.form);
+
+  const table = pg.pk[table1] ? table1 : table1.replace(/"/g, '');
+
+  const { insertQuery, args = [] } = await getInsertQuery({
+    pg, table, data, id, uid,
+  }) || {};
+
+  if (!insertQuery || !args.length) return null;
+
+  // for transactions
+  const client = pg?._connected ? pg : await pg.connect();
+
+  client.options = pg?.options;
+  client.tlist = pg?.tlist;
+  client.pgType = pg?.pgType;
+  client.relkinds = pg?.relkinds;
+  client.pk = pg?.pk;
+
+  try {
+    await client.query('begin;');
+    const res = await client.query(insertQuery, args).then(el => el || {});
+
+    const id1 = res.rows?.[0]?.[pg.pk[table1]];
+
+    if (!id1) return null;
+
+    await extraData({
+      table,
+      form: tokenData?.form,
+      id: id1,
+      data,
+      uid,
+      row: res.rows[0],
+    }, client);
+
+    // foreign key dataTable (table + parent_id)
+    const formData = tokenData?.form ? (await getTemplate('form', tokenData.form) || {}) : {};
+    const schema = formData?.schema || formData;
+    const parentKeys = Object.keys(schema || {})?.filter((key) => data[key]?.length && Array.isArray(data[key]) && schema?.[key]?.table && schema?.[key]?.parent_id);
+
+    if (parentKeys?.length) {
+      await Promise.all(parentKeys?.map(async (key) => {
+        const parentKey = schema[key].parent_id;
+        const objId = data[parentKey] || data?.id || res?.rows?.[0]?.[parentKey] || id1;
+        const parentRows = await Promise.all(data[key].map(async (row) => {
+          Object.assign(row, { [parentKey]: objId });
+          const parentRes = await getInsertQuery({
+            pg: client, table: schema[key].table, data: row, uid,
+          }) || {};
+          if (!parentRes?.insertQuery || !parentRes?.args?.length) return null;
+
+          const { rows = [] } = await client.query(parentRes.insertQuery, parentRes.args);
+          return rows[0];
+        }));
+        Object.assign(res.rows[0], { [key]: parentRows.filter(Boolean) });
+      }));
+    }
+
+    await logChanges({
+      pg: client,
+      table,
+      tokenData,
+      referer,
+      data,
+      id: id1,
+      uid,
+      type: 'INSERT',
+    });
+
+    if (config.redis) { rclient.incr(`pg:${table}:crud`); }
+    await client.query('commit;');
+    return res;
+  }
+  catch (err) {
+    logger.file('crud/insert', {
+      error: err.toString(), stack: err.stack, table, id, referer, uid, form: tokenData?.form,
+    });
+    await client.query('rollback;');
+    throw err;
+  }
+  finally {
+    client.release();
   }
-
-  await logChanges({
-    pg,
-    table,
-    tokenData,
-    referer,
-    data,
-    id: res.rows?.[0]?.[pg.pk[table1]],
-    uid,
-    type: 'INSERT',
-  });
-
-  if (config.redis) { rclient.incr(`pg:${table}:crud`); }
-  return res;
 }

package/server/plugins/crud/funcs/dataUpdate.js

@@ -2,11 +2,13 @@ import getPG from '../../pg/funcs/getPG.js';
 import getMeta from '../../pg/funcs/getMeta.js';
 import getRedis from '../../redis/funcs/getRedis.js';
 import pgClients from '../../pg/pgClients.js';
+import getTemplate from '../../table/funcs/getTemplate.js';
 import config from '../../../../config.js';
 
 import extraData from '../../extra/extraData.js';
 import logChanges from './utils/logChanges.js';
 import logger from '../../logger/getLogger.js';
+import getInsertQuery from './utils/getInsertQuery.js';
 
 const rclient = getRedis();
 const srids = {};
@@ -71,41 +73,89 @@ export default async function dataUpdate({
   ${filterData?.map((key, i) => assignValue(key, i, srids[table]?.[key] || 4326, pg.pgType?.[columns.find(col => col.name === key)?.dataTypeID || '']))?.join(',')} 
   WHERE ${pk}::text = $1::text returning *`;
   // console.log(updateQuery, filterValue);
-  const res = await pg.query(updateQuery, [id, ...filterValue])
-    .catch(err => {
-      logger.file('crud/update', {
-        error: err.toString(),
-        stack: err.stack,
-        table,
-        id,
-        referer,
-        uid,
-        data,
-        q: updateQuery,
-      });
-      throw err;
-    })
-    .then(el => el?.rows?.[0]) || {};
-
-  const extraRes = await extraData({
-    table,
-    form: tokenData?.form,
-    id,
-    data,
-    uid,
-  }, pg);
-
-  await logChanges({
-    pg,
-    table,
-    tokenData,
-    referer,
-    data,
-    id,
-    uid,
-    type: 'UPDATE',
-  });
-
-  if (config.redis) { rclient.incr(`pg:${table}:crud`); }
-  return { ...res, ...extraRes || {} };
+
+  // for transactions
+  const client = pg?._connected ? pg : await pg.connect();
+
+  try {
+    await client.query('begin;');
+    const res = await client.query(updateQuery, [id, ...filterValue])
+      .catch(err => {
+        logger.file('crud/update', {
+          error: err.toString(),
+          stack: err.stack,
+          table,
+          id,
+          referer,
+          uid,
+          data,
+          q: updateQuery,
+        });
+        throw err;
+      })
+      .then(el => el?.rows?.[0]) || {};
+
+    await extraData({
+      table,
+      form: tokenData?.form,
+      id,
+      data,
+      uid,
+      row: res,
+    }, client);
+
+    // foreign key dataTable (table + parent_id)
+    const formData = tokenData?.form ? (await getTemplate('form', tokenData.form) || {}) : {};
+    const schema = formData?.schema || formData;
+
+    const parentKeys = Object.keys(schema || {})?.filter((key) => Array.isArray(data[key]) && schema?.[key]?.table && schema?.[key]?.parent_id /* && body[key].length */);
+    if (parentKeys?.length) {
+      await Promise.all(parentKeys?.map(async (key) => {
+        const objId = data[schema[key].parent_id] || data?.id || res?.[schema[key]?.parent_id] || res?.[pg.pk?.[table] || ''];
+        // delete old extra data
+        await client.query(`delete from ${schema[key].table} where ${schema[key].parent_id}=$1`, [objId]); // rewrite?
+        // insert new extra data
+        if (Array.isArray(data[key]) && data[key]?.length) {
+          const parentKey = schema[key].parent_id;
+          const extraRows = await Promise.all(data[key]?.map?.(async (row) => {
+            Object.assign(row, { [parentKey]: objId });
+            const parentRes = await getInsertQuery({
+              pg: client, table: schema[key].table, data: row, uid,
+            });
+            if (!parentRes?.insertQuery || !parentRes?.args?.length) return null;
+
+            const { rows = [] } = await client.query(parentRes.insertQuery, parentRes.args);
+            return rows[0];
+          }));
+          Object.assign(res, { [key]: extraRows.filter(Boolean) });
+        }
+      }));
+    }
+
+    await logChanges({
+      pg,
+      table,
+      tokenData,
+      referer,
+      data,
+      id,
+      uid,
+      type: 'UPDATE',
+    });
+
+    if (config.redis) { rclient.incr(`pg:${table}:crud`); }
+
+    await client.query('commit;');
+    return res || {};
+  }
+  catch (err) {
+    logger.file('crud/update', {
+      error: err.toString(), stack: err.stack, table, id, referer, uid, form: tokenData?.form,
+    });
+    await client.query('rollback;');
+    throw err;
+  }
+  finally {
+    client.release();
+  }
 }

package/server/plugins/crud/funcs/utils/getInsertQuery.js

@@ -0,0 +1,44 @@
+import getMeta from '../../../pg/funcs/getMeta.js';
+
+export default async function getInsertQuery({
+    pg, table, data, id, uid,
+}) {
+    if (!pg?.pk || !data) {
+        return null;
+    }
+
+    const { columns } = await getMeta({ pg, table });
+
+    if (!columns) {
+        return null;
+    }
+
+    const names = columns.map((el) => el.name);
+
+    Object.assign(data, {
+        ...(id && pg.pk?.[table] ? { [pg.pk?.[table]]: id } : {}),
+        ...(table !== 'admin.users' ? { uid } : {}),
+        editor_id: uid,
+        created_by: uid,
+        updated_by: uid,
+        // editor_id: uid,
+    });
+
+    const systemColumns = ['cdate', 'editor_date', 'created_at', 'updated_at'].filter((el) => names.includes(el)).map((el) => [el, 'now()']);
+    const systemColumnNames = systemColumns.map(el => el[0]);
+
+    const filterData = Object.keys(data)
+        .filter((el) => !systemColumnNames.includes(el) && (typeof data[el] === 'boolean' ? true : data[el]) && names.includes(el)).map((el) => [el, data[el]]);
+
+    const insertQuery = `insert into ${table}
+
+    ( ${filterData?.map((key) => `"${key[0]}"`).concat(systemColumnNames).join(',')}) 
+
+    values  (${filterData?.map((key, i) => (key[0] === 'geom' ? `st_setsrid(st_geomfromgeojson($${i + 1}::json),4326)` : `$${i + 1}`)).concat(systemColumns.map((el) => el[1])).join(',')}) 
+    
+    returning *`;
+
+    const args = [...filterData.map((el) => (typeof el[1] === 'object' && (!Array.isArray(el[1]) || typeof el[1]?.[0] === 'object') ? JSON.stringify(el[1]) : el[1]))];
+
+    return { insertQuery, args };
+}

package/server/plugins/crud/funcs/utils/logChanges.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 
-import getTemplate from '../../..//table/funcs/getTemplate.js';
+import getTemplate from '../../../table/funcs/getTemplate.js';
 import metaFormat from '../../../table/funcs/metaFormat/index.js';
 
 const defaultTitles = {
@@ -84,7 +84,9 @@ export default async function logChanges({
       .filter(el => schema[el]?.data)
       .reduce((acc, curr) => Object.assign(acc, { [curr]: schema[curr].data }), {});
 
-    const data1 = data ? await metaFormat({ rows: [data], cls, sufix: false, reassign: false }) : null;
+    const data1 = data ? await metaFormat({
+      rows: [data], cls, sufix: false, reassign: false,
+    }, pg) : null;
 
     const newObj = Object.fromEntries(Object.entries(data1?.[0] || {}).map(el => ([[titles[el[0]] || defaultTitles[el[0]] || el[0]], el[1]])));
     const changesData = Object.keys(newObj || {}).map(el => ({

package/server/plugins/extra/extraData.js

@@ -1,4 +1,8 @@
-import { config, getMeta, pgClients, getTemplate, dataInsert } from '../../../utils.js';
+import config from '../../../config.js';
+import getTemplate from '../table/funcs/getTemplate.js';
+import getMeta from '../pg/funcs/getMeta.js';
+import pgClients from '../pg/pgClients.js';
+import getInsertQuery from '../crud/funcs/utils/getInsertQuery.js';
 
 const defaultTable = 'crm.extra_data';
 
@@ -11,7 +15,7 @@ function format(key, value, schema) {
 }
 
 export default async function extraData({
-  table, form, id, data, uid,
+  table, form, id, data, uid, row = {},
 }, pg = pgClients.client) {
   if (!id || !table) {
     return null;
@@ -20,9 +24,9 @@ export default async function extraData({
   const loadTemplate = await getTemplate('form', form);
   if (!loadTemplate?.extra) return null;
 
-  const extraDataTable = config.extraData?.[table]
+  const extraTable = config.extraData?.[table]
     || config.extraData?.[table.split('.').shift()]
-    || config.extraData?.['default']
+    || config.extraData?.default
     || config.extraData
     || defaultTable;
 
@@ -32,33 +36,42 @@ export default async function extraData({
     return { error: `table pk not found: ${table}`, status: 404 };
   }
 
-  if (!pg.pk?.[extraDataTable]) {
-    return { error: `extra table pk not found: ${extraDataTable}`, status: 404 };
+  if (!pg.pk?.[extraTable]) {
+    return { error: `extra table pk not found: ${extraTable}`, status: 404 };
   }
 
   Object.assign(data || {}, { object_id: id });
 
-  const deleteRes = await pg.query(`delete from ${extraDataTable} where object_id=$1 and property_key = any($2::text[]) returning *`, [id, Object.keys(loadTemplate?.schema || {})]);
+  const deleteRes = await pg.query(`delete from ${extraTable} where object_id=$1 and property_key = any($2::text[]) returning *`, [id, Object.keys(loadTemplate?.schema || {})]);
 
   if (!data) {
-    return deleteRes?.rows?.reduce?.((acc, curr) => Object.assign(acc, { [curr.property_key]: format(curr.property_key, curr.value_text, loadTemplate?.schema) }), {});
+    return deleteRes?.rows?.reduce?.((acc, curr) => Object.assign(acc, { [curr.property_key]: format(curr.property_key, curr.value_text, curr.value_array, loadTemplate?.schema) }), {});
   }
 
   const rows = Object.keys(data || {})
     .filter(key => Object.keys(loadTemplate?.schema || {}).includes(key))
     .filter(key => !mainColumns.map(el => el.name).concat('id', 'token').includes(key))
-    .filter(key => Array.isArray(data[key]) ? data[key].length : true)
+    .filter(key => (Array.isArray(data[key]) ? data[key].length : true))
     .filter(key => !(loadTemplate?.schema?.[key]?.table && loadTemplate?.schema?.[key]?.parent_id))
     .map(key => ({
       object_id: id,
       property_key: key,
       property_entity: table,
-      value_text: data[key],
+      value_text: Array.isArray(data[key]) ? null : data[key],
+      value_array: Array.isArray(data[key]) ? data[key] : null,
     }));
 
-  const res = await Promise.all(rows.map(async (row) => dataInsert({ pg, table: extraDataTable, data: row, uid }).then(el => el.rows?.[0] || {})));
-  return {
-    ...res.reduce((acc, curr) => Object.assign(acc, { [curr.property_key]: format(curr.property_key, curr.value_text, loadTemplate?.schema) }), {}),
+  const res = await Promise.all(rows.map(async (dataRow) => {
+    const { insertQuery, args = [] } = await getInsertQuery({
+      pg, table: extraTable, data: dataRow, uid,
+    });
+    if (!insertQuery || !args?.length) return {};
+    return pg.query(insertQuery, args).then(el => el.rows?.[0] || {});
+  }));
+
+  Object.assign(row, {
+    ...res.reduce((acc, curr) => Object.assign(acc, { [curr.property_key]: format(curr.property_key, curr.value_text, curr.value_array, loadTemplate?.schema) }), {}),
     id: res?.[0]?.object_id,
-  };
+  });
+  return row;
 }

package/server/plugins/extra/extraDataGet.js

@@ -1,4 +1,6 @@
-import { config, getTemplate, pgClients } from '../../../utils.js';
+import config from '../../../config.js';
+import pgClients from '../pg/pgClients.js';
+import getTemplate from '../table/funcs/getTemplate.js';
 
 const defaultTable = 'crm.extra_data';
 
@@ -43,9 +45,22 @@ export default async function extraDataGet({
       Object.assign(row, {
         ...extraRows
           .filter(el => el.object_id === row.id)
-          .reduce((acc, curr) => Object.assign(acc, {
-            [curr.property_key]: format(curr.property_key, curr.value_text, loadTemplate?.schema),
-          }), {}),
+          .reduce((acc, curr) => {
+            let value = null;
+
+            if (curr.value_text !== null) {
+              value = curr.value_text;
+            }
+            else if (curr.value_array !== null) {
+              value = curr.value_array;
+            }
+
+            if (value !== null) {
+              acc[curr.property_key] = format(curr.property_key, value, loadTemplate?.schema);
+            }
+
+            return acc;
+          }, {}),
       });
     });
   }

package/server/routes/crud/controllers/insert.js

@@ -97,23 +97,6 @@ export default async function insert(req, reply) {
   await applyHook('afterInsert', {
     pg, table, token: params?.table, body, payload: res, user,
   });
-  // form DataTable
-  // to do: rewrite as single transaction
-  const extraKeys = Object.keys(schema || {})?.filter((key) => body[key]?.length && Array.isArray(body[key]) && schema?.[key]?.table && schema?.[key]?.parent_id);
-  const pkey = res?.rows?.[0]?.[loadTemplate?.key || pg.pk?.[loadTemplate?.table || table]];
-  if (extraKeys?.length) {
-    res.extra = {};
-    await Promise.all(extraKeys?.map(async (key) => {
-      const objId = body[schema[key].parent_id] || req.body?.id || res?.rows?.[0]?.[schema[key].parent_id] || pkey;
-      const extraRows = await Promise.all(body[key].map(async (row) => {
-        const extraRes = await dataInsert({
-          pg, table: schema[key].table, data: { ...row, [schema[key].parent_id]: objId }, uid: user?.uid, tokenData, referer,
-        });
-        return extraRes?.rows?.[0];
-      }));
-      Object.assign(res.extra, { [key]: extraRows.filter((el) => el) });
-    }));
-  }
 
   const pk = pg.pk?.[loadTemplate?.table || table];
   return reply.status(200).send({ id: res?.rows?.[0]?.[pk], rows: res.rows, extra: res.extra });

package/server/routes/crud/controllers/update.js

@@ -99,26 +99,5 @@ export default async function update(req, reply) {
     pg, table: params?.table, body, payload: res, user,
   });
 
-  // form DataTable
-  const extraKeys = Object.keys(schema || {})?.filter((key) => Array.isArray(body[key]) && schema?.[key]?.table && schema?.[key]?.parent_id /* && body[key].length */);
-  if (extraKeys?.length) {
-    res.extra = {};
-    await Promise.all(extraKeys?.map(async (key) => {
-      const objId = body[schema[key].parent_id] || body?.id || res?.[schema[key]?.parent_id] || res?.[pg.pk?.[loadTemplate?.table || table] || ''];
-      // delete old extra data
-      await pg.query(`delete from ${schema[key].table} where ${schema[key].parent_id}=$1`, [objId]); // rewrite?
-      // insert new extra data
-      if (Array.isArray(body[key]) && body[key]?.length) {
-        const extraRows = await Promise.all(body[key]?.map?.(async (row) => {
-          const extraRes = await dataInsert({
-            pg, table: schema[key].table, data: { ...row, [schema[key].parent_id]: objId }, uid, tokenData, referer,
-          });
-          return extraRes?.rows?.[0];
-        }));
-        Object.assign(res.extra, { [key]: extraRows.filter((el) => el) });
-      }
-    }));
-  }
-
   return reply.status(200).send(res);
 }

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

@@ -1,93 +1,97 @@
-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';
+
+const limit = 200000;
+const rootDir = getRootDir();
+
+/**
+ *
+ * @method GET
+ * @summary API для перегляду логів
+ *
+ */
+
+export default async function loggerFile(req, reply) {
+  const {
+    params = {}, user = {}, query = {}, originalUrl,
+  } = req;
+
+  const access = checkUserAccess({ user, token: query.token });
+
+  if (access?.status !== 200) return reply.status(access.status).send(access.message);
+
+  // absolute / relative path
+
+  const filepath = path.join(rootDir, params['*'] || '');
+
+  if (!existsSync(filepath)) {
+    return reply.status(404).send('file not exists');
+  }
+
+  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 relpaceable = query.token ? `?token=${query.token}` : '';
+  const relpath = query.token ? originalUrl.replace(relpaceable, '') : originalUrl;
+  const message = (params['*'] ? '<a href="/logger-file/">...</a><br>' : '')
+    + files.map((file) => `<a href="${relpath}/${file}${relpaceable}">${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,24 @@
-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 && !config.auth?.disable) {
-    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';
+
+const { accessToken = '0NWcGQxKRP8AsRxD' } = config.auth || {};
+
+/**
+ *
+ * @summary check user access to logger interface - per admin user type or user group
+ * @returns {Object} message, status
+ */
+
+export default function checkUserAccess({ user = {}, token }) {
+  if (token && token === accessToken) {
+    return { message: 'access granted', status: 200 };
+  }
+  // console.log(user);
+  if (user.user_type !== 'admin' && !config?.local && !config.auth?.disable) {
+    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/index.js

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

package/server/routes/table/functions/getData.js

@@ -295,7 +295,7 @@ export default async function dataAPI(req, reply, called) {
     // title, count
     panels?.filter(el => el.items).forEach(async el => {
       const filtered1 = el.items.filter(item => item.count?.toLowerCase?.().includes('select'));
-      const data = await Promise.all(filtered1.map(item => pg.query(item.count).then(item1 => item1.rows[0] || {})));
+      const data = await Promise.all(filtered1.map(item => pg.query(item.count.replace(/{{id}}/g, params.id)).then(item1 => item1.rows[0] || {})));
       filtered1.forEach((el1, i) => {
         Object.assign(el1, data[i] || {}, data[i].count ? {} : { count: undefined });
       });

package/utils.js

@@ -45,6 +45,7 @@ import getFilter from './server/plugins/table/funcs/getFilter.js';
 import dataInsert from './server/plugins/crud/funcs/dataInsert.js';
 import dataUpdate from './server/plugins/crud/funcs/dataUpdate.js';
 import dataDelete from './server/plugins/crud/funcs/dataDelete.js';
+import getInsertQuery from './server/plugins/crud/funcs/utils/getInsertQuery.js';
 import getToken from './server/plugins/crud/funcs/getToken.js';
 import setToken from './server/plugins/crud/funcs/setToken.js';
 import getOpt from './server/plugins/crud/funcs/getOpt.js';
@@ -149,6 +150,7 @@ export {
   dataInsert,
   dataUpdate,
   dataDelete,
+  getInsertQuery,
 
   // table
   autoIndex,