@opengis/fastify-table 1.4.9 → 1.4.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.4.9",
+  "version": "1.4.11",
   "type": "module",
   "description": "core-plugins",
   "keywords": [
@@ -26,14 +26,20 @@
     "test:routes": "node --test .\\test\\routes",
     "test:functions": "node --test .\\test\\functions",
     "compress": "node compress.js",
-    "dev": "cross-env NODE_ENV=development node server.js"
+    "dev": "set NODE_ENV=development&& node server.js"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "3.554.0",
     "@fastify/http-proxy": "11.1.2",
+    "@fastify/multipart": "9.0.3",
+    "@grpc/grpc-js": "1.10.6",
+    "@grpc/proto-loader": "0.7.12",
     "dotenv": "16.5.0",
     "fastify": "5.3.3",
     "fastify-plugin": "5.0.1",
+    "formidable": "3.5.1",
     "handlebars": "4.7.8",
+    "image-size": "1.2.0",
     "ioredis": "5.3.2",
     "js-yaml": "4.1.0",
     "markdown-it": "14.1.0",
@@ -42,16 +48,9 @@
     "pino-abstract-transport": "2.0.0",
     "promised-handlebars": "2.0.1",
     "qrcode": "1.5.4",
-    "uglify-js": "3.19.3",
-    "@aws-sdk/client-s3": "3.554.0",
-    "@fastify/multipart": "9.0.3",
-    "@grpc/grpc-js": "1.10.6",
-    "@grpc/proto-loader": "0.7.12",
-    "formidable": "3.5.1",
-    "image-size": "1.2.0"
+    "uglify-js": "3.19.3"
   },
   "devDependencies": {
-    "cross-env": "7.0.3",
     "eslint": "8.49.0",
     "eslint-config-airbnb": "19.0.4"
   },

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

@@ -2,16 +2,7 @@ import pgClients from '../../pg/pgClients.js';
 import getTemplate from '../../table/funcs/getTemplate.js';
 import applyHook from '../../hook/funcs/applyHook.js';
 
-/**
- * @param {Array} user_roles.actions Actions - user actions <> group actions
- * @param {Array} role_access.actions Actions - user actions = group actions
- * @param {String} body.actions Actions from table template
- * @param {String} table Table name / Interface alias
- * @param {Object} user User object
- * @param {String} user.uid User ID
- * @param {String} user.user_type User type
- * @returns { scope: String, actions: String[], query: String }
- */
+const allActions = ['view', 'edit', 'add', 'del'];
 
 const q = `select a.route_id as id, d.actions as user_roles, d.actions as role_actions, coalesce(b.actions, array['view']) as interface_actions, b.scope, c.role_id
 from admin.routes a 
@@ -29,7 +20,18 @@ left join admin.user_roles d on
         end )
 where $1 in (a.route_id, a.alias, a.table_name) and $2 in (b.user_uid, d.user_uid)`;
 
-export default async function getAccess({ table, user = {} }, pg = pgClients.client) {
+/**
+ * @param {Array} user_roles.actions Actions - user actions <> group actions
+ * @param {Array} role_access.actions Actions - user actions = group actions
+ * @param {String} body.actions Actions from table template
+ * @param {String} table Table name / Interface alias
+ * @param {Object} user User object
+ * @param {String} user.uid User ID
+ * @param {String} user.user_type User type
+ * @returns { scope: String, roles: String[], actions: String[], query: String }
+ */
+
+export default async function getAccess({ table, form, user = {} }, pg = pgClients.client) {
   if (!table) return null;
 
   const hookData = await applyHook('getAccess', { table, user, pg });
@@ -38,15 +40,19 @@ export default async function getAccess({ table, user = {} }, pg = pgClients.cli
   const { uid, user_type: userType = 'regular' } = user;
 
   if (userType === 'superadmin') {
-    return { actions: ['view', 'edit', 'add', 'del'], query: '1=1' };
+    return { actions: allActions, query: '1=1' };
   }
 
   const body = await getTemplate('table', table);
-  const tableActions = ['view'].concat(body?.actions || body?.action_default || []);
+  const tableActions = !body && form
+    ? allActions // if db table and form => full access (token)
+    : ['view'].concat(body?.actions || body?.action_default || []);
 
   if (userType === 'admin') {
-    const adminActions = body?.form ? ['view', 'del', 'edit', 'add'] : ['view', 'del'];
-    return { actions: body?.actions || body?.action_default ? tableActions : adminActions, query: '1=1' };
+    if (!(body?.actions || body?.action_default) && (body?.form || form)) {
+      return { actions: allActions, query: '1=1' };
+    }
+    return { actions: tableActions, query: '1=1' };
   }
 
   if (body?.public || body?.access === 'public') {
@@ -76,7 +82,7 @@ export default async function getAccess({ table, user = {} }, pg = pgClients.cli
   const query = userAccess?.scope === 'my' ? `uid='${uid}'` : '1=1';
   const actions = userAccess?.interface_actions
     ?.filter?.((el, idx, arr) => arr.indexOf(el) === idx)
-    ?.filter(el => userAccess?.role_actions?.length ? userAccess?.role_actions.includes(el) : true)
+    ?.filter(el => (userAccess?.role_actions?.length ? userAccess?.role_actions.includes(el) : true))
     ?.filter(el => tableActions.includes(el));
   return {
     scope: userAccess?.scope,

package/server/plugins/file/providers/index.js

@@ -6,7 +6,6 @@ const providers = (opt) => ({
   s3: s3(opt),
 });
 
-// import config from '@opengis/fastify-file/config.js';
 import config from '../../../../config.js';
 
 // storage s3 or file

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

@@ -28,7 +28,7 @@ export default async function deleteCrud(req, reply) {
   }
 
   if (!actions.includes('del') && !config?.local) {
-    return reply.status(403).send('access restricted');
+    return reply.status(403).send('access restricted: actions');
   }
 
   const loadTemplate = await getTemplate('table', del);

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

@@ -26,14 +26,14 @@ export default async function insert(req, reply) {
 
   const { form, table: add } = hookData || tokenData || (config.security?.disableToken || config.local || config.auth?.disable ? req.params : {});
 
-  const { actions = [] } = await getAccess({ table: add, user }, pg) || {};
+  const { actions = [] } = await getAccess({ table: add, form, user }, pg) || {};
 
   if (!tokenData && !config.local && !config.security?.disableToken && !config.auth?.disable) {
     return reply.status(400).send('invalid token');
   }
 
   if (!actions.includes('add') && !config.local) {
-    return reply.status(403).send('access restricted');
+    return reply.status(403).send('access restricted: actions');
   }
 
   if (!add) {

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

@@ -17,57 +17,56 @@ export default async function tableAPI(req, reply) {
   if (hookData?.message && hookData?.status) {
     return { message: hookData?.message, status: hookData?.status };
   }
-  const tableName1 = hookData?.table || tokenData.table || params.table;
+  const templateName = hookData?.table || tokenData.table || params.table;
+
+  const loadTable = await getTemplate('table', templateName);
 
-  const loadTable = await getTemplate('table', tableName1) || {};
   if (!loadTable && !pg.pk?.[tokenData.table]) {
     return { message: 'not found', status: 404 };
   }
 
-  const { table, /* columns, */ form } = loadTable;
-
-  const templateName = hookData?.table || tokenData.table || params.table;
-  const tableName = table || templateName;
+  const { table = params.table, /* columns, */ form } = hookData || loadTable || tokenData;
 
   const id = hookData?.id || tokenData.id || params.id;
 
   if (tokenData && !id) return { message: {} };
-  if (!tableName && !id) {
+  if (!table && !id) {
     return reply.status(400).send('not enough params');
   }
 
-  const { actions = [], query: accessQuery } = await getAccess({ table: templateName, id, user }, pg) || {};
+  const { actions = [], query: accessQuery } = await getAccess({
+    table, form, id, user,
+  }, pg) || {};
 
   if (!tokenData && !config?.local && !config.security?.disableToken) {
     return reply.status(400).send('invalid token');
   }
 
   if (!actions.includes('edit') && !config?.local) {
-    return reply.status(403).send('access restricted');
+    return reply.status(403).send('access restricted: actions');
   }
 
-  const { pk, columns: dbColumns = [] } = await getMeta({ pg, table: tableName });
+  const { pk, columns: dbColumns = [] } = await getMeta({ pg, table });
 
   if (!pk) {
     return reply.status(404).send(`table not found: ${table}`);
   }
 
   // const cols = columns.map((el) => el.name || el).join(',');
-  const formName = hookData?.form || tokenData?.form || form;
-  const formData = await getTemplate('form', formName) || {};
+  const formData = await getTemplate('form', form) || {};
   const schema = formData?.schema || formData || {};
   // skip DataTable from another table
   const extraKeys = Object.keys(schema).filter((key) => schema[key]?.table && schema[key]?.parent_id && Object.hasOwn(schema[key], 'colModel'));
   // skip non-existing columns
   const columnList = dbColumns.map((el) => el.name || el).join(',');
 
-  const { fields = [] } = !loadTable?.table ? await pg.query(`select * from ${tableName} limit 0`) : {};
+  const { fields = [] } = !loadTable?.table ? await pg.query(`select * from ${table} limit 0`) : {};
   const cols = loadTable?.table
     ? Object.keys(schema || {}).filter((col) => columnList.includes(col) && !extraKeys.includes(col))?.map((col) => (col?.includes('geom') && schema?.[col]?.type === 'Geom' ? `st_asgeojson(${col})::json as "${col}"` : `"${col}"`))?.join(',')
     : fields.map((el) => (el?.name?.includes('geom') && pg.pgType[el?.dataTypeID] === 'geometry' ? `st_asgeojson(${el.name})::json as "${el.name}"` : `"${el?.name}"`)).join(',');
-  const where = [`"${pk}" = $1`, loadTable.query, accessQuery].filter((el) => el).filter((el) => (user?.user_type === 'superadmin' ? !el.includes('{{uid}}') : true));
+  const where = [`"${pk}" = $1`, loadTable?.query, accessQuery].filter(Boolean).filter((el) => (user?.user_type === 'superadmin' ? !el.includes('{{uid}}') : true));
   const geom = dbColumns.find((el) => el.name === 'geom' && pg.pgType[el.dataTypeID] === 'geometry') ? ',st_asgeojson(geom)::json as geom' : '';
-  const q = `select "${pk}" as id, ${cols || '*'} ${geom} from ${tableName} t where ${where.join(' and ') || 'true'} limit 1`;
+  const q = `select "${pk}" as id, ${cols || '*'} ${geom} from ${table} t where ${where.join(' and ') || 'true'} limit 1`;
 
   if (query?.sql === '1') {
     const extraQ = extraKeys?.map((key) => {
@@ -93,23 +92,23 @@ export default async function tableAPI(req, reply) {
       const { colModel, table: extraTable, parent_id: parentId } = schema[key];
       const colModel1 = Array.isArray(colModel) ? colModel : Object.values(colModel || {});
       const q1 = `select ${parentId} as parent, ${colModel1.map((col) => col.name || col.key).join(',')} from ${extraTable} a where ${parentId}=$1`;
-      // console.log(tableName, formName, q1);
+      // console.log(table, formName, q1);
       const { rows: extraRows } = await pg.query(q1, [id]);
       Object.assign(data, { [key]: extraRows });
     }));
   }
   if (user?.uid && !config.security?.disableToken && actions.includes('edit')) {
     data.token = tokenData?.table ? params.table : setToken({
-      ids: [JSON.stringify({ id, table: tableName, form: loadTable.form })],
+      ids: [JSON.stringify({ id, table, form })],
       uid: user.uid,
       array: 1,
     })?.[0];
   }
 
-  await extraDataGet({ rows: [data], table: tableName, form: hookData?.form || tokenData?.form || loadTable.form }, pg);
+  await extraDataGet({ rows: [data], table, form }, pg);
 
   const res = await applyHook('afterTable', {
-    pg, table: tableName, payload: [data], user,
+    pg, table, payload: [data], user,
   });
 
   return res || data || {};

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

@@ -28,14 +28,16 @@ export default async function update(req, reply) {
 
   const { form, table: edit, id } = hookData || tokenData || (config.security?.disableToken || config.local || config.auth?.disable ? params : {});
 
-  const { actions = [] } = await getAccess({ table: edit, id, user }, pg) || {};
+  const { actions = [] } = await getAccess({
+    table: edit, form, id, user,
+  }, pg) || {};
 
   if (!tokenData && !config.local && !config.security?.disableToken && !config.auth?.disable) {
     return reply.status(400).send('invalid token');
   }
 
   if (!actions.includes('edit') && !config.local) {
-    return reply.status(403).send('access restricted');
+    return reply.status(403).send('access restricted: actions');
   }
 
   if (!edit) {

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

@@ -1,4 +1,6 @@
-import { logger, autoIndex, getSelect, getTemplate, getSelectVal, pgClients } from '../../../../utils.js';
+import {
+  logger, autoIndex, getSelect, getTemplate, getSelectVal, pgClients,
+} from '../../../../utils.js';
 
 export default async function filterAPI(req) {
   const time = Date.now();
@@ -21,8 +23,10 @@ export default async function filterAPI(req) {
   const 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]);
-  properties.forEach((row) => filters.push({ id: row.name, name: row.name, ua: row.title, type: row.format, data: row.data }));
+  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]);
+  properties.forEach((row) => filters.push({
+    id: row.name, name: row.name, ua: row.title, type: row.format, data: row.data,
+  }));
 
   // KRYVYIRIH-231
   autoIndex({ table: loadTable.table, columns: filters.filter((el) => columns?.find?.((item) => item?.name === el.name)) })
@@ -43,7 +47,7 @@ export default async function filterAPI(req) {
     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, loadTable.table]);
       const options = countArr.rows.map(cel => {
         const data = (cls?.arr || cls).find(c => c.id === cel.id);
         return { ...cel, ...data };
@@ -73,12 +77,10 @@ export default async function filterAPI(req) {
       return { ...cel, ...data };
     });
     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 { rows = [], timeout: timeout1 } = q ? await pg.queryCache(q) : {};
   if (timeout1) logger.file('timeout/filter', { table: params.table, type: 'state/custom' });
 
@@ -89,7 +91,6 @@ export default async function filterAPI(req) {
     });
   }
 
-
   const sqlList = loadTable?.sql
     ?.filter((el) => !el.disabled && el?.sql?.replace)
     ?.map((el, i) => ` left join lateral (${el.filter ? el.sql.replace(/limit 1/ig, '') : el.sql}) as ${el.name || `t${i + 1}`} on 1=1 `)
@@ -97,23 +98,23 @@ export default async function filterAPI(req) {
 
   // percentile_cont - alternative
   await Promise.all(filters.filter((el) => el.name && el.type === 'Range' && fields?.find?.((item) => item?.name === el.name)).map(async (el) => {
-
-    const data = await pg.queryCache(`select array[
+    const data = await pg.queryCache(
+      `select array[
         min(${el.name}),
         percentile_disc(0.25) within group (order by ${el.name}),
         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;
-        }
-        return el.rows?.[0]?.range;
-      });
+      { table: loadTable.table },
+    ).then(el => {
+      if (el.timeout) {
+        logger.file('timeout/filter', { table: params.table, type: 'Range', filter: el.name });
+        return el;
+      }
+      return el.rows?.[0]?.range;
+    });
     Object.assign(el, { data });
-
   }));
 
   const sqlFilters = (loadTable?.filterCustom || []).filter((el) => el.name && el.sql);
@@ -136,4 +137,4 @@ export default async function filterAPI(req) {
     inline: loadTable?.filterInline,
     state: loadTable?.filterState,
   };
-}
+}

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

@@ -1,5 +1,5 @@
 import {
-  config, getTemplate, getFilterSQL, getMeta, metaFormat, getAccess, setToken, gisIRColumn, applyHook, handlebars, handlebarsSync, getSelect, setOpt, getOpt, pgClients,
+  config, getTemplate, getFilterSQL, getMeta, metaFormat, getAccess, setToken, gisIRColumn, applyHook, handlebars, handlebarsSync, getSelect, setOpt, getOpt, pgClients, logger, getFilter,
 } from '../../../../utils.js';
 
 import extraDataGet from '../../../plugins/extra/extraDataGet.js';
@@ -78,13 +78,22 @@ export default async function dataAPI(req, reply, called) {
     table, columns = [], sql, cardSql, form, meta, sqlColumns, public: ispublic, editable = false,
   } = loadTable || hookData || tokenData || params;
 
-  const filters = ((body?.filter_list || [])
+  /* const filters = ((body?.filter_list || [])
     .concat(body?.filterInline || [])
     .concat(body?.filterCustom || [])
     .concat(body?.filterState || [])
     .concat(body?.filterList || [])
     .concat(body?.filters || [])
-  ).filter(el => el.id || el.name);
+  ).filter(el => el.id || el.name); */
+
+  if (body?.filter_list || body?.filterList) {
+    console.warn('invalid filters in template: filter_list / filterList');
+    logger.file('crud/warning', { msg: 'invalid filters', template: tokenData?.table || hookData?.table || params.table });
+  }
+
+  const { list: filters = [] } = await getFilter({
+    pg, table: tokenData?.table || hookData?.table || params.table, user,
+  }) || {};
 
   const tableMeta = await getMeta({ pg, table });
   timeArr.push(Date.now());

package/server/routes/table/index.js

@@ -5,7 +5,6 @@ import cardData from './controllers/cardData.js';
 import dataInfo from './controllers/dataInfo.js';
 import tableInfo from './controllers/tableInfo.js';
 import tokenInfo from './controllers/tokenInfo.js';
-import tableFilter from './controllers/tableFilter.js';
 
 import card from './controllers/card.js';
 import search from './controllers/search.js';
@@ -15,7 +14,7 @@ import form from './controllers/form.js';
 import loadTemplatePath from '../../plugins/table/funcs/loadTemplatePath.js';
 
 import {
-  tableDataSchema, tableSchema, searchSchema, suggestSchema, formSchema, filterSchema, cardTabDataSchema, tableDataIdSchema, tableFilterSchema,
+  tableDataSchema, tableSchema, searchSchema, suggestSchema, formSchema, filterSchema, cardTabDataSchema, tableDataIdSchema,
 } from './schema.js';
 
 const policy = ['public'];
@@ -25,7 +24,7 @@ async function plugin(app, config = {}) {
 
   app.get(`${prefix}/token-info/:token`, { config: { policy: ['admin'] } }, tokenInfo);
 
-  app.get(`${prefix}/table-filter/:table`, { config: { policy }, schema: tableFilterSchema }, tableFilter);
+  app.get(`${prefix}/table-filter/:table`, { config: { policy }, schema: filterSchema }, filter);
 
   app.get(`${prefix}/table-info/:table/:id?`, { config: { policy }, schema: tableDataSchema }, tableInfo);
   app.get(`${prefix}/suggest/:data`, { config: { policy }, schema: suggestSchema }, suggest);

package/server/routes/table/schema.js

@@ -1,33 +1,24 @@
 const tableDataSchema = {
   type: 'object',
   properties: {
-      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 tableFilterSchema = {
-  type: 'object',
-  properties: {
-      params: {
-          name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-      },
+    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_.-]+)$' },
+    },
   },
 };
 
@@ -85,7 +76,7 @@ const suggestSchema = {
       count: { type: 'string', pattern: '^(\\d)$' },
     },
     params: {
-    //  data: { type: 'string', pattern: '^([\\d\\w]+)$' },
+      //  data: { type: 'string', pattern: '^([\\d\\w]+)$' },
     },
   },
 };
@@ -111,25 +102,25 @@ const filterSchema = {
 const cardTabDataSchema = {
   type: 'object',
   properties: {
-      querystring: {
-          sql: { type: 'string', pattern: '^(\\d)$' }
-      },
-      params: {
-          token: { type: 'string', pattern: '^([\\d\\w]+)$' },
-      },
+    querystring: {
+      sql: { type: 'string', pattern: '^(\\d)$' },
+    },
+    params: {
+      token: { type: 'string', pattern: '^([\\d\\w]+)$' },
+    },
   },
 };
 
 const tableDataIdSchema = {
   type: 'object',
   properties: {
-      params: {
-          id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-          name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-      },
+    params: {
+      id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+      name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+    },
   },
 };
 
 export {
-  tableDataSchema, tableDataIdSchema, tableSchema, searchSchema, suggestSchema, formSchema, filterSchema, cardTabDataSchema, tableFilterSchema,
+  tableDataSchema, tableDataIdSchema, tableSchema, searchSchema, suggestSchema, formSchema, filterSchema, cardTabDataSchema,
 };

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

@@ -1,16 +0,0 @@
-import { getFilter, pgClients } from '../../../../utils.js';
-
-export default async function tableFilter(req) {
-    const {
-        pg = pgClients.client, params = {}, query = {}, user = {},
-    } = req;
-
-    const {
-        filter, custom, state, search,
-    } = query;
-
-    const result = await getFilter({
-        table: params.table, pg, filter, custom, state, search, user,
-    });
-    return result;
-}