@opengis/fastify-table 1.4.25 → 1.4.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.4.25",
+  "version": "1.4.27",
   "type": "module",
   "description": "core-plugins",
   "keywords": [
@@ -51,8 +51,8 @@
     "uglify-js": "3.19.3"
   },
   "devDependencies": {
-    "eslint": "8.49.0",
-    "eslint-config-airbnb": "19.0.4"
+    "eslint": "^8.49.0",
+    "eslint-config-airbnb": "^19.0.4"
   },
   "author": "Softpro",
   "license": "ISC"

package/server/plugins/table/funcs/getFilter.js

@@ -1,8 +1,14 @@
 import routeFilter from '../../../routes/table/controllers/filter.js';
 
-export default async function getFilter({ pg, table, filter, custom, state, search, user }) {
+export default async function getFilter({
+    pg, table, filter, custom, state, search, user,
+}, reply) {
     const params = { table };
-    const query = { filter, custom, state, search };
-    const result = await routeFilter({ pg, params, query, user });
+    const query = {
+        filter, custom, state, search,
+    };
+    const result = await routeFilter({
+        pg, params, query, user,
+    }, reply, 1);
     return result;
 }

package/server/plugins/table/funcs/getFilterSQL/index.js

@@ -7,6 +7,7 @@ import config from '../../../../../config.js';
 import getTableSql from './util/getTableSql.js';
 import getFilterQuery from './util/getFilterQuery.js';
 import getOptimizedQuery from './util/getOptimizedQuery.js';
+import getFilter from '../getFilter.js';
 
 const checkInline = {};
 const defaultTable = 'crm.extra_data';
@@ -85,30 +86,34 @@ export default async function getFilterSQL({
         return pk && !fieldsList.includes(name) ? `${pk} in (select ${pk} from (${fieldQuery.replace(/limit 0/g, '')} where ${name} ${sval} )q where 1=1)` : `${name} ${sval}`;
       }).join(' or ')} )` : '';
 
-    const filterList1 = await Promise.all((filterList || (body?.filter_list || [])
-      .concat(body?.filterInline || [])
-      .concat(body?.filterCustom || [])
-      .concat(body?.filterState || [])
-      .concat(body?.filterList || [])
-      .concat(body?.filters || [])
-    )?.filter(el => el.id || el.name)?.map(async (el) => {
-      el.name = el.name || el.id;
-
-      if (el.name && extraColumns.find(item => item?.name === el?.name)) {
-        Object.assign(el, { extra: { table: extraDataTable, input: extraColumns.find(item => item?.name === el?.name)?.type } });
-      }
-      if (!el?.data) return el;
-      // const cls = await getTemplate(['cls', 'select'], el.data); // only git cls
-      const cls = await getSelect(el.data, pg); // git + db cls
-
-      if (Array.isArray(cls?.arr) && cls.arr.length) {
-        Object.assign(el, { cls: el.data, options: cls, select: `select code, name from admin.cls where parent='${el.data}'` });
-      }
-      else if (typeof (cls?.sql || cls) === 'string') {
-        Object.assign(el, { select: cls?.sql || cls });
-      }
-      return el;
-    }));
+    const filterResponse = await getFilter({
+      pg, table, user: { uid },
+    }, null, 1);
+
+    const filterList1 = await Promise.all((filterList || [])
+      .concat(filterResponse?.inline || [])
+      .concat(filterResponse?.custom || [])
+      .concat(filterResponse?.state || [])
+      .concat(filterResponse?.list || [])
+      ?.filter(el => el.id || el.name)
+      ?.map(async (el) => {
+        el.name = el.name || el.id;
+
+        if (el.name && extraColumns.find(item => item?.name === el?.name)) {
+          Object.assign(el, { extra: { table: extraDataTable, input: extraColumns.find(item => item?.name === el?.name)?.type } });
+        }
+        if (!el?.data) return el;
+        // const cls = await getTemplate(['cls', 'select'], el.data); // only git cls
+        const cls = await getSelect(el.data, pg); // git + db cls
+
+        if (Array.isArray(cls?.arr) && cls.arr.length) {
+          Object.assign(el, { cls: el.data, options: cls, select: `select code, name from admin.cls where parent='${el.data}'` });
+        }
+        else if (typeof (cls?.sql || cls) === 'string') {
+          Object.assign(el, { select: cls?.sql || cls });
+        }
+        return el;
+      }));
 
     const modelQuery = body?.model || body?.table || table;
 

package/server/routes/table/controllers/filter.js

@@ -1,26 +1,42 @@
-import {
-  logger, autoIndex, getSelect, getTemplate, getSelectVal, pgClients,
-} from '../../../../utils.js';
-
-export default async function filterAPI(req) {
+/* import {
+  logger, autoIndex, getSelect, getTemplate, getSelectVal, pgClients, applyHook,
+} from '../../../../utils.js'; */
+
+import logger from '../../../plugins/logger/getLogger.js';
+import autoIndex from '../../../plugins/pg/funcs/autoIndex.js';
+import getSelect from '../../../plugins/table/funcs/getSelect.js';
+import getSelectVal from '../../../plugins/table/funcs/metaFormat/getSelectVal.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+import applyHook from '../../../plugins/hook/funcs/applyHook.js';
+import getTemplate from '../../../plugins/table/funcs/getTemplate.js';
+
+export default async function filterAPI(req, reply, iscalled) {
   const time = Date.now();
 
   const {
     params, pg = pgClients.client, user = {}, query = {},
   } = req;
 
+  const hookData = await applyHook('preFilter', { pg, table: params.table });
   const loadTable = await getTemplate('table', params.table);
-  if (!loadTable) { return { status: 404, message: 'not found' }; }
 
-  const sqlTable = loadTable.sql?.filter?.((el) => !el?.disabled && el?.sql?.replace).map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', user?.uid)}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
-  const { fields: columns = [] } = await pg.query(`select * from ${loadTable.table} t ${sqlTable} limit 0`);
-  const { fields = [] } = await pg.query(`select * from ${loadTable.table} t limit 0`);
+  const {
+    table, sql, query: tableQuery, form, extra, filterState, filterCustom,
+  } = hookData || loadTable || {};
+
+  if (!table) {
+    return { status: 404, message: 'not found' };
+  }
+
+  const sqlTable = sql?.filter?.((el) => !el?.disabled && el?.sql?.replace)?.map?.((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', user?.uid)}) ${el.name || `t${i}`} on 1=1 `)?.join?.('') || '';
+  const { fields: columns = [] } = await pg.query(`select * from ${table} t ${sqlTable} limit 0`);
+  const { fields = [] } = await pg.query(`select * from ${table} t limit 0`);
 
-  const optimizedSQL = `select * from ${loadTable.table} t ${sqlTable} where ${loadTable.query || '1=1'}`.replace(/{{uid}}/g, user?.uid);
+  const optimizedSQL = `select * from ${table} t ${sqlTable} where ${tableQuery || '1=1'}`.replace(/{{uid}}/g, user?.uid);
 
   if (query?.sql && user?.user_type === 'admin') return optimizedSQL;
 
-  const filters = (loadTable?.filter_list || loadTable?.filters || loadTable?.filterList || []).concat(loadTable?.filterSql || []);
+  const filters = (hookData?.filters || loadTable?.filter_list || loadTable?.filters || loadTable?.filterList || []).concat(loadTable?.filterSql || []);
 
   // admin.custom_column - user filter NA-165
   const { rows: properties = [] } = await pg.query('select column_id, name, title, format, data from admin.custom_column where entity=$1 and uid=$2 and filter', [params.table, user?.uid]);
@@ -29,25 +45,25 @@ export default async function filterAPI(req) {
   }));
 
   // KRYVYIRIH-231
-  autoIndex({ table: loadTable.table, columns: filters.filter((el) => columns?.find?.((item) => item?.name === el.name)) })
+  autoIndex({ table, columns: filters.filter((el) => columns?.find?.((item) => item?.name === el.name)) })
     .catch(err => {
       console.error(err.toString());
       logger.file('autoindex/error', { name: params?.table, error: err.toString(), stack: err.stack });
     });
 
-  const loadTemplate = loadTable?.form ? await getTemplate('form', loadTable.form) : {};
-  const extraColumns = loadTemplate?.extra ? Object.keys(loadTemplate?.schema || {}).filter(key => !columns.find(col => col.name === key)) : [];
+  const loadTemplate = form ? await getTemplate('form', form) : {};
+  const extraColumns = extra ? Object.keys(loadTemplate?.schema || {}).filter(key => !columns.find(col => col.name === key)) : [];
 
   filters?.forEach?.(el => Object.assign(el, { id: el.id || el.name, title: el.title || el.ua, extra: extraColumns.includes(el.id || el.name) }));
 
   await Promise.all(filters.filter((el) => el.data && el.id && el.type !== 'Autocomplete' && !el.sql).map(async (el) => {
     const cls = await getSelect(el.data, pg);
 
-    if (!cls || !loadTable.table) return;
+    if (!cls) return;
     const { dataTypeID } = columns.find((item) => item.name === el.id) || {};
 
     if (el.extra && Array.isArray(cls?.arr || cls)) {
-      const countArr = await pg.query('select value_text as id, count(*) from crm.extra_data where property_key=$1 and property_entity=$2 group by value_text', [el.id, loadTable.table]);
+      const countArr = await pg.query('select value_text as id, count(*) from crm.extra_data where property_key=$1 and property_entity=$2 group by value_text', [el.id, table]);
       const options = countArr.rows.map(cel => {
         const data = (cls?.arr || cls).find(c => c.id === cel.id);
         return { ...cel, ...data };
@@ -60,7 +76,7 @@ export default async function filterAPI(req) {
       ? `select unnest(${el.id})::text as id,count(*) from (${optimizedSQL})q group by unnest(${el.id}) limit 100`
       : `select ${el.id}::text as id,count(*) from (${optimizedSQL})q group by ${el.id} limit 100`;
 
-    const countArr = await pg.queryCache(q, { table: loadTable.table });
+    const countArr = await pg.queryCache(q, { table });
 
     if (countArr.timeout) {
       Object.assign(el, { timeout: countArr.timeout });
@@ -79,13 +95,13 @@ export default async function filterAPI(req) {
     Object.assign(el, { options });
   }));
 
-  const q = ((loadTable?.filterState || []).concat(loadTable?.filterCustom || [])).filter((el) => el.name && el.sql).map((el) => `select count(*), '${el.name}' as name from (${optimizedSQL})q where ${el.sql}`).join(' union all ');
+  const q = ((filterState || []).concat(filterCustom || [])).filter((el) => el.name && el.sql).map((el) => `select count(*), '${el.name}' as name from (${optimizedSQL})q where ${el.sql}`).join(' union all ');
 
   const { rows = [], timeout: timeout1 } = q ? await pg.queryCache(q) : {};
   if (timeout1) logger.file('timeout/filter', { table: params.table, type: 'state/custom' });
 
   if (rows?.length) {
-    ((loadTable?.filterState || []).concat(loadTable?.filterCustom || [])).filter((el) => el.name && el.sql).forEach((el) => {
+    ((filterState || []).concat(filterCustom || [])).filter((el) => el.name && el.sql).forEach((el) => {
       const { count } = rows.find((row) => row.name === el.name) || {};
       Object.assign(el, { count, sql: undefined });
     });
@@ -105,22 +121,22 @@ export default async function filterAPI(req) {
         percentile_disc(0.5) within group (order by ${el.name}),
         percentile_disc(0.75) within group (order by ${el.name}),
         max(${el.name})
-    ] as range from ${loadTable.table} ${sqlList && false ? ` t ${sqlList}` : ''} where ${loadTable.query || '1=1'}`,
-      { table: loadTable.table },
-    ).then(el => {
-      if (el.timeout) {
-        logger.file('timeout/filter', { table: params.table, type: 'Range', filter: el.name });
-        return el;
+    ] as range from ${table} ${sqlList && false ? ` t ${sqlList}` : ''} where ${tableQuery || '1=1'}`,
+      { table },
+    ).then(res => {
+      if (res.timeout) {
+        logger.file('timeout/filter', { table: params.table, type: 'Range', filter: res.name });
+        return res;
       }
-      return el.rows?.[0]?.range;
+      return res.rows?.[0]?.range;
     });
     Object.assign(el, { data });
   }));
 
-  const sqlFilters = (loadTable?.filterCustom || []).filter((el) => el.name && el.sql);
-  const q1 = sqlFilters.map((el) => `select count(*), '${el.name}' as name from ${loadTable.table} where ${loadTable.query || '1=1'} and ${el.sql}`).join(' union all ');
+  const sqlFilters = (filterCustom || []).filter((el) => el.name && el.sql);
+  const q1 = sqlFilters.map((el) => `select count(*), '${el.name}' as name from ${table} where ${tableQuery || '1=1'} and ${el.sql}`).join(' union all ');
 
-  const { rows: sqlRows = [], timeout } = q1 ? await pg.queryCache(q1, { table: loadTable.table }) : {};
+  const { rows: sqlRows = [], timeout } = q1 ? await pg.queryCache(q1, { table }) : {};
   if (timeout) logger.file('timeout/filter', { table: params.table, type: 'sqlFilters' });
 
   if (sqlRows?.length) {
@@ -132,9 +148,9 @@ export default async function filterAPI(req) {
 
   return {
     time: Date.now() - time,
-    list: filters?.map?.(el => ({ ...el, sql: undefined })),
-    custom: loadTable?.filterCustom,
+    list: filters?.map?.(el => ({ ...el, sql: iscalled ? el.sql : undefined })),
+    custom: filterCustom,
     inline: loadTable?.filterInline,
-    state: loadTable?.filterState,
+    state: filterState,
   };
 }

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

@@ -17,6 +17,14 @@ const checkInline = {};
 const maxLimit = 100;
 const defaultLimit = 20;
 
+function getOrder(query, columnList, orderColumn, loadTable, orderDir, called) {
+  if (query?.order && called) { return `order by ${query.order}`; }
+  if (typeof orderColumn === 'string' && Array.isArray(columnList) && columnList.includes(orderColumn)) {
+    return `order by ${orderColumn} ${query?.desc || orderDir === 'desc' ? 'desc' : ''} nulls last`;
+  }
+  return `order by ${(loadTable?.order || 'true::boolean')} nulls last`;
+}
+
 export default async function dataAPI(req, reply, called) {
   const {
     pg = pgClients.client, params, headers = {}, query = {}, user = {}, contextQuery, sufix = true,
@@ -166,9 +174,8 @@ export default async function dataAPI(req, reply, called) {
   // id, query, filter
   const [orderColumn, orderDir] = (query.order || loadTable?.order || '').split(/[- ]/);
 
-  const order = query.order && columnList.includes(orderColumn) && orderColumn?.length
-    ? `order by ${orderColumn} ${query.desc || orderDir === 'desc' ? 'desc' : ''} nulls last`
-    : `order by ${(loadTable?.order || 'true::boolean')} nulls last`;
+  const order = getOrder(query, columnList, orderColumn, loadTable, orderDir, called);
+
   const search = loadTable?.meta?.search && query.search
     ? `(${loadTable?.meta?.search?.split(',')?.map(el => `${el} ilike '%${query.search.replace(/%/g, '\\%').replace(/'/g, "''")}%'`).join(' or ')})`
     : null;

package/server/routes/util/controllers/user.tokens.js

@@ -1,4 +1,6 @@
-import { customTokens, userTokens, handlebarsSync, setOpt, getOpt } from "../../../../utils.js";
+import {
+    customTokens, userTokens, handlebarsSync, setOpt, getOpt, config,
+} from '../../../../utils.js';
 
 export default async function userTokensAPI({ params = {}, user = {} }, reply) {
     if (!user?.uid) {
@@ -9,6 +11,10 @@ export default async function userTokensAPI({ params = {}, user = {} }, reply) {
         return reply.status(400).send('not enough params: token');
     }
 
+    if (!config.redis) {
+        return reply.status(500).send('empty redis');
+    }
+
     if (!customTokens[params.token]) {
         return reply.status(404).send('token not found');
     }
@@ -22,7 +28,7 @@ export default async function userTokensAPI({ params = {}, user = {} }, reply) {
     const token = setOpt(
         {
             ...customTokens[params.token],
-            query: handlebarsSync.compile(customTokens[params.token]?.query || 'true')({ user, uid: user.uid })
+            query: handlebarsSync.compile(customTokens[params.token]?.query || 'true')({ user, uid: user.uid }),
         },
         user.uid,
     );
@@ -36,4 +42,4 @@ export default async function userTokensAPI({ params = {}, user = {} }, reply) {
     userTokens[user.uid][params.token] = token;
 
     return token;
-}
+}

package/server/routes/util/index.js

@@ -6,7 +6,7 @@ async function plugin(app, config = {}) {
   const { prefix = '/api' } = config;
   app.get(`${prefix}/next-id`, { config: { policy: ['public'] } }, nextId);
   app.get(`${prefix}/status-monitor`, {}, statusMonitor);
-  app.get(`${prefix}/user-tokens/:token`, { config: { policy: ['user'] } }, userTokens);
+  app.get(`${prefix}/user-tokens/:token`, { config: { policy: ['user', 'site'] } }, userTokens);
 }
 
 export default plugin;