@opengis/fastify-table 1.1.38 → 1.1.40

package/helper.js

@@ -1,11 +1,11 @@
-// This file contains code that we reuse
-// between our tests.
+import path from 'node:path';
 import Fastify from 'fastify';
 import config from './test/config.js';
 import appService from './index.js';
 
 import rclient from './redis/client.js';
 import pgClients from './pg/pgClients.js';
+import { addTemplateDir } from './utils.js';
 
 // automatically build and tear down our instance
 async function build(t) {
@@ -14,6 +14,8 @@ async function build(t) {
   process.env.NODE_ENV = 'production';
   const app = Fastify({ logger: false });
   app.register(appService, config);
+  const cwd = process.cwd();
+  addTemplateDir(path.join(cwd, 'module/test'));
   // close the app after we are done
   t.after(() => {
     // console.log('close app');

package/module/test/cls/itree.composition.json

@@ -0,0 +1,26 @@
+[
+  {
+    "id": "2",
+    "text": "Хвойні",
+    "en": "Conifers",
+    "color": "#006400"
+  },
+  {
+    "id": "3",
+    "text": "Чагарники",
+    "en": "Shrubs",
+    "color": "#6B8E23"
+  },
+  {
+    "id": "4",
+    "text": "Плодові",
+    "en": "Fruit",
+    "color": "#808000"
+  },
+  {
+    "id": "1",
+    "text": "Листяні",
+    "en": "Deciduous",
+    "color": "#228B22"
+  }
+]

package/module/test/table/test.rest_zone.table.json

@@ -0,0 +1,265 @@
+{
+  "key": "rz_id",
+  "table": "itree.rest_zones",
+  "query": "verif",
+  "sql": [
+    {
+      "sql": "select json_agg(file_path) as img_list from admin.doc_file where object_id=t.rz_id and file_status=1",
+      "name": "image_sql"
+    }
+  ],
+  "form": "rest_zone.form",
+  "meta": {
+    "bbox": "geom",
+    "search": "name",
+    "title": "name"
+  },
+  "columns": [
+    {
+      "ua": "Назва об'єкта",
+      "title": "Назва об'єкта",
+      "name": "name",
+      "meta": "title",
+      "html": "<a href=\"/rest_zone/mode=card/view={{rz_id}}\">{{name}}</a>",
+      "format": "html"
+    },
+    {
+      "en": "Green zone category",
+      "ua": "Категорія зеленої зони",
+      "meta": "category",
+      "name": "category",
+      "data": "itree.recrzone_category",
+      "format": "select"
+    },
+    {
+      "ru": "Вид насаджень",
+      "ua": "Вид насаджень",
+      "name": "plant_type",
+      "meta": "type",
+      "data": "itree.plant_type",
+      "format": "select"
+    },
+    {
+      "name": "uid",
+      "ua": "Хто додав",
+      "width": "70",
+      "data": "contact_id",
+      "format": "select"
+    },
+    {
+      "ru": "Балансоутримувач об'єкта",
+      "ua": "Балансоутримувач об'єкта",
+      "hidden": true,
+      "meta": "other",
+      "name": "balancer",
+      "format": "text"
+    },
+    {
+      "ua": "Відповідальний за утримання",
+      "name": "maintain_respons_gp",
+      "meta": "other",
+      "hidden": true,
+      "format": "text"
+    },
+    {
+      "ua": "Площа, га",
+      "name": "area",
+      "meta": "other",
+      "format": "text"
+    },
+    {
+      "ru": "Форма власності",
+      "ua": "Форма власності",
+      "name": "ownership",
+      "meta": "other",
+      "data": "itree.ownership",
+      "format": "select"
+    },
+    {
+      "ru": "Категорія земель",
+      "ua": "Категорія земель",
+      "name": "landcategory",
+      "meta": "other",
+      "hidden": true,
+      "data": "itree.landcategory",
+      "format": "select"
+    },
+    {
+      "ru": "Цільве призначення",
+      "ua": "Цільве призначення",
+      "name": "purpose",
+      "meta": "other",
+      "hidden": true,
+      "data": "itree.purpose_type",
+      "format": "select"
+    },
+    {
+      "ru": "Обмеження щодо використання",
+      "ua": "Обмеження щодо використання",
+      "name": "restriction",
+      "hidden": true,
+      "meta": "other",
+      "data": "itree.restriction",
+      "format": "select"
+    },
+    {
+      "ru": "Площа, зайнята зеленими насадженнями, кв.м",
+      "ua": "Площа, зайнята зеленими насадженнями, кв.м",
+      "name": "plants_square",
+      "meta": "other",
+      "hidden": true,
+      "format": "text"
+    },
+    {
+      "ru": "Загальний стан насаджень",
+      "ua": "Загальний стан насаджень",
+      "name": "plants_cond",
+      "meta": "other",
+      "data": "itree.plants_cond",
+      "format": "badge"
+    },
+    {
+      "en": "Photo",
+      "ru": "Фото",
+      "ua": "Фото",
+      "html": "{{#each img_list}}<a class='btn btn-xs btn-default' href=\"{{this}}\" download><i class='fa fa-file-text'></i></a><a target=\"_blank\" class='btn btn-xs btn-default' href=\"{{this}}\"><i class='fa fa-eye'></i></a><br>{{/each}}",
+      "name": "image",
+      "format": "html"
+    },
+    {
+      "ru": "Видовий склад рослин",
+      "ua": "Видовий склад рослин",
+      "name": "composition",
+      "hidden": true,
+      "meta": "other",
+      "data": "itree.composition",
+      "format": "badge"
+    },
+    {
+      "ru": "Кількість особливо цінних порід та чагарників, шт",
+      "ua": "Кількість особливо цінних порід та чагарників, шт",
+      "name": "espec_valuable",
+      "hidden": true,
+      "meta": "other",
+      "format": "text"
+    },
+    {
+      "ru": "Повнота насаджень (кількість дерев на 1 гектар), шт/га",
+      "ua": "Повнота насаджень (кількість дерев на 1 гектар), шт/га",
+      "name": "planting_density",
+      "hidden": true,
+      "meta": "other",
+      "format": "text"
+    },
+    {
+      "ru": "Площа, зайнята деревами, кв.м",
+      "ua": "Площа, зайнята деревами, кв.м",
+      "name": "tree_square",
+      "hidden": true,
+      "meta": "other",
+      "format": "text"
+    },
+    {
+      "ru": "Балансова вартість",
+      "ua": "Балансова вартість",
+      "name": "book_value",
+      "meta": "other",
+      "hidden": true,
+      "format": "text"
+    },
+    {
+      "ru": "Кадастровий номер",
+      "ua": "Кадастровий номер",
+      "meta": "other",
+      "name": "cadnum",
+      "hidden": true,
+      "format": "text"
+    },
+    {
+      "ru": "Нормативна грошова оцінка",
+      "ua": "Нормативна грошова оцінка",
+      "name": "monetary_valuation",
+      "meta": "other",
+      "hidden": true,
+      "format": "text"
+    },
+    {
+      "ua": "Верифіковано",
+      "html": " {{#ifCond verif '==' true}} \r\n <span class=\"label\" style=\"color:#fff;background:green\"> Так</span> \r\n   {{else}}  \r\n   <span class=\"label\" style=\"color:#fff;background:red\"> Ні</span>\r\n                    {{/ifCond}}",
+      "name": "verif",
+      "format": "check"
+    }
+  ],
+  "title": "Зони відпочинку",
+  "filterList": [
+    {
+      "ua": "Назва",
+      "name": "name",
+      "type": "Text"
+    },
+    {
+      "ua": "Категорія зеленої зони",
+      "data": "itree.recrzone_category",
+      "name": "category",
+      "sort": "asc",
+      "type": "Check"
+    },
+    {
+      "ua": "Вид насаджень",
+      "data": "itree.plant_type",
+      "name": "plant_type",
+      "sort": "asc",
+      "type": "Check"
+    },
+    {
+      "ua": "Загальний стан насаджень",
+      "data": "itree.plants_cond",
+      "name": "plants_cond",
+      "sort": "asc",
+      "type": "Check"
+    },
+    {
+      "ua": "Видовий склад рослин",
+      "data": "itree.composition",
+      "name": "composition",
+      "sort": "asc",
+      "type": "Check"
+    },
+    {
+      "ua": "Форма власності",
+      "data": "itree.ownership",
+      "name": "ownership",
+      "type": "Check"
+    },
+    {
+      "ua": "Категорія земель",
+      "data": "itree.landcategory",
+      "name": "landcategory",
+      "type": "Check"
+    },
+    {
+      "ua": "Цільове призначення",
+      "data": "itree.purpose",
+      "name": "purpose",
+      "type": "Check"
+    }
+  ],
+  "filterCustom": [
+    {
+      "name": "actual",
+      "label": "Поточний рік",
+      "sql": "cdate > '2020-01-01'::date"
+    }
+  ],
+  "filterState": [
+    {
+      "name": "actual",
+      "label": "Поточний рік 2",
+      "sql": "cdate > '2022-09-12'::date"
+    }
+  ],
+  "actions": [
+    "edit",
+    "del"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.1.38",
+  "version": "1.1.40",
   "type": "module",
   "description": "core-plugins",
   "main": "index.js",

package/table/controllers/data.js

@@ -53,10 +53,13 @@ export default async function dataAPI(req) {
     });
   }
 
-  const fData = query.filter || query.search ? await getFilterSQL({
+  const checkFilter = [query.filter, query.state, query.search, query.custom].filter((el) => el).length;
+  const fData = checkFilter ? await getFilterSQL({
+    table: params.table,
     filter: query.filter,
+    state: query.state,
     search: query.search,
-    table: params.table,
+    custom: query.custom,
     json: 1,
   }) : {};
 
@@ -69,15 +72,13 @@ export default async function dataAPI(req) {
   const [orderColumn, orderDir] = (query.order || loadTable.order || '').split(/[- ]/);
 
   const order = columnList.includes(orderColumn) && orderColumn?.length ? `order by ${orderColumn} ${query.desc || orderDir === 'desc' ? 'desc' : ''}` : '';
-  const state = loadTable.filterState && query.state ? loadTable.filterState[query.state]?.sql : null;
-  const custom = loadTable.filterCustom && query.custom ? loadTable.filterCustom[query.custom]?.sql : null;
   const search = loadTable.meta?.search && query.search ? `(${loadTable.meta?.search.split(',').map(el => `${el} ilike '%${query.search}%'`).join(' or ')})` : null;
   const queryBbox = query?.bbox ? query.bbox.replace(/ /g, ',').split(',')?.map((el) => el - 0) : [];
   const queryPolyline = meta?.bbox && query?.polyline ? `ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline('${query?.polyline}')),${meta.bbox})` : undefined;
   const bbox = meta?.bbox && queryBbox.filter((el) => !Number.isNaN(el))?.length === 4 ? `${meta.bbox} && 'box(${queryBbox[0]} ${queryBbox[1]},${queryBbox[2]} ${queryBbox[3]})'::box2d ` : undefined;
 
   const access = await getAccess(req, params.table);
-  const where = [(opt?.id || params.id ? ` "${pk}" = $1` : null), keyQuery, loadTable.query, fData.q, state, custom, search, access?.query || '1=1', bbox, queryPolyline].filter((el) => el);
+  const where = [(opt?.id || params.id ? ` "${pk}" = $1` : null), keyQuery, loadTable.query, fData.q, search, access?.query || '1=1', bbox, queryPolyline].filter((el) => el);
   const cardColumns = cardSqlFiltered.length ? `,${cardSqlFiltered.map((el) => el.name)}` : '';
   const q = `select  ${pk ? `"${pk}" as id,` : ''} ${columnList.includes('geom') ? 'st_asgeojson(geom)::json as geom,' : ''} ${query.id || query.key ? '*' : sqlColumns || cols || '*'} ${metaCols} ${cardColumns} from ${table} t ${sqlTable} ${cardSqlTable} where ${where.join(' and ') || 'true'} ${order} ${offset}  limit ${limit}`;
 

package/table/controllers/table.js

@@ -5,19 +5,20 @@ import { applyHook } from '../../utils.js';
 
 export default async function tableAPI(req) {
   const {
-    pg, params = {}, query = {}, opt = {},
+    pg, params = {}, query = {},
   } = req;
   if (!params.id) return { message: 'not enough params', status: 400 };
 
-  const loadTable = await getTemplate('table', opt?.table || params.table) || {};
-  if (!loadTable) {
-    if (!pg.pk?.[opt?.table || params.table]) { return { message: 'not found', status: 404 }; }
-  }
-
   const check = await applyHook('preTable', { req });
   if (check?.message && check?.status) {
     return { message: check?.message, status: check?.status };
   }
+  const { opt = {} } = req;
+
+  const loadTable = await getTemplate('table', opt?.table || params.table) || {};
+  if (!loadTable) {
+    if (!pg.pk?.[opt?.table || params.table]) { return { message: 'not found', status: 404 }; }
+  }
 
   const {
     table, /* columns, */ form,

package/table/funcs/getFilterSQL/index.js

@@ -1,18 +1,13 @@
-/* const getTable = require('../../controllers/utils/getTable');
-const pg = require('../../../pg/client');
-const config = require('../../../../config'); */
-
 import getTemplate from '../../controllers/utils/getTemplate.js';
 import pgClients from '../../../pg/pgClients.js';
-import config from '../../../config.js';
+
 // filter util
 import getTableSql from './util/getTableSql.js';
-// import getCustomQuery from './util/getCustomQuery.js';
 import getFilterQuery from './util/getFilterQuery.js';
 import getOptimizedQuery from './util/getOptimizedQuery.js';
 
 async function getFilterSQL({
-  table, filter, pg = pgClients.client, search, filterList, query,
+  table, filter, pg = pgClients.client, search, filterList, query, custom, state,
 }) {
   if (!table) return { error: 'param table is required', status: 400 };
 
@@ -25,8 +20,7 @@ async function getFilterSQL({
         return ` left join lateral (${el.filter ? el.sql.replace(/limit 1/ig, '') : el.sql}) as ${el.name} on 1=1 `;
       }).join(' ')
     : '';
-  const fieldQuery = config.allTemplates?.table?.[table] ? `${config.allTemplates?.table?.[table]} limit 0`
-    : `select * from ${body?.table || table} ${sqlList ? ` t ${sqlList}` : ''} where 1=1 limit 0`;
+  const fieldQuery = `select * from ${body?.table || table} ${sqlList ? ` t ${sqlList}` : ''} where 1=1 limit 0`;
   const { fields = [] } = await pg.query(fieldQuery);
 
   const { fields: fieldsModel } = pg.pk[body?.table] ? await pg.query(`select * from ${body.table} limit 0`) : {};
@@ -45,18 +39,36 @@ async function getFilterSQL({
         return pk && !fieldsList.includes(name) ? `${pk} in (select ${pk} from (${fieldQuery})q where ${name} ${sval})` : `${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 || [])) /* .concat(extraFilters || []).concat(customFilters || []) */
+
+      ?.map(async (el) => {
+        if (!el?.data) return el;
+        const cls = await getTemplate(['cls', 'select'], el.data);
+        if (Array.isArray(cls) && cls?.length) {
+          Object.assign(el, { options: cls });
+        }
+        else if (typeof (cls?.sql || cls) === 'string') {
+          Object.assign(el, { sql: cls?.sql || cls });
+        }
+        return el;
+      }));
+
     const filters = getFilterQuery({
+      pg,
       filter,
+      table,
       tableSQL,
       fields,
-      filterList: filterList || (body?.filter_list || []).concat(body?.filterInline || []).concat(body?.filterCustom || []).concat(body?.filterState || []).concat(body?.filterList || []),
-      pg,
-      config,
+      filterList: filterList1,
     });
 
     // filter
+    const customQuery = body?.filterCustom?.length && custom ? body.filterCustom?.find((el) => el.name === custom)?.sql : null;
+    const stateQuery = body?.filterState?.length && state ? body.filterState?.find((el) => el.name === state)?.sql : null;
+
     const filterQuery = filters?.filter((el) => el.query)?.map((el) => `${el.query} `).join(' and ');
-    const q = [body?.query, query, searchQuery, filterQuery].filter((el) => el).join(' and ');
+    const q = [body?.query, query, searchQuery, filterQuery, stateQuery, customQuery].filter((el) => el).join(' and ');
 
     // table
     const modelQuery = body?.model || body?.table || table;

package/table/funcs/getFilterSQL/util/formatValue.js

@@ -19,9 +19,15 @@ function formatDateISOString(date) {
 }
 
 function formatValue({
-  filterType, filter, name, value, operator = '=', fieldType = 'text', uid = 1, optimize,
+  pg, table, filter = {}, name, value, operator = '=', dataTypeID, uid = 1, optimize,
 }) {
-  if (!name || !value) return {};
+  const { data, sql, extra } = filter;
+  const pk = pg?.pk && table ? pg.pk[table] : undefined;
+
+  if (!dataTypeID && !extra) return {};
+  const fieldType = extra ? pg.pgType?.[{ Date: 1114 }[filter?.type] || 25] : pg.pgType?.[dataTypeID];
+  if (!name || !value || !fieldType) return {};
+  const filterType = filter.type?.toLowerCase();
 
   // current day, week, month, year etc.
   if (dateTypeList.includes(fieldType) && !value?.includes('_') && ['cd', 'cw', 'cm', 'cq', 'cy'].includes(value)) {
@@ -32,26 +38,32 @@ function formatValue({
       cq: `${name}::date >= '${dt(dp.y, dp.q, 1)}'::date and ${name} <= '${dt(dp.y, dp.q + 3, 0)}'::date`,
       cy: `${name}::date >= '${dt(dp.y, 0, 1)}'::date and ${name}::date <= '${dt(dp.y, 11, 31)}'::date`,
     }[value];
-    return { op: '=', query };
+    return { op: '=', query, extra };
   }
+
   // date range
   if (dateTypeList.includes(fieldType) && value?.includes('_')) {
     const [min, max] = value.split('_');
     const query = `${name} >= '${min}'::date and ${name} <= '${max}'::date`;
-    return { op: 'between', query };
+    return { op: 'between', query, extra };
   }
+
   // v3 filter date range, example - "01.01.2024-31.12.2024"
   if (dateTypeList.includes(fieldType) && value?.includes('.') && value?.indexOf('-') === 10 && value?.length === 21) {
     const [startDate, endDate] = value.split('-');
     const min = formatDateISOString(startDate);
     const max = formatDateISOString(endDate);
-    const query = `${name}::date >= '${min}'::date and ${name}::date <= '${max}'::date`;
-    return { op: 'between', query };
+    const query = extra && pk
+      ? `${pk} in (select object_id from crm.extra_data where property_key='${name}' and value_date::date >= '${min}'::date and value_date::date <= '${max}'::date)`
+      : `${name}::date >= '${min}'::date and ${name}::date <= '${max}'::date`;
+    return { op: 'between', query, extra };
   }
+
   // my rows
   if (value === 'me' && uid && fieldType === 'text') {
-    return { op: '=', query: `${name}::text = '${uid}'` };
+    return { op: '=', query: extra ? `uid = '${uid}'` : `${name}::text = '${uid}'`, extra };
   }
+
   const formatType = {
     float8: 'numeric',
     int4: 'numeric',
@@ -68,41 +80,47 @@ function formatValue({
       query: fieldType?.includes('[]')
         ? `${optimize.pk} && (select array_agg(${optimize.pk}) from ${optimize.table} where ${name} ${val} )`
         : `${optimize.pk} in (select ${optimize.pk} from ${optimize.table} where ${name} ${val} )`,
+      extra,
     };
   }
 
-  if (filter.sql) {
-    return { op: '~', query: filter.sql.replace('{val}', value) };
-  }
   if (fieldType?.includes('[]')) {
-    return { op: 'in', query: `'{${value}}'::text[] && ${name}::text[]` };
+    return { op: 'in', query: `'{${value}}'::text[] && ${name}::text[]`, extra };
   }
+
   // multiple items of 1 param
   if (value?.indexOf(',') !== -1) {
     const values = value.split(',').filter((el) => el !== 'null');
-    const query = value?.indexOf('null' !== -1)
+    if (extra && pk) {
+      const query = value?.indexOf('null') !== -1
+        ? `${pk} in (select object_id from crm.extra_data where property_key='${name}' and ( value_text is null or value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) ) )`
+        : `${pk} in (select object_id from crm.extra_data where property_key='${name}' and value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) )`;
+      return { op: 'in', query, extra };
+    }
+    const query = value?.indexOf('null') !== -1
       ? `( ${name} is null or ${name}::text in (${values?.map((el) => `'${el}'`).join(',')}) )`
       : `${name}::text in (${value.split(',')?.map((el) => `'${el}'`).join(',')})`;
-    return { op: 'in', query };
+    return { op: 'in', query, extra };
   }
 
   // v3 filter number range, example - "100_500"
   if (numberTypeList.includes(fieldType) && value?.indexOf('_') !== -1) {
     const [min, max] = value.split('_');
     const query = (max === 'max' ? `${name} > ${min}` : null) || (min === 'min' ? `${name} < ${max}` : null) || `${name} between ${min} and ${max}`;
-    return { op: 'between', query };
+    return { op: 'between', query, extra };
   }
+
   // number range
   if (numberTypeList.includes(fieldType) && value?.indexOf('-') !== -1) {
     const [min, max] = value.split('-');
     if (min === 'min' && max === 'max') return {};
     const query = (max === 'max' ? `${name} > ${min}` : null) || (min === 'min' ? `${name} < ${max}` : null) || `${name} between ${min} and ${max}`;
-    return { op: 'between', query };
+    return { op: 'between', query, extra };
   }
 
   if (['<', '>'].includes(operator)) {
     const query = `${name} ${operator} '${value}'::${formatType}`;
-    return { op: operator, query };
+    return { op: operator, query, extra };
   }
 
   if (operator === '=' && filterType !== 'text' && !filter?.data) {
@@ -110,12 +128,19 @@ function formatValue({
       null: `${name} is null`,
       notnull: `${name} is not null`,
     }[value] || `${name}::${formatType}='${value}'::${formatType}`;
-    return { op: '=', query };
+    return { op: '=', query, extra };
   }
 
   if (['~', '='].includes(operator)) {
     const operator1 = (filterType === 'text' && (filter?.id || filter?.name) && operator === '=' ? '~' : operator);
     const match = operator1 === '=' ? `='${value}'` : `ilike '%${value}%'`;
+    if (extra && pk) {
+      const query = data && sql
+        ? `${pk} in (select object_id from crm.extra_data where property_key='${name}' and value_text in ( ( with q(id,name)  as  (${sql}) select id from q where name ${match})))`
+        : `${pk} in (select object_id from crm.extra_data where property_key='${name}' and value_text ${match})`;
+      return { op: 'ilike', query, extra };
+    }
+
     const query = filter?.data && filter?.sql
       ? `${filter?.name || filter?.id} in ( ( with q(id,name)  as  (${filter?.sql}) select id from q where name::text ${match}) )` // filter with cls
       : `${name}::text ${match}`; // simple filter
@@ -127,7 +152,7 @@ function formatValue({
   if (name.includes('.')) {
     const [col, prop] = name.split('.');
     const query = ` ${col}->>'${prop}' in ('${value.join("','")}')`;
-    return { op: 'in', query };
+    return { op: 'in', query, extra };
   }
 
   // geometry
@@ -136,7 +161,7 @@ function formatValue({
 
     if (bbox?.length === 4) {
       const query = ` ${name} && 'box(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d `;
-      return { op: '&&', query };
+      return { op: '&&', query, extra };
     }
   }
   return {};

package/table/funcs/getFilterSQL/util/getFilterQuery.js

@@ -1,4 +1,5 @@
 /* eslint-disable no-continue */
+
 /**
 * @param {Number} opt.json - (1|0) 1 - Результат - Object, 0 - String
 * @param {String} opt.query - запит до таблиці
@@ -8,18 +9,13 @@
 import formatValue from './formatValue.js';
 
 function getQuery({
-  filter: filterStr, tableSQL, fields, filterList, config = {}, pg,
+  pg, filter: filterStr, table, tableSQL, fields, filterList,
 }) {
   if (!filterStr) return null; // filter list API
 
   const mainOperators = ['=', '~', '>', '<'];
 
-  // v3 filter
-  const { allTemplates } = config;
-
-  const filterQueryArray = config.v3?.filter
-    ? decodeURI(filterStr?.replace(/(^,)|(,$)/g, '')).replace(/'/g, '').split(/[;|]/)
-    : decodeURI(filterStr?.replace(/(^,)|(,$)/g, '')?.replace(/,null/g, '')).replace(/'/g, '').split(/[;|]/);
+  const filterQueryArray = decodeURI(filterStr?.replace(/(^,)|(,$)/g, '')).replace(/'/g, '').split(/[;|]/);
 
   const resultList = [];
 
@@ -33,6 +29,9 @@ function getQuery({
       continue;
     }
 
+    // filter
+    const filter = filterList?.find((el) => [el.id, el.name].includes(name)) || { type: 'text' };
+
     // find all value
     const value = filterQueryArray.filter((el) => el.startsWith(name)).map((el) => el.substring(name.length + 1)).join(',');
 
@@ -40,30 +39,24 @@ function getQuery({
 
     // find field and skip not exists
     const { dataTypeID } = fields?.find((el) => el.name === name) || fields?.find((el) => el.name === optimize?.pk) || {};
-    if (!dataTypeID) continue;
 
-    const type = pg.pgType?.[dataTypeID];
-
-    // filter
-    const filter = filterList?.find((el) => el.id === name) || { type: 'text' };
-    const filterType = filter.type?.toLowerCase();
     // format query
-
-    const { op, query } = formatValue({
-      clsList: allTemplates?.cls || [],
+    const {
+      op, query, filterType, fieldType,
+    } = formatValue({
+      pg,
+      table,
       filter,
       optimize,
-      filterType,
       name,
-      value: decodeURIComponent(value), // decodeURIComponent(value)?.replace(new RegExp(String.raw`\b${name}=\b`, 'g'), '') for checkboxes?
+      value: decodeURIComponent(value),
       operator,
-      fieldType: type || 'text',
+      dataTypeID,
     }) || {};
-    // console.log({ query, value });
     if (!query) continue;
 
     resultList.push({
-      name, value, query, operator: op, filterType, type,
+      name, value, query, operator: op, filterType, type: fieldType,
     });
   }
 

package/test/api/table.test.js

@@ -5,34 +5,72 @@ import init from '../../pg/funcs/init.js';
 
 import build from '../../helper.js';
 import config from '../config.js';
+import { getTemplate } from '../../utils.js';
+
+const table = 'test.rest_zone.table';
 
 test('api table', async (t) => {
   const app = await build(t);
   await init(pgClients.client);
 
+  const body = await getTemplate('table', table);
+  assert.equal(body?.table, 'itree.rest_zones');
+  assert.ok(pgClients.client?.pk?.[body?.table], 'invalid db - skip filter unit test');
+
+  if (pgClients.client?.pk?.[body?.table]) {
+    const custom = body?.filterCustom?.[0] || {};
+    assert.ok(custom.name && custom.sql, 'invalid test template - empty filterCustom');
+    const state = body?.filterState?.[0] || {};
+    assert.ok(state.name && state.sql, 'invalid test template - empty filterState');
+
+    await t.test('GET /data (filter + custom + state + sql)', async () => {
+      const res = await app.inject({
+        method: 'GET',
+        url: `${config.prefix || '/api'}/data/${table}`,
+        query: {
+          custom: custom.name,
+          state: state.name,
+          filter: 'balancer~1;composition=1',
+          sql: 1,
+        },
+      });
+      assert.ok(res.body?.includes(custom.sql), 'filterCustom not ok');
+      assert.ok(res.body?.includes(state.sql), 'filterState not ok');
+      assert.ok(res.body?.includes('balancer::text ilike \'%1%\'  and \'{1}\'::text[] && composition::text[]'), 'filter not ok');
+    });
+  }
+
   const bbox = '20.276526313524393 40.6651677831094,35.27752631352439 50.66616778310941';
-  const { count = 0 } = await pgClients.client.query(`select count(*) from gis.dataset 
-  where geom && 'box(${bbox})'::box2d`)
-    .then((res) => res.rows[0] || {});
+  const { count = 0 } = pgClients.client?.pk[body?.table] ? await pgClients.client.query(`select count(*) from itree.rest_zones
+  where verif and '{1}'::text[] && composition::text[] and geom && 'box(${bbox})'::box2d`).then((res) => res.rows[0] || {}) : {};
 
   await t.test('GET /data (meta bbox / cls)', async () => {
     const res = await app.inject({
       method: 'GET',
-      url: `${config.prefix || '/api'}/data/test.dataset.table?bbox=${bbox}`,
+      url: `${config.prefix || '/api'}/data/${table}`,
+      query: { bbox, filter: 'composition=1' },
     });
     const json = res.json();
-    assert.ok(json?.rows?.length === +count, 'meta bbox - not ok');
-    assert.ok(json?.rows?.length ? json?.rows?.[0]?.dataset_id_text : true, 'meta cls - not ok');
+    const res1 = await app.inject({
+      method: 'GET',
+      url: `${config.prefix || '/api'}/data/${table}`,
+      query: { bbox, sql: 1 },
+    });
+    const { body: sql } = res1;
+    assert.ok(sql?.includes(bbox), 'meta bbox sql - not ok');
+    assert.ok(json?.rows?.length && +count >= json?.rows?.length, 'meta bbox - not ok');
+    assert.ok(json?.rows?.length ? json?.rows?.[0]?.composition_text : true, 'meta cls - not ok');
   });
 
   const polyline = 'wfvkH_jsvCoKvj@oKfiB?fw@?nd@?nK?nK~WgEfE?wQfw@gEfE?vQwQvj@wQvcAoKvQoKnKgEnd@_cBgw@wj@fEwj@nKg^vQg^oK?vQgEnKgpAvj@?vcAfEf^fEf^?vj@vQvj@vQgE~Wvj@?~p@gE~iAfEnK?~iA_XnvA?nd@fEf^~p@~bBvQ?nd@wQ?vQfEf^fEnK?vQ?vj@oKfEoKfEvQnd@nKvj@?vQfEvQgEf^gEf^?vQfEvQfEvQfE~W?fE?fE?~W?f^?nd@?nK?nKfEfEg^oKwj@nK_X~W~p@~WvQnKoKn}@wQvj@oK~Wg^vcAgEnK?~Wfw@vgD~p@oKfpAvQnd@nKoKvQoKvQ?fE?fEnKvj@wQvQ?fEod@fw@~Wn}@fEn}@_Xv|A_jA~fEwQwQ_XoKwQoKoKoKoKoKg^gE_XgEoKg^gEgEgE?gEfEgEfEgEf^_XoKwQ?gEgEoK?wQ?gE~WoKoKoKwQfEgEnK_X?gEgE?oKfEoKoKgE_XgEgEwQfEoKod@_Xgw@gEoKgE_Xg^wQoKg^_XnvAgE?gEvQgE?od@fpA?vQ?f^oKvcAwj@oKg^?wQn}@gEf^oK?w|AnKgE??nKwj@gEgEg^oKwQoKoK?gEwQoaD?oKod@oKod@gEod@wQo}@oKfEf^gEfEgpAnd@_XfEgE?wQnKo}@_q@?gEgEwj@?oK?oK?_X?oKfEoK?oKfEoK?oK?oK?gEfEoKwQfEoK?gEwQwj@nKo}@nKwQ~Wod@nKoKfEgw@ovAgEwQgE??oKoKgEoKgEgEwQ?oKfEoKnKwQfEwQoK?g^fE?wQfEg^fEod@gE??fEoKvQ?nKoKnKgEfEgEgE?g^nK_q@nKod@?oKoKoK~Wgw@fEoKnd@fE?_XfEoKfEwQfEoKfEwQfEoKvQ?fEfE?vj@gE~W~WvQvQwj@vQvQf^o}@nKvQ?_XgEg^gEg^nKod@?wQgEgEgE?oK_XgEoK?oKgEoKgE_XoKg^oKg^oKod@?gEfEoKvQgEnK?nKfE?_Xnd@gw@fEwQf^wj@fEwQnd@w|A?gEgEgEgEwQfEoKfEgEnKoKnKwQfEgE?oKfEoKnKgEnKwQ_XwQnKwcAod@wQvQod@~Wgw@nKgw@oKg^f^ovAgEwQ?_X?od@gEwj@gEwQvQg^fEoKnKoKvQnK~WfEnKvQ~Wod@f^wj@~WoKnKg^~W?vQgE~WoKnKoK~WoKfEwQvQwQfEgEnKwQnKwQvQwQnKoKnKgEnKgEnKgEvQnKnK?fE?fE?~WwQnKgEnKgEfE?fE?nK?fE?fE?vQgEfE?nKfEfE?fE?vQ?~W?~WgEfEgEnKgEnKwQfEnKnKfE?wj@?o}@g^o}@_Xod@?gEf^_X?o}@?wQ~W?~WgE~WgEfE?f^gEf^oK~Wg^nKgE?oK~WwQ?od@nK_XfEwQnKoKfEgEfE~W?f^f^fEfEfEnKfEnK?gEf^vQfEnK?~WnKvQnK?vQf^nKfEfEgE~WnKfEnK?fEgEfE?nK?fEfEfEgEnK?nKgEnK?nKfEf^?vQgEvQ?nd@gEnKo}@vQgE~WgEf^gE'; // UA26040270000047749
 
-  const { count1 } = await pgClients.client.query('select count(*) as count1 from gis.dataset where ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline($1)),geom)', [polyline])
+  const { count1 } = await pgClients.client.query('select count(*) as count1 from itree.rest_zones where verif and ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline($1)),geom)', [polyline])
     .then((res) => res.rows[0] || {});
   await t.test('GET /data (meta polyline)', async () => {
     const res = await app.inject({
       method: 'GET',
-      url: `${config.prefix || '/api'}/data/test.dataset.table?polyline=${polyline}`,
+      url: `${config.prefix || '/api'}/data/${table}`,
+      query: { polyline },
     });
     const json = res.json();
     assert.ok(json?.rows?.length === +count1, 'meta bbox (polyline) - not ok');

package/utils.js

@@ -33,6 +33,7 @@ import execMigrations from './migration/exec.migrations.js';
 import addNotification from './notification/funcs/addNotification.js';
 import sendNotification from './notification/funcs/sendNotification.js';
 import logger from './logger/getLogger.js';
+// const logger = false; // test!
 
 export default null;
 export {