@opengis/fastify-table 1.2.68 → 1.2.70

package/package.json

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

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

@@ -34,7 +34,7 @@ function checkBody({ body = {}, arr = [], idx }) {
         const input = arr.find(el => el.key === key) || {};
 
         if (input.colModel?.length && input.type?.toLowerCase() === 'datatable') {
-            const result = body[key].reduce((acc, item, i) => {
+            const result = body[key]?.reduce?.((acc, item, i) => {
                 const check = checkBody({ body: item, arr: input.colModel, idx: i });
                 acc.push(check);
                 return acc;
@@ -48,10 +48,10 @@ function checkBody({ body = {}, arr = [], idx }) {
         return acc1;
     }, []);
 
-    const invalidField = res.find(el => el.error);
+    const invalidField = res.find(el => el?.error);
 
     if (invalidField) {
-        console.warn('invalid field: ', invalidField.key, invalidField.error);
+        console.warn('invalid field: ', invalidField?.key, invalidField?.error);
         return invalidField;
     }
 

package/server/plugins/pg/funcs/autoIndex.js

@@ -16,8 +16,8 @@ async function autoIndex({
 
   if (!filter?.length || !table) return null;
 
-  const attrs = filter.map((el) => (el.name || el).replace(/'/g, '')).sort();
-  const types = filter.map((el) => (el.name ? el : { name: el }))
+  const attrs = filter.map((el) => (el.name || el).replace(/'/g, '')).filter(el => el?.indexOf('(') === -1).sort();
+  const types = filter.filter(el => (el?.name || el)?.indexOf?.('(') === -1).map((el) => (el.name ? el : { name: el }))
     .reduce((p, el) => ({ ...p, [el.name]: el.type || '-' }), {});
 
   const redisKey = `autoindex1:${table}:${attrs.join(';')}`;

package/server/plugins/pg/funcs/init.js

@@ -70,7 +70,7 @@ async function init(client) {
 
   async function queryCache(q, param = {}) {
     const { table, args = [], time = 15 } = param;
-    const seconds = typeof time !== 'number' || time < 0 ? 15 : (config.local ? 0 : time * 60);
+    const seconds = typeof time !== 'number' || time < 0 ? 0 : time * 60;
 
     // CRUD table state
     const keyCacheTable = `pg:${table}:crud`;
@@ -92,6 +92,7 @@ async function init(client) {
     if (seconds > 0) {
       rclient.set(keyCache, JSON.stringify(data), 'EX', seconds);
     }
+
     // console.log('no cache', table, crudInc, query);
     return data;
   }

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

@@ -1,8 +1,8 @@
 import routeData from '../../../routes/table/controllers/data.js';
 
-export default async function getData({ id, table, pg, filter, limit, page, search, user }) {
+export default async function getData({ id, table, pg, filter, limit, page, search, user, sql }, reply, called) {
   const params = { table, id };
-  const query = { filter, limit, page, search };
-  const result = await routeData({ pg, params, query, user });
+  const query = { filter, limit, page, search, sql };
+  const result = await routeData({ pg, params, query, user, sql }, reply, called);
   return result;
 }

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

@@ -7,24 +7,20 @@ import getTableSql from './util/getTableSql.js';
 import getFilterQuery from './util/getFilterQuery.js';
 import getOptimizedQuery from './util/getOptimizedQuery.js';
 
+const checkInline = {};
 const defaultTable = 'crm.extra_data';
 
-function getExtraQuery(mainColumns, extraColumns, schema, table, pk, mode = 'property') {
-  const extraKeys = mode === 'column'
-    ? Object.keys(schema || {}).filter(key => !mainColumns.map(el => el?.name).includes(key) && extraColumns.map(el => el?.name).includes(key))
-    : Object.keys(schema || {}).filter(key => !mainColumns.map(el => el?.name).includes(key));
+function getExtraQuery(mainColumns, schema, table, pk) {
+  const extraKeys = Object.keys(schema || {}).filter(key => !mainColumns.map(el => el?.name).includes(key));
 
-  if (mode === 'column') {
-    return { q: `left join lateral (select ${extraKeys.map(key => `"${key}"`).join(',')} from ${table} where ${pk}=t.${pk} limit 1) extra on 1=1`, extraKeys };
-  }
   return {
-    q: extraKeys.map((el, idx) => `left join lateral (select value_text as "${el.replace(/'/g, "''")}" from ${table} where property_key='${el.replace(/'/g, "''")}' and object_id=t.${pk} limit 1) extra${idx} on 1=1`).join(' '),
+    q: extraKeys.map((el) => `,(select value_text as "${el.replace(/'/g, "''")}" from ${table} where property_key='${el.replace(/'/g, "''")}' and object_id=t.${pk} limit 1)`).join(' '),
     extraKeys,
   };
 }
 
 export default async function getFilterSQL({
-  table, filter, pg = pgClients.client, search, filterList, query, custom, state,
+  table, filter, pg = pgClients.client, search, filterList, query, custom, state, uid,
 }) {
   if (!table) return { error: 'param table is required', status: 400 };
 
@@ -40,32 +36,46 @@ export default async function getFilterSQL({
     || defaultTable
     : undefined;
 
-  const { fields: fieldsExtra = [] } = pg.pk?.[extraDataTable] ? await pg.query(`select * from ${extraDataTable} limit 0`) : {};
-  const mode = fieldsExtra.find((col) => col?.name === pg.pk?.[body?.table || table]) ? 'column' : 'property';
-
-  const { fields: fieldsModel = [] } = body?.table && pg.pk[body?.table] ? await pg.query(`select * from ${body.table} limit 0`) : {};
-  const { q: extraSqlList, extraKeys } = pg.pk?.[extraDataTable] && pg.pk?.[body?.table]
-    ? getExtraQuery(fieldsModel, fieldsExtra, loadTemplate?.schema, extraDataTable, pg.pk[body?.table || table], mode)
+  const { fields: fieldsModel = [] } = body?.table && pg.pk[body.table] ? await pg.query(`select * from ${body.table} limit 0`) : {};
+  const { q: extraSqlColumns, extraKeys } = pg.pk?.[extraDataTable] && pg.pk?.[body.table || table]
+    ? getExtraQuery(fieldsModel, loadTemplate?.schema, extraDataTable, pg.pk[body.table || table])
     : {};
 
   // console.log('extra getFilterSQL', extraDataTable, pg.pk?.[extraDataTable]);
 
-  const sqlList = body?.sql?.length
-    ? body?.sql?.filter((el) => !el.disabled && el?.sql?.replace)
-      .map((el, i) => {
-        Object.assign(el, { name: el.name || `t${i + 1}` });
-        return ` left join lateral (${el.filter ? el.sql.replace(/limit 1/ig, '') : el.sql}) as ${el.name} on 1=1 `;
-      }).join(' ')
-    : '';
-  const fieldQuery = `select * from ${body?.table || table} t ${sqlList || ''} ${extraSqlList || ''} limit 0`;
-  const { fields = [] } = !extra || mode === 'column' ? await pg.query(fieldQuery) : { fields: extraKeys.map(el => ({ name: el.name, dataTypeID: 25 })) };
+  // check sql inline fields count
+  if (!checkInline[body?.table] && body?.sql?.length && body.table) {
+    const filterSql = body.sql.filter(el => !el?.disabled && (el.inline ?? true));
+    const sqlTable = filterSql.map((el, i) => ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
+    const d = await Promise.all(filterSql.map((el, i) => pg.query(`select  ${el.name || `t${i}`}.* from(select * from ${body.table})t ${sqlTable} limit 0`).then(el => el.fields)))
+    d.forEach((el, i) => {
+      filterSql[i].inline = el.length == 1 ? true : false;
+      filterSql[i].fields = el.map(f => f.name);
+    });
+    checkInline[body?.table] = body.sql;
+  } else if (checkInline[body?.table]) {
+    body.sql = checkInline[body?.table]
+  }
+
+  const sqlTable = body?.sql?.length
+    ? body.sql
+      .filter((el) => !el?.disabled && !el.inline && el?.sql?.replace && (!el.sql.includes('{{uid}}') || uid))
+      .map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ${el.name || `t${i}`} on 1=1 `)
+      .join('')
+    : null;
+  const sqlInline = body.sql?.filter?.(el => el.inline).map(el => `,(${el.sql})`).join('');
+
+  const fieldQuery = `select * ${extraSqlColumns || ''} ${sqlInline || ''} from ${body?.table || table} t ${sqlTable || ''} limit 0`;
+  const { fields = [] } = !extra ? await pg.query(fieldQuery) : { fields: extraKeys.map(el => ({ name: el.name, dataTypeID: 25 })) };
   const autoSearchColumn = fields?.filter((el) => pg.pgType?.[el.dataTypeID] === 'text')?.map((el) => el.name).join(',');
   const searchColumn = body?.search_column || body?.meta?.search || autoSearchColumn;
   const fieldsList = (fieldsModel || fields)?.map((el) => el.name);
+
   try {
     const tableSQL = await getTableSql({
       pg, body, table, fields,
     });
+
     const sval = `ilike '%${decodeURIComponent(search?.replace(/%/g, '%25')).replace(/'/g, "''").replace(/%/g, '\\%')}%'`;
     const searchQuery = search && searchColumn
       ? ` (${searchColumn.split(',')?.map((name) => {
@@ -73,33 +83,40 @@ 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 ')} )` : '';
 
-    body?.filterSql?.forEach?.((el) => Object.assign(el, { filtersql: 1 }));
-
-    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(body?.filterSql || []) /* .concat(extraFilters || []).concat(customFilters || []) */
-
-      ?.map(async (el) => {
-        if (el.name && extraKeys?.includes?.(el.name)) {
-          Object.assign(el, { extra: { table: extraDataTable, mode } });
-        }
-        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 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 && extraKeys?.includes?.(el.name)) {
+        Object.assign(el, { extra: { table: extraDataTable } });
+      }
+      if (!el?.data) return el;
+      const cls = await getTemplate(['cls', 'select'], el.data);
+
+      if (Array.isArray(cls) && cls?.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;
 
     const filters = getFilterQuery({
       pg,
       filter,
-      table: body?.table || table,
+      table: modelQuery,
       tableSQL,
       fields,
       filterList: filterList1,
+      uid,
     });
 
     // filter
@@ -110,16 +127,18 @@ export default async function getFilterSQL({
     const q = [body?.query, query, searchQuery, filterQuery, stateQuery, customQuery].filter((el) => el).join(' and ');
 
     // table
-    const modelQuery = body?.model || body?.table || table;
-    const optimizedSQL = `select * from ${getOptimizedQuery({ body, extraSqlList, table, q })} `;
-    const tableCount = getOptimizedQuery({ body, extraSqlList, table, q }, true);
-    // console.log(optimizedSQL);
+
+    const obj = { table: modelQuery, orderby: body?.order || body?.orderby, sqlTable, sqlInline, extraSqlColumns, q };
+    const optimizedSQL = `select * from ${getOptimizedQuery(obj)} `;
+    const tableCount = getOptimizedQuery(obj, true);
+
     return {
       filterList,
-
+      filters,
       q,
       optimizedSQL,
-      extraSqlList,
+      sqlTable,
+      extraSqlColumns,
       extraKeys,
       tableCount,
       table: modelQuery,

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

@@ -1,6 +1,15 @@
 const dateTypeList = ['date', 'timestamp', 'timestamp without time zone', 'timestamp with time zone'];
 const numberTypeList = ['float8', 'int4', 'int8', 'numeric', 'double precision', 'integer'];
+
 const isValidDate = (dateStr) => {
+  if (!dateStr) return false;
+  // iso date: 2024-01-01
+  if (dateStr?.indexOf('-') !== -1) {
+    const [yyyy, mm, dd] = dateStr.split('-');
+    return new Date(mm + '/' + dd + '/' + yyyy).toString() !== 'Invalid Date';
+  }
+
+  // locale date: 01.01.2024
   const [dd, mm, yyyy] = dateStr.split('.');
   return new Date(mm + '/' + dd + '/' + yyyy).toString() !== 'Invalid Date';
 };
@@ -8,6 +17,7 @@ const isValidDate = (dateStr) => {
 function dt(y, m, d) {
   return new Date(Date.UTC(y, m, d)).toISOString().slice(0, 10);
 }
+
 const dp = {
   d: new Date().getDate(),
   w: new Date().getDate() - (new Date().getDay() || 7) + 1,
@@ -22,96 +32,150 @@ function formatDateISOString(date) {
   return `${year}-${month}-${day}`;
 }
 
+function getDates(value) {
+  // date range, specific options: current day, week, month, year etc.
+  if (value === 'cd') {
+    return [dt(dp.y, dp.m, dp.d)];
+  }
+  if (value === 'cw') {
+    return [dt(dp.y, dp.m, dp.w), dt(dp.y, dp.m, dp.w + 6)];
+  }
+  if (value === 'cm') {
+    return [dt(dp.y, dp.m, 1), dt(dp.y, dp.m + 1, 0)];
+  }
+  if (value === 'cq') {
+    return [dt(dp.y, dp.q, 1), dt(dp.y, dp.q + 3, 0)];
+  }
+  if (value === 'cy') {
+    return [dt(dp.y, 0, 1), dt(dp.y, 11, 31)];
+  }
+
+  // date range, example: 01.01.2024-31.12.2024
+  const [startDate, endDate] = value.split('-');
+  const min = formatDateISOString(startDate);
+  const max = formatDateISOString(endDate);
+  return [min, max];
+}
+
 function formatValue({
   pg, table, filter = {}, name, value, operator = '=', dataTypeID, uid = 1, optimize,
 }) {
-  const { data, sql, extra, filtersql } = filter;
+  const { extra, sql, select } = 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];
-  const fieldType = pg.pgType?.[dataTypeID] || pg.pgType?.[{ Date: 1114 }[filter?.type || ''] || 25];
+
+  const filterType = filter.type?.toLowerCase() || 'text';
+  const fieldType = pg.pgType?.[dataTypeID] || pg.pgType?.[{ date: 1114 }[filterType] || 25];
 
   if (!name || !value || !fieldType) return {};
-  const filterType = filter.type?.toLowerCase();
-
-  // body.filterSql
-  if (sql && filtersql) {
-    // date range
-    if (filterType === 'date') {
-      const [startDate, endDate] = value.split('-');
-      const min = formatDateISOString(startDate);
-      const max = formatDateISOString(endDate);
-
-      if (!isValidDate(startDate) || !isValidDate(endDate)) {
-        return { op: 'between', query: 'false', extra, sql: true };
-      }
-
-      const query = sql.replace(/\$1/g, `'${min}'::date`).replace(/\$2/g, `'${max}'::date`);
-      return { op: '=', query, extra, sql: true };
+
+  // Date filter
+  if (filterType === 'date' /* && dateTypeList.includes(fieldType) */) {
+    const [min, max] = getDates(value, name);
+
+    // check date is valid
+    if (!isValidDate(min) || (!isValidDate(max) && value !== 'cd')) {
+      return { op: 'between', query: 'false' };
+    }
+
+    // with sql subquery
+    if (sql) {
+      return { op: '=', query: sql.replace(/\$1/g, `'${min}'::date`).replace(/\$2/g, `'${max}'::date`) };
     }
 
-    // num range
-    if (filterType === 'range') {
-      const [min, max] = value?.indexOf('_') !== -1 ? value.split('_') : value.split('-');
-      const query = sql.replace(/\$1/g, min).replace(/\$2/g, max);
-      return { op: 'between', query, extra, sql: true };
+    // preset values
+    if (['cw', 'cm', 'cq', 'cy'].includes(value)) {
+      return { op: 'between', query: `${name}::date between '${min}'::date and '${max}'::date` };
     }
 
+    // preset values: current day
+    if (value === 'cd') {
+      return { op: '=', query: `${name}::date = '${min}'::date` };
+    }
+
+    // extra columns, example: crm.extra_data
+    if (extra?.table && pk) {
+      const query = extra?.table && pk
+        ? `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_date::date between '${min}'::date and '${max}'::date)`
+        : `${pk} in (select ${pk} from ${extra.table} where ${name}::date between '${min}'::date and '${max}'::date)`;
+      return { op: 'between', query };
+    }
+
+    // same date
+    if (max && min && min === max) {
+      return { op: 'strict', query: `${name}::date = '${min}'::date` };
+    }
+
+    // default
+    return { op: 'between', query: `${name}::date between '${min}'::date and '${max}'::date` };
+  }
+
+  // Range filter, example: 100-500
+  if (filterType === 'range' /* && numberTypeList.includes(fieldType) */) {
+    const [min, max] = value?.indexOf('_') !== -1 ? value.split('_') : value.split('-');
+
+    // with sql subquery
+    if (sql) {
+      return { op: '=', query: sql.replace(/\$1/g, min).replace(/\$2/g, max) };
+    }
+
+    if (min === 'min' && max === 'max') {
+      return { op: 'between', query: 'false' };
+    }
+
+    // default
+    const query = (max === 'max' ? `${name} > ${min}` : null) || (min === 'min' ? `${name} < ${max}` : null) || `${name} between ${min} and ${max}`;
+    return { op: 'between', query };
+  }
+
+  // Autocomplete, Check, Text filter with sql subquery
+  if (sql) {
     // autocomplete, check
     if (sql?.indexOf('any($1)') !== -1) {
       const query = sql.replace(/= ?any\(\$1\)/g, `::text=any('{ ${value} }'::text[])`);
-      return { op: '=', query, extra, sql: true };
+      return { op: '=', query };
     }
 
-    // text
+    // default
     const query = sql.replace(/\$1/g, `'${value}'`);
-    return { op: '=', query, extra, sql: true };
+    return { op: '=', query };
   }
 
-  // current day, week, month, year etc.
-  if (dateTypeList.includes(fieldType) && !value?.includes('_') && ['cd', 'cw', 'cm', 'cq', 'cy'].includes(value)) {
-    const query = {
-      cd: `${name}::date = '${dt(dp.y, dp.m, dp.d)}'::date`,
-      cw: `${name}::date >= '${dt(dp.y, dp.m, dp.w)}'::date and ${name} <= '${dt(dp.y, dp.m, dp.w + 6)}'::date`,
-      cm: `${name}::date >= '${dt(dp.y, dp.m, 1)}'::date and ${name} <= '${dt(dp.y, dp.m + 1, 0)}'::date`,
-      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, 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, 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);
-
-    if (!isValidDate(startDate) || !isValidDate(endDate)) {
-      return { op: 'between', query: 'false', extra };
-    }
+  const matchNull = { null: 'is null', notnull: 'is not null' }[value];
+  const matchBoolean = fieldType === 'boolean' ? { true: 'is true', false: 'is false' }[value] : null;
+  const matchMulti = value?.indexOf(',') !== -1 ? `= any('{${value}}'::text[])` : null;
+  const match = matchNull || matchBoolean || matchMulti || (operator === '=' ? `='${value}'` : `ilike '%${value}%'`);
+
+  /* select query - from admin.cls / filter options */
+  if (['check', 'autocomplete', 'text',  'tags', 'avatar', 'radio'].includes(filterType)) {
+
+    // extra table, example: crm.extra_data
     if (extra?.table && pk) {
-      const query = extra?.mode === 'property' && pk
-        ? `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_date::date >= '${min}'::date and value_date::date <= '${max}'::date)`
-        : `${pk} in (select ${pk} from ${extra.table} where ${name}::date >= '${min}'::date and ${name}::date <= '${max}'::date)`;
-      return { op: 'between', query, extra };
+      const subquery = filterType === 'autocomplete' ? match : `in ( ( with q(id,name) as (${select}) select id from q where name::text ${match}))`;
+      const query = select
+        ? `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_text ${subquery} )`
+        : `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_text ${match})`;
+      return { op: operator, query };
     }
-    return { op: 'between', query: `${name}::date >= '${min}'::date and ${name}::date <= '${max}'::date`, extra };
+
+    // default
+    const query = select && filterType === 'text'
+      ? `${name}::text in ( ( with q(id,name) as (${select}) select id from q where name::text ${match}) )` // filter with cls
+      : `${name}::text ${match}`; // simple filter
+    return { op: operator, query };
   }
 
   // my rows
-  if (value === 'me' && uid && fieldType === 'text') {
-    const query = extra?.table && pk
+  if (value === 'me' && uid) {
+    if (sql) {
+      return { op: '=', query: sql.replace(/\$1/g, `'${uid}'`) };
+    }
+
+    const query = extra?.table && pk && fieldType === 'text'
       ? `${pk} in (select ${pk} from ${extra.table} where uid = '${uid}')`
       : `${name}::text = '${uid}'`;
-    return { op: '=', query, extra };
+    return { op: '=', query };
   }
 
   const formatType = {
@@ -123,6 +187,7 @@ function formatValue({
     geometry: 'geom',
   }[fieldType] || 'text';
 
+  // sql column?
   if (optimize && optimize.name !== optimize.pk) {
     const val = filterType === 'text' ? `ilike '%${value}%'` : `= any('{${value}}')`;
     return {
@@ -134,49 +199,33 @@ function formatValue({
     };
   }
 
+  // filter text array column
   if (fieldType?.includes('[]')) {
-    return { op: 'in', query: `'{${value}}'::text[] && ${name}::text[]`, extra };
+    return { op: 'in', query: `'{${value}}'::text[] && ${name}::text[]` };
   }
 
-  // multiple items of 1 param
+  // filter multiple values, example: 1,2,3
   if (value?.indexOf(',') !== -1) {
     const values = value.split(',').filter((el) => el !== 'null');
-    if (extra?.mode === 'property' && pk) {
-      const query = value?.indexOf('null') !== -1
-        ? `${pk} in (select object_id from ${extra?.table} where property_key='${name}' and ( value_text is null or value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) ) )`
-        : `${pk} in (select object_id from ${extra?.table} where property_key='${name}' and value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) )`;
-      return { op: 'in', query, extra };
-    } else if (extra?.mode === 'property' && pk) {
+
+    // extra table, example: crm.extra_data
+    if (extra?.table && pk) {
       const query = value?.indexOf('null') !== -1
-        ? `${pk} in (select ${pk} from ${extra?.table} where ( "${name}" is null or "${name}" in (${values?.map((el) => `'"${el}"'`).join(',')}) ) )`
-        : `${pk} in (select ${pk} from ${extra?.table} where "${name}" in (${values?.map((el) => `'"${el}"'`).join(',')}) )`;
-      return { op: 'in', query, extra };
+        ? `${pk} in (select object_id from ${extra.table} where property_key='${name}' and ( value_text is null or value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) ) )`
+        : `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) )`;
+      return { op: 'in', query };
     }
 
+    // default
     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, 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, 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, extra };
+    return { op: 'in', query };
   }
 
   if (['<', '>'].includes(operator)) {
     const query = `${name} ${operator} '${value}'::${formatType}`;
-    return { op: operator, query, extra };
+    return { op: operator, query };
   }
 
   if (operator === '=' && filterType !== 'text' && !filter?.data) {
@@ -184,39 +233,14 @@ function formatValue({
       null: `${name} is null`,
       notnull: `${name} is not null`,
     }[value] || `${name}::${formatType}='${value}'::${formatType}`;
-    return { op: '=', query, extra };
-  }
-
-  if (['~', '='].includes(operator)) {
-    const operator1 = (filterType === 'text' && (filter?.id || filter?.name) && operator === '=' ? '~' : operator);
-    const matchNull = { null: 'is null', notnull: 'is not null' }[value];
-    const matchBoolean = fieldType === 'boolean' ? { true: 'is true', false: 'is false' }[value] : null;
-    const match = matchNull || matchBoolean || ((operator1 === '=' || filterType === 'autocomplete') ? `='${value}'` : `ilike '%${value}%'`);
-
-    if (extra?.mode === 'property' && pk) {
-      const query = data && sql
-        ? `${pk} in (select object_id from ${extra?.table} where property_key='${name}' and value_text in ( ( with q(id,name)  as  (${sql}) select id from q where ${filterType === 'autocomplete' ? 'id' : 'name'} ${match})))`
-        : `${pk} in (select object_id from ${extra?.table} where property_key='${name}' and value_text ${match})`;
-      return { op: 'ilike', query, extra };
-    } else if (extra?.mode === 'column') {
-      const query = data && sql
-        ? `${pk} in (select ${pk} from ${extra?.table} where "${name}" in ( ( with q(id,name)  as  (${sql}) select id from q where ${filterType === 'autocomplete' ? 'id' : 'name'} ${match})))`
-        : `${pk} in (select ${pk} from ${extra?.table} where "${name}" ${match})`;
-      return { op: 'ilike', query, extra };
-    }
-
-    const query = data && sql && filterType == 'text'
-      ? `${name || filter?.id} in ( ( with q(id,name)  as  (${sql}) select id from q where ${filterType === 'autocomplete' ? 'id' : 'name'}::text ${match}) )` // filter with cls
-      : `${name}::text ${match}`; // simple filter
-    // console.log(query);
-    return { op: 'ilike', query, extra };
+    return { op: '=', query };
   }
 
   // json
   if (name.includes('.')) {
     const [col, prop] = name.split('.');
     const query = ` ${col}->>'${prop}' in ('${value.join("','")}')`;
-    return { op: 'in', query, extra };
+    return { op: 'in', query };
   }
 
   // geometry
@@ -225,7 +249,7 @@ function formatValue({
 
     if (bbox?.length === 4) {
       const query = ` ${name} && 'box(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d `;
-      return { op: '&&', query, extra };
+      return { op: '&&', query };
     }
   }
   return {};

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

@@ -9,7 +9,7 @@
 import formatValue from './formatValue.js';
 
 function getQuery({
-  pg, filter: filterStr, table, tableSQL, fields, filterList,
+  pg, filter: filterStr, table, tableSQL, fields, filterList, uid,
 }) {
   if (!filterStr) return null; // filter list API
 
@@ -21,8 +21,8 @@ function getQuery({
 
   for (let i = 0; i < filterQueryArray.length; i += 1) {
     const item = filterQueryArray[i];
-    const operator = mainOperators?.find((el) => item.indexOf(el) !== -1) || '=';
-    const [name] = item.split(operator);
+    const splitby = mainOperators?.find((el) => item.indexOf(el) !== -1) || '=';
+    const [name] = item.split(splitby);
 
     // skip already added filter
     if (resultList.find((el) => el.name === name)) {
@@ -30,10 +30,12 @@ function getQuery({
     }
 
     // filter
-    const filter = filterList?.find((el) => [el.id, el.name].includes(name)) || { type: 'text' };
+    const filter = filterList?.find?.((el) => el.type && el.name === name) || { type: 'text' };
+    const { strict, extra } = filter;
+    const operator = filter.strict || ['check', 'autocomplete'].includes(filter.type.toLowerCase()) ? '=' : (splitby !== '=' ? splitby : '~');
 
     // find all value
-    const value = filterQueryArray.filter((el) => el.startsWith(name)).map((el) => el.substring(name.length + 1)).join(',');
+    const value = filterQueryArray.filter((el) => el.split(splitby)?.[0] === name).map((el) => el.substring(name.length + 1)).join(',');
 
     const optimize = fields?.find((el) => el.name === name) ? null : tableSQL.find((el) => el.name === name);
 
@@ -52,11 +54,12 @@ function getQuery({
       value,
       operator,
       dataTypeID,
+      uid,
     }) || {};
     if (!query) continue;
 
     resultList.push({
-      name, value, query, operator: op, filterType, type: fieldType,
+      name, value, query, operator: op, filterType, type: fieldType, strict, extra,
     });
   }
 

package/server/plugins/table/funcs/getFilterSQL/util/getOptimizedQuery.js

@@ -1,12 +1,6 @@
-function getOptimizedQuery({ body, extraSqlList, table, q }, count) {
-  const order = body?.orderby || body?.order ? `order by ${body?.orderby || body?.order}` : '';
-
-  const tableName = body?.table || body?.model || table;
-
-  const sqlList = body?.sql?.filter((el) => !el.disabled && el?.sql?.replace && (count ? el.count !== false : true))
-    .map((el) => ` left join lateral (${el.filter ? el.sql.replace(/limit 1/ig, '') : el.sql}) as ${el.name} on 1=1 `).join(' ');
-
-  return `(select * from ${tableName} t ${sqlList ? ` ${sqlList}` : ''} ${extraSqlList || ''} where 1=1 and ${q?.replace('q.', 't.') || '1=1'} ${order})q`;
+export default function getOptimizedQuery({ table, orderby, sqlTable, sqlInline, extraSqlColumns, q }, count) {
+  if (sqlInline) {
+    return `(select * ${extraSqlColumns || ''} ${sqlInline ? sqlInline : ''} from ${table} t ${sqlTable && count ? ` ${sqlTable}` : ''})q where 1=1 and ${q ? q.replace('q.', 't.') : '1=1'} ${orderby ? `order by ${orderby}` : ''}`;
+  }
+  return `(select * ${extraSqlColumns || ''} ${sqlInline ? sqlInline : ''} from ${table} t ${sqlTable && count ? ` ${sqlTable}` : ''} where 1=1 and ${q ? q.replace('q.', 't.') : '1=1'} ${orderby ? `order by ${orderby}` : ''})q`;
 }
-
-export default getOptimizedQuery;

package/server/plugins/table/funcs/metaFormat/getSelectVal.js

@@ -30,7 +30,9 @@ export default async function getSelectVal({
   const filteredValues = values.filter(el => !cache[el]);
 
   // query select
-  const q = `with c(id,text) as (select * from (${cls.sql})q where ${id} = any('{${filteredValues}}')) select * from c`;
+
+  const q = `with c(id,text) as (select * from (${cls.sql})q where ${id} = any('{${filteredValues.join(',').replace(/\"/g, '\\"')}}')) select * from c`;
+
   const data = filteredValues.length ? await pg.query(q).then(el => el.rows) : [];
 
   const clsObj = { ...cache, ...data.reduce((p, el) => ({ ...p, [el.id.toString()]: el.color ? el : el.text }), {}) };

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

@@ -46,9 +46,9 @@ export default async function tableAPI(req) {
   // const cols = columns.map((el) => el.name || el).join(',');
   const formName = hookData?.form || tokenData?.form || form;
   const formData = await getTemplate('form', formName) || {};
-  const schema = formData?.schema || formData;
+  const schema = formData?.schema || formData || {};
   // skip DataTable from another table
-  const extraKeys = Object.keys(schema)?.filter((key) => schema[key]?.type === 'DataTable' && schema[key]?.table && schema[key]?.parent_id && schema[key]?.colModel?.length);
+  const extraKeys = Object.keys(schema).filter((key) => schema[key]?.type === 'DataTable' && schema[key]?.table && schema[key]?.parent_id && schema[key]?.colModel?.length);
   // skip non-existing columns
   const columnList = dbColumns.map((el) => el.name || el).join(',');
 
@@ -65,6 +65,10 @@ export default async function tableAPI(req) {
   const data = await pg.query(q, [id]).then(el => el.rows[0]);
   if (!data) return { message: 'not found', status: 404 };
 
+  Object.keys(schema).filter(key => schema[key]?.type === 'DataTable').forEach(key => {
+    if (data[key] && !Array.isArray(data[key])) { data[key] = null };
+  });
+
   if (extraKeys?.length) {
     await Promise.all(extraKeys?.map(async (key) => {
       const { colModel, table: extraTable, parent_id: parentId } = schema[key];

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

@@ -19,7 +19,7 @@ export default async function dataAPI(req, reply, called) {
   } = req;
 
   const time = Date.now();
-
+  const timeArr = [Date.now()];
   const { uid } = user;
 
   const hookData = await applyHook('preData', {
@@ -34,9 +34,10 @@ export default async function dataAPI(req, reply, called) {
   const loadTable = await getTemplate('table', tokenData?.table || hookData?.table || params.table);
 
   // check sql inline fields count
-  if (!checkInline[params?.table] && loadTable.sql?.length && loadTable.table) {
-    const filterSql = loadTable.sql.filter(el => el.inline ?? true);
-    const d = await Promise.all(filterSql.map(el => pg.query(`select  q.* from(select * from ${loadTable.table})t left join lateral(${el.sql})q on 1=1 limit 0`).then(el => el.fields)))
+  if (!checkInline[params?.table] && loadTable?.sql?.length && loadTable.table) {
+    const filterSql = loadTable.sql.filter(el => !el?.disabled && (el.inline ?? true));
+    const sqlTable = filterSql.map((el, i) => ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
+    const d = await Promise.all(filterSql.map((el, i) => pg.query(`select  ${el.name || `t${i}`}.* from(select * from ${loadTable.table})t ${sqlTable} limit 0`).then(el => el.fields)))
     d.forEach((el, i) => {
       filterSql[i].inline = el.length == 1 ? true : false;
       filterSql[i].fields = el.map(f => f.name);
@@ -45,9 +46,9 @@ export default async function dataAPI(req, reply, called) {
   } else if (checkInline[params?.table]) {
     loadTable.sql = checkInline[params?.table]
   }
-  if (query.sql == 2) {
-    return loadTable;
-  }
+
+  if (query.sql === '0') return loadTable;
+
   if (!loadTable && !(tokenData?.table && pg.pk?.[tokenData?.table])) { return { message: 'template not found', status: 404 }; }
 
   const id = tokenData?.id || hookData?.id || params?.id;
@@ -62,7 +63,7 @@ export default async function dataAPI(req, reply, called) {
   } = loadTable || tokenData;
 
   const tableMeta = await getMeta({ pg, table });
-
+  timeArr.push(Date.now())
   if (tableMeta?.view) {
     if (!loadTable?.key && !tokenData?.key) return { message: `key not found: ${table}`, status: 404 };
     Object.assign(tableMeta, { pk: loadTable?.key || tokenData?.key });
@@ -105,12 +106,13 @@ export default async function dataAPI(req, reply, called) {
     search: query.search,
     state: query.state,
     custom: query.custom,
+    uid,
     json: 1,
   }) : {};
-
+  timeArr.push(Date.now())
   const keyQuery = query.key && (loadTable?.key || tokenData?.key) && !(hookData?.id || tokenData?.id || params.id) ? `${loadTable?.key || tokenData?.key}=$1` : null;
 
-  const limit = Math.min(maxLimit, +(query.limit || 20));
+  const limit = called ? (query.limit || 20) : Math.min(maxLimit, +(query.limit || 20));
 
   const offset = query.page && query.page > 0 ? ` offset ${(query.page - 1) * limit}` : '';
   // id, query, filter
@@ -133,10 +135,9 @@ export default async function dataAPI(req, reply, called) {
   const q = `select  ${pk ? `"${pk}" as id,` : ''} 
                      ${params.id || query.key ? '*' : sqlColumns || cols || '*'} 
                      ${metaCols} 
-                     ${sql?.filter(el => el.inline).map(el => `,(${el.sql})`).join('') || ''}
                      
                      ${dbColumns.find((el) => el.name === 'geom' && pg.pgType?.[el.dataTypeID] === 'geometry') ? ',st_asgeojson(geom)::json as geom' : ''} 
-                     from (select * from ${table} where ${sqlTable ? 'true' : (where.join(' and ') || 'true')}  ) t 
+                     from (select * ${sql?.filter(el => el.inline).map(el => `,(${el.sql})`).join('') || ''} from ${table} t   ) t 
                      ${sqlTable} 
                      ${params.id ? cardSqlTable : ''} 
                      where ${where.join(' and ') || 'true'} 
@@ -149,6 +150,8 @@ export default async function dataAPI(req, reply, called) {
 
   const { rows = [] } = await pg.query(q, (tokenData?.id || hookData?.id || params.id ? [tokenData?.id || hookData?.id || params.id] : null) || (query.key && loadTable.key ? [query.key] : []));
 
+  timeArr.push(Date.now())
+
   if (uid && rows.length && editable) {
     rows.forEach(row => {
       row.token = setToken({
@@ -167,7 +170,7 @@ export default async function dataAPI(req, reply, called) {
             count(*)::int as total,  
             count(*) FILTER(WHERE ${filterWhere.join(' and ') || 'true'})::int as filtered
             ${aggregates.length ? `,${aggregates.map((el) => `${aggColumns[el.name]}(${el.name}) FILTER(WHERE ${filterWhere.join(' and ') || 'true'}) as ${el.name}`).join(',')}` : ''}
-            from ${table} t ${sqlTable} 
+            from (select * ${sql?.filter(el => el.inline).map(el => `,(${el.sql})`).join('') || ''} from ${table} t ${sqlTable})q 
             where ${[loadTable?.query, tokenData?.query, accessQuery].filter(el => el).join(' and ') || 'true'} `
     .replace(/{{uid}}/g, uid);
 
@@ -175,15 +178,16 @@ export default async function dataAPI(req, reply, called) {
 
   const counts = keyQuery || tokenData?.id || hookData?.id || params.id
     ? { total: rows.length, filtered: rows.length }
-    : await pg.queryCache?.(qCount, { table: loadTable?.table || tokenData?.table, time: 5 }).then(el => el?.rows[0] || {});
+    : await pg.queryCache?.(qCount, { table: loadTable?.table || tokenData?.table, time: 5 * 60 }).then(el => el?.rows[0] || {});
 
+  timeArr.push(Date.now())
   const { total, filtered } = counts || {};
   const agg = Object.keys(counts).filter(el => !['total', 'filtered'].includes(el)).reduce((acc, el) => ({ ...acc, [el]: counts[el] }), {});
 
   await extraDataGet({ rows, table: loadTable?.table, form }, pg);
 
   await metaFormat({ rows, table: tokenData?.table || hookData?.table || params.table }, pg);
-
+  timeArr.push(Date.now())
   const status = [];
   if (loadTable?.meta?.status) {
     const statusColumn = loadTable.meta?.cls?.[loadTable.meta?.status]
@@ -270,7 +274,15 @@ export default async function dataAPI(req, reply, called) {
   }
 
   const res = {
-    time: Date.now() - time,
+    time: {
+      total: Date.now() - time,
+      init: timeArr[1] - timeArr[0],
+      filter: timeArr[2] - timeArr[1],
+      data: timeArr[3] - timeArr[2],
+      count: timeArr[4] - timeArr[3],
+      format: timeArr[5] - timeArr[4],
+    },
+
     public: ispublic,
     tokens,
     card: loadTable?.card,

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

@@ -1,5 +1,7 @@
 import { logger, autoIndex, getSelect, getFilterSQL, getTemplate, getSelectVal, pgClients } from '../../../../utils.js';
 
+const checkInline = {};
+
 export default async function filterAPI(req) {
   const time = Date.now();
 
@@ -10,8 +12,22 @@ export default async function filterAPI(req) {
   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`);
+  // check sql inline fields count
+  if (!checkInline[params.table] && loadTable.sql?.length && loadTable.table) {
+    const filterSql = loadTable.sql.filter(el => el.inline ?? true);
+    const d = await Promise.all(filterSql.map(el => pg.query(`select  q.* from(select * from ${loadTable.table})t left join lateral(${el.sql})q on 1=1 limit 0`).then(el => el.fields)))
+    d.forEach((el, i) => {
+      filterSql[i].inline = el.length == 1 ? true : false;
+      filterSql[i].fields = el.map(f => f.name);
+    });
+    checkInline[params?.table] = loadTable.sql;
+  } else if (checkInline[params?.table]) {
+    loadTable.sql = checkInline[params?.table]
+  }
+
+  const sqlTable = false ? loadTable.sql?.filter?.((el) => !el.inline && !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 sqlInline = loadTable.sql?.filter?.(el => el.inline).map(el => `,(${el.sql})`).join('');
+  const { fields: columns = [] } = await pg.query(`select q.* from (select * ${sqlInline || ''} from ${loadTable.table} t ${sqlTable} limit 0)q`);
   const { fields = [] } = await pg.query(`select * from ${loadTable.table} t limit 0`);
 
   const {
@@ -20,13 +36,14 @@ export default async function filterAPI(req) {
 
   const { extra } = loadTable?.form ? await getTemplate('form', loadTable?.form) || {} : {};
 
-  const { optimizedSQL = `select * from ${loadTable.table}` } = loadTable?.sql || filter || custom || state || search || extra ? await getFilterSQL({
+  const { optimizedSQL = `select * ${sqlInline || ''} from ${loadTable.table}` } = loadTable?.sql || filter || custom || state || search || extra ? await getFilterSQL({
     pg,
     table: params.table,
     filter,
     custom,
     state,
     search,
+    uid: user?.uid,
   }) : {};
 
   const filters = (loadTable?.filter_list || loadTable?.filters || loadTable?.filterList || []).concat(loadTable?.filterSql || []);
@@ -47,8 +64,8 @@ export default async function filterAPI(req) {
   await Promise.all(filters.filter((el) => el.data && el.id && el.type !== 'Autocomplete').map(async (el) => {
     const cls = await getSelect(el.data, pg);
 
-    if (!cls || !loadTable.table) return;
     const { dataTypeID } = columns.find((item) => item.name === el.id) || {};
+    if (!cls || !loadTable.table || !dataTypeID) return;
 
     if (el.extra && el.type === 'select' && Array.isArray(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, params.table]);