@opengis/fastify-table 1.2.73 → 1.2.74

package/package.json

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

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

@@ -11,11 +11,11 @@ const checkInline = {};
 const defaultTable = 'crm.extra_data';
 
 function getExtraQuery(mainColumns, schema, table, pk) {
-  const extraKeys = Object.keys(schema || {}).filter(key => !mainColumns.map(el => el?.name).includes(key));
+  const extraColumns = Object.keys(schema || {}).filter(key => !mainColumns.map(el => el?.name).includes(key)).map(key => ({ name: key, type: schema[key]?.type }));
 
   return {
-    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,
+    q: extraColumns.map((el) => `,(select value_text as "${el.name.replace(/'/g, "''")}" from ${table} where property_key='${el.name.replace(/'/g, "''")}' and object_id=t.${pk} limit 1)`).join(' '),
+    extraColumns,
   };
 }
 
@@ -37,7 +37,7 @@ export default async function getFilterSQL({
     : undefined;
 
   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]
+  const { q: extraSqlColumns, extraColumns = [] } = pg.pk?.[extraDataTable] && pg.pk?.[body.table || table]
     ? getExtraQuery(fieldsModel, loadTemplate?.schema, extraDataTable, pg.pk[body.table || table])
     : {};
 
@@ -66,7 +66,7 @@ export default async function getFilterSQL({
   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 { fields = [] } = await pg.query(fieldQuery);
   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);
@@ -92,8 +92,8 @@ export default async function getFilterSQL({
     )?.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.name && extraColumns.find(item => item?.name === el?.name)) {
+        Object.assign(el, { extra: { table: extraDataTable, input: extraColumns.find(item => item?.name === el?.name)?.type } });
       }
       if (!el?.data) return el;
       const cls = await getTemplate(['cls', 'select'], el.data);
@@ -139,7 +139,6 @@ export default async function getFilterSQL({
       optimizedSQL,
       sqlTable,
       extraSqlColumns,
-      extraKeys,
       tableCount,
       table: modelQuery,
       // filter parts

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

@@ -1,199 +1,110 @@
-const dateTypeList = ['date', 'timestamp', 'timestamp without time zone', 'timestamp with time zone'];
-const numberTypeList = ['float8', 'int4', 'int8', 'numeric', 'double precision', 'integer'];
+import getRangeQuery from "./getRangeQuery.js";
 
-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';
-};
-
-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,
-  m: new Date().getMonth(),
-  q: (new Date().getMonth() / 4).toFixed() * 3,
-  y: new Date().getFullYear(),
-};
-
-function formatDateISOString(date) {
-  if (!date?.includes('.')) return date;
-  const [day, month, year] = date.split('.');
-  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,
+export default function formatValue({
+  pg, table, filter = {}, name, value, dataTypeID, uid = 1, optimize,
 }) {
-  const { extra, sql, select } = filter;
+  const { extra, sql, select, strict } = filter;
   const pk = pg?.pk && table ? pg.pk[table] : undefined;
 
-  if (!dataTypeID && !extra) return {};
-
   const filterType = filter.type?.toLowerCase() || 'text';
-  const fieldType = pg.pgType?.[dataTypeID] || pg.pgType?.[{ date: 1114 }[filterType] || 25];
+  const fieldType = pg?.pgType?.[dataTypeID] || pg?.pgType?.[{ date: 1114 }[filterType] || 25];
 
-  if (!name || !value || !fieldType) return {};
-
-  // Date filter
-  if (['date', 'datepicker'].includes(filterType) /* && 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' };
-    }
+  if (!name
+    || !value
+    || !dataTypeID && !extra && !sql || extra?.input?.toLowerCase?.() === 'datatable') {
+    return {};
+  }
 
-    // with sql subquery
-    if (sql) {
-      return { op: '=', query: sql.replace(/\$1/g, `'${min}'::date`).replace(/\$2/g, `'${max}'::date`) };
-    }
+  // my rows
+  if (value === 'me' && uid) {
+    return { op: '=', query: `${name}::text = '${uid}'` };
+  }
 
-    // preset values
-    if (['cw', 'cm', 'cq', 'cy'].includes(value)) {
-      return { op: 'between', query: `${name}::date between '${min}'::date and '${max}'::date` };
-    }
+  const matchNull = { null: 'is null', notnull: 'is not null' }[value];
+  // null = true is null, not false
+  const matchBoolean = fieldType === 'boolean' ? { true: 'is true', false: 'is false' }[value] : null;
+  const matchMulti = fieldType.includes('[]') ? `::text[] && '{${value}}'::text[]` : null;
+  const match = matchNull || matchBoolean || matchMulti || `::text=any('{${value}}'::text[])`;
 
-    // preset values: current day
-    if (value === 'cd') {
-      return { op: '=', query: `${name}::date = '${min}'::date` };
+  // geometry
+  if (['geometry'].includes(fieldType)) {
+    if (matchNull) {
+      return { op: 'nullable', query: `${name} ${matchNull}` };
     }
 
-    // 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 };
-    }
+    const bbox = value[0].split('_');
 
-    // same date
-    if (max && min && min === max) {
-      return { op: 'strict', query: `${name}::date = '${min}'::date` };
+    if (bbox?.length !== 4) {
+      return {};
     }
 
-    // default
-    return { op: 'between', query: `${name}::date between '${min}'::date and '${max}'::date` };
+    const query = ` ${name} && 'box(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d `;
+    return { op: '&&', query };
   }
 
-  // Range filter, example: 100-500
-  if (filterType === 'range' /* && numberTypeList.includes(fieldType) */) {
-    const [min, max] = value?.indexOf('_') !== -1 ? value.split('_') : value.split('-');
+  const querysql = sql?.replace?.(/= ?any\(\$1\)/g, `::text=any('{ ${value} }'::text[])`)?.replace?.(/\$1/g, `'${value}'`);
+  const op = filterType === 'text' && !strict ? '~' : '=';
 
+  // text
+  if (['text'].includes(filterType)) {
     // with sql subquery
     if (sql) {
-      return { op: '=', query: sql.replace(/\$1/g, min).replace(/\$2/g, max) };
+      return { op: '=', query: querysql };
     }
 
-    if (min === 'min' && max === 'max') {
-      return { op: 'between', query: 'false' };
+    // extra table, example: crm.extra_data
+    if (extra?.table && pk) {
+      const query = `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_text ${matchNull || `${op} '${value}'`} )`;
+      return { op, query };
     }
 
-    // default
-    const query = (max === 'max' ? `${name} > ${min}` : null) || (min === 'min' ? `${name} < ${max}` : null) || `${name} between ${min} and ${max}`;
-    return { op: 'between', query };
-  }
+    // select / cls
+    if (select) {
+      const subquery = matchNull ? `name ${matchNull}` : `lower(name::text) ~ lower('${value}')`;
+      return {
+        op,
+        query: `${name}::text in ( ( with q(id,name) as (${select}) select id from q where ${subquery}) )`,
+      };
+    }
 
-  // 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 };
+    // nullable
+    if (matchNull) {
+      const query = `${name} ${matchNull}`;
+      return { op, query };
     }
 
     // default
-    const query = sql.replace(/\$1/g, `'${value}'`);
-    return { op: '=', query };
-  }
+    const query = `lower(${name}::text) ${op} lower('${value}')`;
 
-  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}%'`);
+    return { op, query };
+  }
 
-  const formatType = {
-    float8: 'numeric',
-    numeric: 'numeric',
-    int4: 'numeric',
-    integer: 'integer',
-    int8: 'numeric',
-    "double precision": 'double precision',
-    varchar: 'text',
-    "character varying": 'character varying',
-    bool: 'boolean',
-    boolean: 'boolean',
-    geometry: 'geom',
-  }[fieldType] || 'text';
+  // date: 01.01.2024-31.12.2024 / number range: 100-500
+  if (['date', 'datepicker', 'range'].includes(filterType)) {
+    const query = getRangeQuery(value, name, fieldType, filterType, sql, extra, pk);
+    return { op: 'between', query };
+  }
 
   /* select query - from admin.cls / filter options */
   if (['check', 'autocomplete', 'text', 'tags', 'avatar', 'radio'].includes(filterType)) {
+    // with sql subquery
+    if (sql) {
+      return { op: '=', query: querysql };
+    }
 
     // extra table, example: crm.extra_data
     if (extra?.table && pk) {
-      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 };
-    }
-
-    // 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}::${formatType} ${match}`; // simple filter
-    return { op: operator, query };
-  }
-
-  // my rows
-  if (value === 'me' && uid) {
-    if (sql) {
-      return { op: '=', query: sql.replace(/\$1/g, `'${uid}'`) };
+      const query = `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_text ${matchNull || `='${value}'`} )`;
+      return { op: '=', query };
     }
 
-    const query = extra?.table && pk && fieldType === 'text'
-      ? `${pk} in (select ${pk} from ${extra.table} where uid = '${uid}')`
-      : `${name}::text = '${uid}'`;
+    // nullable + default
+    const query = `${name} ${match}`;
     return { op: '=', query };
   }
 
-  // sql column?
-  if (optimize && optimize.name !== optimize.pk) {
+  // sql column
+  if (optimize && optimize.name !== optimize.pk && false) {
     const val = filterType === 'text' ? `ilike '%${value}%'` : `= any('{${value}}')`;
     return {
       op: '~',
@@ -204,60 +115,5 @@ function formatValue({
     };
   }
 
-  // filter text array column
-  if (fieldType?.includes('[]')) {
-    return { op: 'in', query: `'{${value}}'::text[] && ${name}::text[]` };
-  }
-
-  // filter multiple values, example: 1,2,3
-  if (value?.indexOf(',') !== -1) {
-    const values = value.split(',').filter((el) => el !== 'null');
-
-    // extra table, example: crm.extra_data
-    if (extra?.table && 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 };
-    }
-
-    // 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 };
-  }
-
-  if (['<', '>'].includes(operator)) {
-    const query = `${name} ${operator} '${value}'::${formatType}`;
-    return { op: operator, query };
-  }
-
-  if (operator === '=' && filterType !== 'text' && !filter?.data) {
-    const query = {
-      null: `${name} is null`,
-      notnull: `${name} is not null`,
-    }[value] || `${name}::${formatType}='${value}'::${formatType}`;
-    return { op: '=', query };
-  }
-
-  // json
-  if (name.includes('.')) {
-    const [col, prop] = name.split('.');
-    const query = ` ${col}->>'${prop}' in ('${value.join("','")}')`;
-    return { op: 'in', query };
-  }
-
-  // geometry
-  if (['geometry'].includes(fieldType)) {
-    const bbox = value[0].split('_');
-
-    if (bbox?.length === 4) {
-      const query = ` ${name} && 'box(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d `;
-      return { op: '&&', query };
-    }
-  }
   return {};
 }
-
-export default formatValue;

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

@@ -32,7 +32,6 @@ function getQuery({
     // filter
     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.split(splitby)?.[0] === name).map((el) => el.substring(name.length + 1)).join(',');
@@ -40,7 +39,9 @@ function getQuery({
     const optimize = fields?.find((el) => el.name === name) ? null : tableSQL.find((el) => el.name === name);
 
     // find field and skip not exists
-    const { dataTypeID } = fields?.find((el) => el.name === name) || fields?.find((el) => el.name === optimize?.pk) || {};
+    const { dataTypeID } = fields?.find((el) => el.name === name)
+      || fields?.find((el) => el.name === optimize?.pk)
+      || {};
 
     // format query
     const {
@@ -49,12 +50,11 @@ function getQuery({
       pg,
       table,
       filter,
-      optimize,
       name,
       value,
-      operator,
       dataTypeID,
       uid,
+      optimize,
     }) || {};
     if (!query) continue;
 

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

@@ -0,0 +1,154 @@
+const dateTypeList = ['date', 'timestamp', 'timestamp without time zone', 'timestamp with time zone'];
+const numberTypeList = ['float8', 'int4', 'int8', 'numeric', 'double precision', 'integer', 'bigint'];
+
+const isValidDate = (dateStr) => {
+    if (!dateStr) return false;
+    if (['min', 'max'].includes(dateStr)) return true;
+    // 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';
+};
+
+const isValidNumber = (numStr) => ['min', 'max'].includes(numStr) ? true : !isNaN(numStr);
+
+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,
+    m: new Date().getMonth(),
+    q: (new Date().getMonth() / 4).toFixed() * 3,
+    y: new Date().getFullYear(),
+};
+
+function formatDateISOString(date) {
+    if (!date?.includes('.')) return date;
+    const [day, month, year] = date.split('.');
+    return `${year}-${month}-${day}`;
+}
+
+function getRangeValues(value = '', filterType = 'range') {
+    if (['range'].includes(filterType)) {
+        return value?.indexOf('_') !== -1
+            ? value.split('_')
+            : value.split('-');
+    }
+
+    // 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 = startDate === 'min' ? startDate : formatDateISOString(startDate);
+    const max = endDate === 'max' ? endDate : formatDateISOString(endDate);
+    return [min, max];
+}
+
+function checkValid(value, fieldType, filterType, sql, extra) {
+    const [min, max] = getRangeValues(value, filterType);
+
+    if (['date', 'datepicker'].includes(filterType)) {
+        const isvalid = (dateTypeList.includes(fieldType) || sql || extra) && (isValidDate(min) && (isValidDate(max) || value === 'cd'));
+        return { min, max, isvalid };
+    }
+
+    if (['range'].includes(filterType)) {
+        const isvalid = (numberTypeList.includes(fieldType) || sql || extra) && isValidNumber(min) && isValidNumber(max);
+        return { min, max, isvalid };
+    }
+
+    return { isvalid: false };
+}
+
+export default function getRangeQuery(value, name, fieldType, filterType, sql, extra, pk) {
+    const { min, max, isvalid } = checkValid(value, fieldType, filterType, sql, extra);
+    if (!isvalid) return 'false';
+
+    // with sql subquery
+    if (['date', 'datepicker'].includes(filterType) && sql) {
+        return sql.replace(/\$1/g, `'${min}'::date`).replace(/\$2/g, `'${max}'::date`);
+    }
+
+    // with sql subquery
+    if (['range'].includes(filterType) && sql) {
+        return sql.replace(/\$1/g, min).replace(/\$2/g, max);
+    }
+
+    // preset date values
+    if (['date', 'datepicker'].includes(filterType) && ['cd', 'cw', 'cm', 'cq', 'cy'].includes(value)) {
+        return value === 'cd'
+            ? `${name}::date = '${min}'::date`
+            : `${name}::date between '${min}'::date and '${max}'::date`;
+    }
+
+    // extra columns, example: crm.extra_data
+    if (['date', 'datepicker'].includes(filterType) && extra?.table && pk) {
+        const subquery = (max && min && min === max ? `value_date = '${value}'::date` : null)
+            || (max === 'max' ? `value_date::date > '${min}'::date` : null)
+            || (min === 'min' ? `value_date::date < '${max}'::date` : null)
+            || `value_date::date between '${min}'::date and '${max}'::date`;
+        const query = `${pk} in (select object_id from ${extra.table} where property_key='${name}' and ${subquery})`;
+        return query;
+    }
+
+    // extra columns, example: crm.extra_data
+    if (['range'].includes(filterType) && extra?.table && pk) {
+        const subquery = (max && min && min === max ? `value_text = '${value}'` : null)
+            || (max === 'max' ? `value_text::numeric > ${min}` : null)
+            || (min === 'min' ? `value_text::numeric < ${max}` : null)
+            || `value_text::numeric between ${min} and ${max}`;
+        const query = `${pk} in (select object_id from ${extra.table} where property_key='${name}' and ${subquery} )`;
+        return query;
+    }
+
+    // same date
+    if (['date', 'datepicker'].includes(filterType) && max && min && min === max) {
+        return `${name}::date = '${min}'::date`;
+    }
+
+    // skip, same as 1=1
+    if (['range'].includes(filterType) && min === 'min' && max === 'max') {
+        return 'true';
+    }
+
+    // default
+    if (max === 'max') {
+        return ['date', 'datepicker'].includes(filterType)
+            ? `${name} > '${min}'::date`
+            : `${name} > ${min}`;
+    }
+
+    if (min === 'min') {
+        return ['date', 'datepicker'].includes(filterType)
+            ? `${name} < '${max}'::date`
+            : `${name} < ${max}`;
+    }
+
+    if (['date', 'datepicker'].includes(filterType)) {
+        return `${name}::date between '${min}'::date and '${max}'::date`;
+    }
+
+    return `${name} between ${min} and ${max}`;
+}

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

@@ -1,10 +1,10 @@
-import { logger, autoIndex, getSelect, getFilterSQL, 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();
 
   const {
-    params, query = {}, pg = pgClients.client, user = {},
+    params, pg = pgClients.client, user = {},
   } = req;
 
   const loadTable = await getTemplate('table', params.table);
@@ -14,20 +14,7 @@ export default async function filterAPI(req) {
   const { fields: columns = [] } = await pg.query(`select * from ${loadTable.table} t ${sqlTable} limit 0`);
   const { fields = [] } = await pg.query(`select * from ${loadTable.table} t limit 0`);
 
-  const {
-    filter, custom, state, search,
-  } = query;
-
-  // const { extra } = loadTable?.form ? await getTemplate('form', loadTable?.form) || {} : {};
-
-  const { optimizedSQL = `select * from ${loadTable.table}` } = false ? await getFilterSQL({
-    pg,
-    table: params.table,
-    filter,
-    custom,
-    state,
-    search,
-  }) : {};
+  const optimizedSQL = `select * from ${loadTable.table} t ${sqlTable}`;
 
   const filters = (loadTable?.filter_list || loadTable?.filters || loadTable?.filterList || []).concat(loadTable?.filterSql || []);
 
@@ -42,7 +29,10 @@ export default async function filterAPI(req) {
       logger.file('autoindex/error', { name: params?.table, error: err.toString(), stack: err.stack });
     });
 
-  filters?.forEach?.(el => Object.assign(el, { id: el.id || el.name }));
+  const loadTemplate = loadTable?.form ? await getTemplate('form', loadTable.form) : {};
+  const extraColumns = loadTemplate?.extra ? Object.keys(loadTemplate?.schema || {}).filter(key => !columns.find(col => col.name === key)) : [];
+
+  filters?.forEach?.(el => Object.assign(el, { id: el.id || el.name, extra: extraColumns.includes(el.id || el.name) }));
 
   await Promise.all(filters.filter((el) => el.data && el.id && el.type !== 'Autocomplete').map(async (el) => {
     const cls = await getSelect(el.data, pg);
@@ -50,13 +40,14 @@ export default async function filterAPI(req) {
     if (!cls || !loadTable.table) return;
     const { dataTypeID } = columns.find((item) => item.name === el.id) || {};
 
-    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]);
+    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 options = countArr.rows.map(cel => {
-        const data = cls.find(c => c.id === cel.id);
+        const data = (cls?.arr || cls).find(c => c.id === cel.id);
         return { ...cel, ...data };
       });
       Object.assign(el, { options });
+      return;
     }
 
     const q = pg.pgType[dataTypeID]?.includes('[]')
@@ -64,6 +55,7 @@ export default async function filterAPI(req) {
       : `select ${el.id}::text as id,count(*) from (${optimizedSQL})q group by ${el.id} limit 100`;
 
     const countArr = await pg.queryCache(q, { table: loadTable.table });
+
     if (countArr.timeout) {
       Object.assign(el, { timeout: countArr.timeout });
       console.log('timeout filter', params.table, el.id);