@opengis/fastify-table 1.4.88 → 1.5.1

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

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

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

@@ -1,42 +0,0 @@
-import { applyHook, getTemplate } from '../../../../utils.js';
-
-const sql = `select property_key as key, property_json as json, property_int as int,
-property_text as text from admin.properties where 1=1`;
-
-async function getSettings({ pg }) {
-  const { rows = [] } = await pg.query(sql);
-  const data = rows.reduce((acc, curr) => Object.assign(acc, { [curr.key]: curr.json || curr.int || curr.text }), {});
-  return data;
-}
-
-export default async function formFunction(req) {
-  const time = Date.now();
-
-  const { pg, params, user } = req;
-  const hookData = await applyHook('preForm', { form: params?.name, user });
-
-  if (hookData?.message && hookData?.status) {
-    return { message: hookData?.message, status: hookData?.status };
-  }
-
-  const form = await getTemplate('form', hookData?.form || params?.name);
-  if (!form) { return { status: 404, message: 'not found' }; }
-
-  // replace settings
-  const arr = JSON.stringify(form).match(/{{settings.([^}]*)}}/g);
-  if (arr?.length) {
-    const string = JSON.stringify(form);
-    const settings = await getSettings({ pg });
-    const match = arr.reduce((acc, curr) => Object.assign(acc, { [curr]: settings[curr.replace(/^{{settings./g, '').replace(/}}$/, '')] }), {});
-    const res = Object.keys(match).reduce((s, m) => s.replace(m, match[m]), string);
-    return { time: Date.now() - time, form: JSON.parse(res) };
-  }
-
-  const res = { time: Date.now() - time, form };
-  const res1 = await applyHook('afterForm', {
-    form: hookData?.form || params?.name,
-    payload: res,
-    user,
-  });
-  return res1 || { time: Date.now() - time, form };
-}

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

@@ -1,74 +0,0 @@
-import {
-  getMeta, metaFormat, getTemplates, getTemplate, handlebars,
-} from '../../../../utils.js';
-
-function sequence(tables, data, fn) {
-  return tables.reduce((promise, table) => promise.then(() => fn({
-    ...data, tableName: table.replace('.json', ''),
-  })), Promise.resolve());
-}
-
-async function getData({
-  pg, tableName, query = {}, maxLimit, res,
-}) {
-  const loadTable = await getTemplate('table', tableName);
-
-  if (!loadTable) { return { message: 'not found', status: 404 }; }
-
-  const {
-    table, columns, meta,
-  } = loadTable;
-
-  const { pk } = await getMeta(table);
-
-  const cols = columns.map((el) => el.name || el).join(',');
-  const [orderColumn, orderDir] = (query.order || loadTable.order || '').split('-');
-  const order = cols.includes(orderColumn) && orderColumn?.length ? `order by ${orderColumn} ${query.desc || orderDir === 'desc' ? 'desc' : ''}` : '';
-
-  const limit = Math.max(maxLimit - res.rows.length, 0);
-  // Math.max(query.offset - res.rows.length,0)
-  const offset = query.page && query.page > 0 ? ` offset ${(query.page - 1) * limit}` : '';
-
-  const search1 = meta?.search && query.key ? `(${meta?.search.concat(meta?.title ? `,${meta?.title}` : '').split(',').map(el => `${el} ilike '%${query.key}%'`).join(' or ')})` : 'false';
-
-  const where = [!pk ? 'false' : 'true', loadTable.query, search1].filter((el) => el);
-  const q = `select ${[`"${pk}" as id`, meta?.title ? `${meta.title} as title` : ''].filter((el) => el).join(',')} from ${table} t where ${where.join(' and ') || 'true'} ${order} ${offset} limit ${limit}`;
-  if (query.sql) {
-    res.sql.push(q);
-    return null;
-  }
-
-  const { rows } = await pg.query(q);
-
-  const total = await pg.queryCache(`select count(*) from ${table} t where ${where.join(' and ') || 'true'}`).then((el) => el?.rows[0]?.count) || 0;
-
-  await metaFormat({ rows, table: tableName });
-  res.total += +total;
-  rows.forEach((row) => {
-    const href = meta?.href ? handlebars.compile(meta.href)({ ...row, [pk]: row.id }) : undefined;
-    res.rows.push({
-      ...row, register: tableName, register_title: loadTable.ua, href,
-    });
-  });
-  return null;
-}
-
-export default async function search({
-  pg, funcs, query = {},
-}) {
-  const time = Date.now();
-
-  const tables = query.table ? [query.table] : await getTemplates('table');
-  const res = { rows: [], sql: [], total: 0 };
-
-  const maxLimit = Math.min(100, query.limit || '16');
-  await sequence(tables, {
-    pg, funcs, query, maxLimit, res,
-  }, getData);
-
-  if (query.sql) return res.sql.join(';\n');
-
-  return {
-    time: Date.now() - time, total: res.total, count: res.rows.length, rows: res.rows,
-  };
-}

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

@@ -1,246 +0,0 @@
-import path from 'node:path';
-import { existsSync, readFileSync } from 'node:fs';
-
-import {
-  config, getPG, getTemplate, getSelectMeta, getMeta, applyHook, getSelectVal, logger, getSelect,
-} from '../../../../utils.js';
-
-const limit = 50;
-const headers = {
-  'Access-Control-Allow-Origin': '*',
-  'Access-Control-Allow-Methods': 'GET',
-  'Cache-Control': 'no-cache',
-};
-
-async function getTableColumnMeta(tableName, column, filtered, pg) {
-  if (!tableName || !column) { return null; }
-
-  const loadTable = await getTemplate('table', tableName);
-  const { data: clsName } = loadTable?.columns?.find?.(el => el.name === column) || {};
-  const { arr } = await getSelect(clsName, pg) || {};
-
-  const original = {
-    true: `with c(id,text) as (select ${column} as id, ${column} as text from ${loadTable?.table || tableName} group by ${column}) select id, text from c`,
-    false: `with c(id,text) as (select ${column}  as id, ${column} as text, count(*) from ${loadTable?.table || tableName} group by ${column} limit ${limit}) select * from c`,
-  }[!!filtered];
-  return {
-    arr,
-    original,
-    searchQuery: '(lower("text") ~ $1 )',
-    pk: 'id',
-  };
-}
-
-export default async function suggest(req) {
-  const {
-    params, query, pg: pg1, user,
-  } = req;
-
-  const lang = query.lang || 'ua';
-  const time = Date.now();
-  const parent = query.parent || '';
-
-  if (params?.data && params.data?.startsWith?.('hash-')) {
-    const filepath = path.join(process.cwd(), `/log/suggest/${params.data.replace('hash-', '')}.json`);
-    if (existsSync(filepath)) {
-      const { table, column } = JSON.parse(readFileSync(filepath, { encoding: 'utf8' }) || '{}');
-      params.data = `${table}:${column}`;
-    }
-  }
-
-  const [table, column] = params.data?.includes(':') ? params.data.split(':') : [query.token, query.column];
-  const selectName = query.sel || query.name || params.data;
-
-  if (!selectName) return { status: 400, message: 'name is required' };
-
-  const { body: hookBody } = table || query.token ? await applyHook('preSuggest', { pg: pg1, table: table || query.token }) || {} : {};
-  const body = await getTemplate('table', table || query.token);
-  const tableName = hookBody?.table || body?.table || table || query.token;
-
-  if (table && !pg1.pk?.[tableName]) {
-    return { status: 400, message: 'param name is invalid: 1' };
-  }
-
-  const tableMeta = await getMeta({ pg: pg1, table: tableName });
-  const columnExists = (hookBody?.columns || body?.columns || tableMeta?.columns)?.find(col => col?.name === (column || query.column));
-
-  if (table && (!column || !columnExists)) {
-    return { status: 400, message: 'param name is invalid: 2' };
-  }
-
-  if (query.limit && query.limit < 0) {
-    return { status: 400, message: 'param limit is invalid' };
-  }
-
-  const meta = tableName && column
-    ? await getTableColumnMeta(table, column, query?.key || query?.val, pg1)
-    : await getSelectMeta({
-      pg: pg1, name: selectName, nocache: query?.nocache, parent,
-    });
-
-  if (meta?.minLength && query.key && query.key.length < meta?.minLength) {
-    return { message: `min length: ${meta.minLength}` };
-  }
-
-  const pg = meta?.db ? getPG(meta.db) : pg1;
-
-  if (!meta) {
-    return { headers, status: 404, message: 'Not found query select ' };
-  }
-
-  if (query.meta) {
-    return meta;
-  }
-
-  const { arr, searchQuery } = meta;
-
-  if (arr && query.token && query.column) {
-    const loadTable = await getTemplate('table', query.token);
-
-    const { columns = [] } = await getMeta({ pg, table: loadTable?.table || tableName });
-
-    const column1 = columns.find(el => el.name === query.column);
-    const args = { table: tableName };
-    if (!column1) return [];
-    const sqlCls = query.count
-    ? `select value, count(*) from (select ${pg.pgType?.[column1.dataTypeID]?.includes('[]') ? `unnest(${column1.name})` : `${column1.name}`} as value from ${(loadTable?.table || tableName).replace(/'/g, "''")} where ${hookBody?.query || loadTable?.query || '1=1'})q group by value`
-    : `select array_agg(distinct value)::text[] from (select ${pg.pgType?.[column1.dataTypeID]?.includes('[]') ? `unnest(${column1.name})` : `${column1.name}`} as value from ${(loadTable?.table || tableName).replace(/'/g, "''")} where ${hookBody?.query || loadTable?.query || '1=1'})q`;
-
-    if (query.sql && (config.local || user?.user_type?.includes?.('admin'))) {
-      return sqlCls;
-    }
-
-    if (pg.pk?.[loadTable?.table || tableName] && column1?.name) {
-      const qRes = await pg.queryCache(sqlCls, args);
-      const vals = (query.count ? qRes.rows?.map?.(el => el.value?.toString?.()) : qRes.rows?.[0]?.array_agg) || [];
-
-      const lower = query.key?.toLowerCase?.();
-      const data1 = query.key || query.val
-        ? arr?.filter((el) => !lower || (el[lang] || el.text)?.toLowerCase()?.indexOf(lower) !== -1)?.filter((el) => !query.val || el.id === query.val)
-        : arr;
-
-      const data2 = data1.filter((el) => el.id && vals.includes(el.id.toString()));
-      const data = data2.slice(0, Math.min(query.limit || limit, limit));
-
-      if (data.length && query.count) {
-        const counts = qRes.rows?.reduce?.((acc, curr) => ({ ...acc, [curr.value]: curr.count }), {});
-        data.forEach(el => Object.assign(el, { count: counts?.[el.id] || 0 }));
-      }
-
-      if (config.debug) {
-        logger.file('suggest/debug', {
-          type: 1,
-          loadTable: loadTable?.table,
-          tableName,
-          column: column?.name,
-          data,
-          data1,
-          data2,
-          query,
-        });
-      }
-
-      return {
-        time: Date.now() - time,
-        limit: Math.min(query.limit || limit, limit),
-        count: data.length,
-        total: arr.length,
-        mode: 'array',
-        sql: (config.local || user?.user_type?.includes?.('admin')) ? sqlCls : undefined,
-        data,
-      };
-    }
-  }
-
-  if (arr) {
-    const lower = query.key?.toLowerCase();
-    const data1 = query.key || query.val
-      ? arr?.filter((el) => !lower || (el[lang] || el.text)?.toLowerCase()?.indexOf(lower) !== -1)?.filter((el) => !query.val || el.id === query.val)
-      : arr;
-    const data = data1.slice(0, Math.min(query.limit || limit, limit));
-
-    if (config.debug) {
-      logger.file('suggest/debug', {
-        type: 2,
-        key: query.key,
-        data,
-        data1,
-      });
-    }
-
-    return {
-      time: Date.now() - time,
-      limit: Math.min(query.limit || limit, limit),
-      count: data.length,
-      total: arr.length,
-      mode: 'array',
-      data,
-    };
-  }
-
-  // search
-  const search = query.key ? searchQuery : null;
-
-  // val
-  // const pk = meta.originalCols.split(',')[0];
-  // return meta;
-
-  const val = query.val ? ` ${meta.pk}=any('{${query.val.replace(/'/g, "''")}}')` : '';
-  const where = [search, val, meta.pk ? `${meta.pk} is not null` : null].filter((el) => el).join(' and ') || 'true';
-
-  const loadTable = await getTemplate('table', query.token);
-
-  const tableName1 = hookBody?.table || loadTable?.table || query.token;
-
-  const { columns = [] } = await getMeta({ pg: pg1, table: tableName1 });
-
-  const { name: filterColumn, dataTypeID } = query.column ? (columns.find(el => el.name === query.column) || {}) : {};
-  const filter = query.token && pg.pk?.[loadTable?.table || query.token] && filterColumn && dataTypeID
-    ? `id in (select ${pg.pgType[dataTypeID]?.includes('[]') ? `unnest(${filterColumn})` : filterColumn} from ${(loadTable?.table || query.token).replace(/'/g, "''")})`
-    : 'true';
-
-  const sqlSuggest = `with c(id,text) as ( ${meta.original.replace(/{{parent}}/gi, parent)} where ${where} order by 2) select * from c where ${filter} limit ${Math.min(query.limit || meta.limit || limit, limit)}`.replace(/{{uid}}/g, user?.uid || '0');
-
-  if (query.sql && (config.local || user?.user_type?.includes?.('admin'))) {
-    return sqlSuggest;
-  }
-
-  // query
-  const { rows: dataNew } = await pg.query(sqlSuggest, query.key ? [`${query.key.toLowerCase()}`] : []);
-  // const { rows: dataNew1 } = dataNew.length < limit ? await pg.query(sqlSuggest, query.key ? [`${query.key}`] : []) : {};
-  // const ids = dataNew.map((el) => el.id);
-  const data = dataNew.filter(el => el.id && el.text);
-
-  if (query.sel) {
-    const clsData = await getSelectVal({
-      pg,
-      name: query.sel,
-      values: data.map((el) => el.id),
-    });
-    data.forEach(el => Object.assign(el, { text: clsData?.[el.id || ''] || el.id }));
-  }
-
-  if (config.debug) {
-    logger.file('suggest/debug', {
-      type: 3,
-      sel: query.sel,
-      data,
-      dataNew,
-      sqlSuggest,
-      // ids,
-    });
-  }
-
-  const message = {
-    time: Date.now() - time,
-    limit: Math.min(query.limit || meta.limit || limit, limit),
-    count: data.length,
-    total: meta.count - 0,
-    mode: 'sql',
-    db: meta.db,
-    sql: (config.local || user?.user_type?.includes?.('admin')) ? sqlSuggest : undefined,
-    data,
-  };
-
-  return message;
-}

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

@@ -1,62 +0,0 @@
-import getToken from '../../../plugins/crud/funcs/getToken.js';
-import getOpt from '../../../plugins/crud/funcs/getOpt.js';
-import getTemplate from '../../../plugins/table/funcs/getTemplate.js';
-import getMeta from '../../../plugins/pg/funcs/getMeta.js';
-import pgClients from '../../../plugins/pg/pgClients.js';
-
-import getData from '../functions/getData.js';
-
-export default async function getTableData(req, reply, called) {
-    const {
-        user = {}, params = {}, headers = {}, query = {}, pg = pgClients.client, contextQuery: contextQuery1, sufix = true, filterList,
-    } = req;
-
-    const { id } = params || {};
-
-    const tokenData1 = await getOpt(params.table, user?.uid);
-    const tokenData2 = await getToken({
-        uid: user?.uid, token: params.table, json: true,
-    });
-    const tokenData = tokenData1 || tokenData2;
-
-    if (tokenData?.table) {
-        const loadTable = await getTemplate('table', tokenData.table);
-
-        if (!loadTable) {
-            const { rows = [], fields = [] } = await pg.query(`select ${tokenData.columns || '*'} from ${tokenData.table} where ${tokenData.query || 'true'} limit 10`);
-            const meta = await getMeta({ pg, table: tokenData.table });
-            const columns = (meta?.columns || fields).map(el => ({ name: el.name, type: pg.pgType?.[el.dataTypeID], title: el.title }));
-            return { rows, columns };
-        }
-
-        const resp = await getData({
-            pg, params: { id, table: tokenData.table }, headers, query, user, contextQuery: [contextQuery1, tokenData.query].filter(Boolean).join(' and '), sufix, filterList, actions: tokenData1?.actions,
-        }, reply, called);
-        if (resp?.addToken && tokenData.obj) { Object.assign(resp, { addToken: params.table }); }
-        return resp;
-    }
-
-    // Це можна 1 раз на старті
-    const interfaceName = req.headers?.referer?.match(/.*\/([^?]+)/)?.[1];
-    const { query: interfaceQuery } = interfaceName && pg?.pk
-        ? await pg.query('select query from admin.routes where route_id=$1', [interfaceName])
-            .then(el => el.rows?.[0] || {}) : {};
-
-    // це можна від користувача
-    const q = `select attr,
-    (select rule_values from admin.account_grants where account_id in (select account_id from admin.account_users where user_uid=$2) and rule_id=r.rule_id limit 1) 
-    from admin.rules r where (select route_id from admin.routes where $1 in (alias,table_name)) = any(routes)`;
-    const { rows = [] } = pg?.pk?.['admin.rules'] ? await pg.query(q, [params.table, user.uid]) : {};
-
-    const context = rows.filter(el => el.rule_values).map(el => `${el.attr} = any ('{${el.rule_values}}')`).join(' and ');
-    const contextQuery = [contextQuery1, interfaceQuery, context].filter(Boolean).join(' and ') || ' 2=2 ';
-
-    const res = await getData({
-        pg, params, query, headers, user, contextQuery, sufix, filterList, actions: tokenData1?.actions,
-    }, reply, called);
-    const route = pg.tlist?.includes('admin.routes') ? await pg.query('select route_id as path, title from admin.routes where enabled and alias=$1 limit 1', [params.table])
-        .then(el => el.rows?.[0] || {}) : {};
-
-    if (typeof res === 'string') return res;
-    return { route, ...res };
-}