@opengis/fastify-table 1.4.88 → 1.5.1

package/server/routes/table/schema.js

@@ -1,127 +0,0 @@
-const tableDataSchema = {
-  type: 'object',
-  properties: {
-    querystring: {
-      limit: { type: 'string', pattern: '^(\\d+)$' },
-      page: { type: 'string', pattern: '^(\\d+)$' },
-      // filter: { type: 'string', pattern: '^([\\w\\d_-]+)=([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
-      // search: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
-      order: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      desc: { type: 'string', pattern: '^(\\d+)$' },
-      state: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-      custom: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-      bbox: { type: 'string', pattern: '^([\\d\\s,.-]+)$' },
-      polyline: { type: 'string', pattern: '^([\\d\\w|@{}~_`]+)$' },
-      // key: { type: 'string', pattern: '^([\\d\\w_]+)$' },
-      sql: { type: 'string', pattern: '^(\\d)$' },
-    },
-    params: {
-      id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-    },
-  },
-};
-
-const tableSchema = {
-  type: 'object',
-  properties: {
-    querystring: {
-      limit: { type: 'string', pattern: '^(\\d+)$' },
-      page: { type: 'string', pattern: '^(\\d+)$' },
-      // filter: { type: 'string', pattern: '^([\\w\\d_-]+)=([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
-      // search: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
-      order: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      desc: { type: 'string', pattern: '^(\\d+)$' },
-      // state: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-      // custom: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-      bbox: { type: 'string', pattern: '^([\\d\\s,.-]+)$' },
-      // polyline: { type: 'string', pattern: '^([\\d\\w\\|@\\/\\{\\}~_`]+)$' },
-      key: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.-]+)$' },
-      uid: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      sql: { type: 'string', pattern: '^(\\d)$' },
-    },
-    params: {
-      id: { type: 'string', pattern: '^([\\d\\w]+)$' },
-      table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-    },
-  },
-};
-
-const searchSchema = {
-  type: 'object',
-  properties: {
-    querystring: {
-      page: { type: 'string', pattern: '^(\\d+)$' },
-      limit: { type: 'string', pattern: '^(\\d+)$' },
-      order: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      desc: { type: 'string', pattern: '^(\\d+)$' },
-      key: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.-]+)$' },
-      table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      sql: { type: 'string', pattern: '^(\\d)$' },
-    },
-  },
-};
-
-const suggestSchema = {
-  type: 'object',
-  properties: {
-    querystring: {
-      lang: { type: 'string', pattern: '^([\\w]+)$' },
-      parent: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      sel: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      name: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      // key: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      val: { type: 'string', pattern: '([\\d\\w]+)$' },
-      sql: { type: 'string', pattern: '^(\\d)$' },
-      count: { type: 'string', pattern: '^(\\d)$' },
-    },
-    params: {
-      //  data: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    },
-  },
-};
-
-const formSchema = {
-  type: 'object',
-  properties: {
-    params: {
-      name: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-    },
-  },
-};
-
-const filterSchema = {
-  type: 'object',
-  properties: {
-    params: {
-      table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-    },
-  },
-};
-
-const cardTabDataSchema = {
-  type: 'object',
-  properties: {
-    querystring: {
-      sql: { type: 'string', pattern: '^(\\d)$' },
-    },
-    params: {
-      token: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    },
-  },
-};
-
-const tableDataIdSchema = {
-  type: 'object',
-  properties: {
-    params: {
-      id: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
-      name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-    },
-  },
-};
-
-export {
-  tableDataSchema, tableDataIdSchema, tableSchema, searchSchema, suggestSchema, formSchema, filterSchema, cardTabDataSchema,
-};

package/server/routes/templates/controllers/getTemplate.js

@@ -1,51 +0,0 @@
-/* eslint-disable no-param-reassign */
-import {
-    config, applyHook, getTemplate, getToken, setToken, handlebarsSync,
-} from '../../../../utils.js';
-
-function formatSchema(schema, user, opt) {
-    function parseDataTables(obj) {
-        if (obj?.add) {
-            const obj1 = obj.add?.obj?.includes('{{') && opt ? handlebarsSync.compile(obj.add.obj)(opt) : obj.add?.obj;
-            if (obj.add?.obj) obj.add.obj = obj1;
-            const [token] = setToken({
-                ids: [JSON.stringify({ ...obj.add, table: obj.add?.table || obj.add?.model })],
-                uid: user.uid,
-                array: 1,
-            });
-            Object.assign(obj.add, { token, api: `${config.prefix || '/api'}/table/${token}` });
-        }
-        else if (obj?.type === 'DataTable' && obj.colModel?.length) {
-            obj.colModel.forEach(parseDataTables);
-        }
-    }
-    Object.keys(schema || {}).map(key => ({ key, ...schema[key] })).forEach(parseDataTables);
-}
-
-export default async function getTemplateApi(req) {
-    const { user } = req || {};
-    const { params = {} } = req;
-    const { type, name } = params;
-
-    const tokenData = await getToken({ token: name, uid: user?.uid, json: 1 }) || {};
-
-    const hookData = await applyHook('preTemplate', { name: tokenData.name || name, type, user });
-    if (hookData?.message && hookData?.status) return hookData;
-
-    const data = await getTemplate(type, hookData?.name || tokenData.form || name);
-
-    if (data && tokenData.obj) {
-        const obj = tokenData.obj.split('#').reduce((p, el) => ({ ...p, [el.split('=')[0]]: el.split('=')[1] }), {});
-        Object.assign(data, { obj });
-    }
-
-    if (type === 'form' && user?.uid) {
-        const schema = data?.schema || data;
-        formatSchema(schema, user, data?.obj);
-    }
-
-    await applyHook('afterTemplate', {
-        name, type, data, user,
-    });
-    return data?.html || data || `template not found "${tokenData.form || name}"`;
-}

package/server/routes/templates/index.mjs

@@ -1,10 +0,0 @@
-import getTemplateApi from './controllers/getTemplate.js';
-
-import { getTemplateSchema } from './schema.js';
-
-const policy = ['public'];
-
-export default async function route(app, config = {}) {
-  const { prefix = '/api' } = config;
-  app.get(`${prefix}/template/:type/:name`, { config: { policy }, schema: getTemplateSchema }, getTemplateApi);
-}

package/server/routes/util/controllers/code.generator.js

@@ -1,94 +0,0 @@
-import getTemplate from '../../../plugins/table/funcs/getTemplate.js';
-import pgClients from '../../../plugins/pg/pgClients.js';
-import getToken from '../../../plugins/crud/funcs/getToken.js';
-import { handlebarsSync } from '../../../../utils.js';
-
-function dayOfTheYear(date) {
-  const start = new Date(date.getFullYear(), 0, 0);
-  const diff = (date - start) + ((start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000);
-  const oneDay = 1000 * 60 * 60 * 24;
-  const day = Math.floor(diff / oneDay);
-  return day;
-}
-
-export default async function codeGenerator({
-  pg = pgClients.client, params = {}, user = {}, query = {},
-}, reply) {
-  const { token, column } = params;
-  const data = query.data?.split?.(';') || [];
-
-  if (!token || !column) {
-    return reply.status(400).send('not enough params: token / column');
-  }
-
-  if (!user?.uid) {
-    return reply.status(401).send('unauthorized');
-  }
-
-  const tokenData = await getToken({ token, uid: user?.uid, json: 1 }) || {};
-
-  if (!tokenData?.form || !tokenData?.table) {
-    return reply.status(401).send('token not allow');
-  }
-
-  const loadTemplate = await getTemplate('form', tokenData.form);
-  const schema = loadTemplate?.schema || loadTemplate;
-
-  if (!schema) {
-    return reply.status(404).send('form not found');
-  }
-
-  if (!schema?.[column]?.template) {
-    return reply.status(400).send('template not specified');
-  }
-
-  const columnValue = data.find(el => el.startsWith(column))?.split('=')?.pop();
-
-  const loadTable = await getTemplate('table', tokenData.table);
-  const table = loadTable?.table || tokenData.table;
-
-  if (!pg.pk?.[table]) {
-    return reply.status(404).send('table pk not found');
-  }
-
-  const { count = 0 } = await pg.query(
-    `select count(*) from ${table} where ${columnValue ? `${column}::text = '${columnValue}'` : 'true'} limit 1`,
-  ).then(el => el.rows?.[0] || {});
-
-  const { NUMY = 0 } = await pg.query(
-    `select ${column} as "NUMY" from ${table} where ${column} is not null and date_part('year', cdate) = $1 order by cdate desc limit 1`,
-    [(new Date()).getFullYear()],
-  ).then(el => el.rows?.[0] || {});
-
-  const date = new Date();
-
-  const template = schema[column].template.match(/NUM[M|Y] \d/g)
-    .reduce(
-      (acc, curr) => acc.replace(
-        curr.startsWith('{{{') ? `{{{${curr}}}}` : `{{${curr}}}`,
-        handlebarsSync.compile('{{paddingNumber value padding}}')({ padding: curr.substring(4, curr.length)?.trim?.(), value: curr.startsWith('NUMY') ? NUMY : +count + 1 }),
-      ),
-      schema[column].template,
-    );
-  const result = handlebarsSync.compile(template)({
-    HH: date.getHours(), // hours 24h: 14:00 = 14
-    HH12: (date.getHours() + 24) % 12 || 12, // hours 12h: 14:00 = 2
-    HH24: date.getHours(), // hours 24h: 14:00 = 14
-    MI: date.getMinutes(), // minutes
-    SS: date.getSeconds(), // seconds
-
-    YYYY: date.getFullYear(), // full year: 2025
-    YY: date.getFullYear().toString().substring(2, 4), // last 2 digits of year: 25
-
-    MONTH: date.toLocaleString('en', { month: 'long' }).toUpperCase(), // month name: MARCH
-    MON: date.toLocaleString('en', { month: 'long' }).substring(0, 3).toUpperCase(), // month name abbrev: MAR
-    MM: date.getMonth() + 1, // month number: 1 - january, 12 - december
-
-    D: date.getDay(), // day of the week: 1 - monday, 7 - sunday
-    DD: date.getDate(), // day of the month: january 4 = 4
-    DDD: dayOfTheYear(date), // day of the year: march 4 = 63
-    ...data,
-  });
-
-  return reply.status(200).send(result);
-}

package/server/routes/util/controllers/next.id.js

@@ -1,4 +0,0 @@
-export default async function nextId({ pg }) {
-  const { id } = await pg.one('select next_id() as id');
-  return { id: id.toString() };
-}

package/server/routes/util/controllers/status.monitor.js

@@ -1,8 +0,0 @@
-const formatMemoryUsage = (data) => `${Math.round((data / 1024 / 1024) * 100) / 100} MB`;
-
-export default async function statusMonitor() {
-  const memoryUsage = process.memoryUsage();
-  const message = Object.keys(memoryUsage)
-    .reduce((acc, curr) => Object.assign(acc, { [curr]: formatMemoryUsage(memoryUsage[curr]) }), {});
-  return { message, status: 200 };
-}

package/server/routes/util/controllers/user.tokens.js

@@ -1,45 +0,0 @@
-import {
-    customTokens, userTokens, handlebarsSync, setOpt, getOpt, config,
-} from '../../../../utils.js';
-
-export default async function userTokensAPI({ params = {}, user = {} }, reply) {
-    if (!user?.uid) {
-        return reply.status(403).send('access restricted: user');
-    }
-
-    if (!params?.token) {
-        return reply.status(400).send('not enough params: token');
-    }
-
-    if (!config.redis) {
-        return reply.status(500).send('empty redis');
-    }
-
-    if (!customTokens[params.token]) {
-        return reply.status(404).send('token not found');
-    }
-
-    // return from cache
-    if (userTokens[user.uid]?.[params.token]) {
-        const opt = await getOpt(userTokens[user.uid][params.token], user.uid);
-        if (opt) return userTokens[user.uid][params.token];
-    }
-
-    const token = setOpt(
-        {
-            ...customTokens[params.token],
-            query: handlebarsSync.compile(customTokens[params.token]?.query || 'true')({ user, uid: user.uid }),
-        },
-        user.uid,
-    );
-
-    // first api call from user
-    if (!userTokens[user.uid]) {
-        userTokens[user.uid] = {};
-    }
-
-    // assign token
-    userTokens[user.uid][params.token] = token;
-
-    return token;
-}

package/server/routes/util/index.js

@@ -1,14 +0,0 @@
-import nextId from './controllers/next.id.js';
-import statusMonitor from './controllers/status.monitor.js';
-import userTokens from './controllers/user.tokens.js';
-import codeGenerator from './controllers/code.generator.js';
-
-async function plugin(app, config = {}) {
-  const { prefix = '/api' } = config;
-  app.get(`${prefix}/next-id`, { config: { policy: ['public'] } }, nextId);
-  app.get(`${prefix}/status-monitor`, {}, statusMonitor);
-  app.get(`${prefix}/user-tokens/:token`, { config: { policy: ['user', 'site'] } }, userTokens);
-  app.get(`${prefix}/code-gen/:token/:column/:id?`, { config: { policy: ['user'] } }, codeGenerator);
-}
-
-export default plugin;

package/server/routes/widget/controllers/file.edit.js

@@ -1,55 +0,0 @@
-import path from 'node:path';
-
-import dataUpdate from '../../../plugins/crud/funcs/dataUpdate.js';
-import pgClients from '../../../plugins/pg/pgClients.js';
-import uploadMultiPart from '../../../plugins/file/uploadMultiPart.js';
-
-export default async function widgetSet(req, reply) {
-    const {
-        pg = pgClients.client, headers = {}, user = {}, params = {},
-    } = req;
-
-    if (!params?.id) {
-        return reply.status(400).send('not enough params: id');
-    }
-
-    if (!pg.pk?.['crm.files']) {
-        return reply.status(404).send('table not found');
-    }
-
-    if (headers['content-type']?.split?.(';')?.shift?.() !== 'multipart/form-data') {
-        return reply.status(400).send('invalid payload content type');
-    }
-
-    const file = await uploadMultiPart(req);
-    const extName = path.extname(file.filepath).slice(1).toLowerCase();
-
-    const data = {
-        uploaded_name: file?.originalFilename?.toLocaleLowerCase()?.replace(/'/g, '\'\''),
-        file_path: file?.relativeFilepath?.replace(/\\/g, '/'),
-        ext: extName,
-        size: file?.size,
-        file_status: 1,
-        uid: user?.uid || 1,
-    };
-
-    const result = await dataUpdate({
-        pg,
-        table: 'crm.files',
-        id: params.id,
-        data,
-        uid: user?.uid,
-    });
-
-    if (!result?.file_id) {
-        return reply.status(404).send('file not found');
-    }
-
-    return reply.status(200).send({
-        rowCount: 1,
-        data: result,
-        command: 'UPLOAD',
-        id: result?.file_id,
-        entity_id: result?.entity_id,
-    });
-}

package/server/routes/widget/controllers/widget.del.js

@@ -1,99 +0,0 @@
-import config from '../../../../config.js';
-import isFileExists from '../../../plugins/file/isFileExists.js';
-import logChanges from '../../../plugins/crud/funcs/utils/logChanges.js';
-import pgClients from '../../../plugins/pg/pgClients.js';
-
-const isAdmin = (req) => process.env.NODE_ENV === 'admin'
-  || config.admin
-  || req?.hostname?.split?.(':')?.shift?.() === config.adminDomain
-  || req?.hostname?.startsWith?.('admin');
-
-async function checkAccess(pg, objectid, id) {
-  const { uid, filepath } = await pg.query('select uid, file_path as filepath from crm.files where entity_id=$1 and file_id=$2', [objectid, id])
-    .then(el => el.rows?.[0] || {});
-  return { uid, exists: filepath ? await isFileExists(filepath) : null };
-}
-
-/**
- * Дістає CRM дані для vue хешує ідентифікатори, підтягує селекти
- *
- * @method DELETE
- * @summary CRM дані для обраного віджета.
- * @priority 2
- * @tag table
- * @type api
- * @requires setTokenById
- * @requires getSelect
- * @param {String} id Ідентифікатор для хешування
- * @param {Any} sql Використовується для повернення sql запиту
- * @param {String} type Тип для хешування даних
- * @errors 400, 500
- * @returns {Number} status Номер помилки
- * @returns {String|Object} error Опис помилки
- * @returns {String|Object} message Повідомлення про успішне виконання або об'єкт з параметрами
- */
-
-export default async function widgetDel(req, reply) {
-  const {
-    pg = pgClients.client, params = {}, user = {},
-  } = req;
-
-  if (!user?.uid) {
-    return reply.status(401).send('access restricted: user not authorized');
-  }
-
-  const { type, objectid, id } = params;
-
-  if (!objectid) {
-    return reply.status(400).send('not enough params: object id');
-  }
-
-  if (!id && type !== 'reaction') {
-    return reply.status(400).send('not enough params: id');
-  }
-
-  // force delete db entry if file not exists
-  const { exists, uid } = ['file', 'gallery'].includes(type) ? await checkAccess(pg, objectid, id) : {};
-
-  if (exists && !isAdmin(req) && uid && user?.uid !== uid) {
-    return reply.status(403).send('access restricted: file exists, not an author');
-  }
-
-  const sqls = {
-    comment: `delete from crm.communications where entity_id=$1 and ${isAdmin(req) ? '$2=$2' : 'uid=$2'} and communication_id=$3`,
-    checklist: `delete from crm.checklists where entity_id=$1 and ${isAdmin(req) ? '$2=$2' : 'uid=$2'} and checklist_id=$3`,
-    file: `update crm.files set file_status=3 where entity_id=$1 and ${!exists || isAdmin(req) ? '$2=$2' : 'uid=$2'} and file_id=$3 returning uploaded_name`,
-    gallery: `update crm.files set file_status=3 where entity_id=$1 and ${!exists || isAdmin(req) ? '$2=$2' : 'uid=$2'} and file_id=$3 returning uploaded_name`,
-    reaction: `delete from crm.reactions where entity_id=$1 and ${isAdmin(req) ? '$2=$2' : 'created_by=$2'} and $3=$3 returning reaction_type`,
-  };
-
-  const sql = sqls[type];
-  const table = {
-    comment: 'crm.communications',
-    checklist: 'crm.checklists',
-    file: 'crm.files',
-    gallery: 'crm.files',
-    reaction: 'crm.reactions',
-  }[type];
-
-  if (!sql) {
-    return reply.status(400).send('invalid widget type');
-  }
-
-  const { rows = [] } = await pg.query(sql, [objectid, user.uid, id || '']);
-
-  if (type === 'reaction') {
-    console.log('231131');
-  }
-
-  await logChanges({
-    pg,
-    table,
-    id: type === 'reaction' ? objectid : id,
-    data: rows[0],
-    uid: user?.uid,
-    type: 'DELETE',
-  });
-
-  return reply.status(200).send({ data: { id }, user: { uid: user.uid, name: user.user_name } });
-}

package/server/routes/widget/controllers/widget.get.js

@@ -1,156 +0,0 @@
-import getMeta from '../../../plugins/pg/funcs/getMeta.js';
-import getToken from '../../../plugins/crud/funcs/getToken.js';
-import pgClients from '../../../plugins/pg/pgClients.js';
-
-const galleryExtList = ['png', 'svg', 'jpg', 'jpeg', 'gif', 'mp4', 'mov', 'avi'];
-const username = 'coalesce(u.sur_name,\'\')||coalesce(\' \'||u.user_name,\'\') ||coalesce(\' \'||u.father_name,\'\')';
-
-const pkList = {
-  comment: 'communication_id',
-  checklist: 'checklist_id',
-  file: 'file_id',
-  gallery: 'file_id',
-  reaction: 'reaction_id',
-};
-
-/**
- * Дістає CRM для widget
- *
- */
-
-export default async function widgetGet({
-  pg = pgClients.client, user = {}, params = {}, query = {}, unittest,
-}, reply) {
-  const param = user?.uid ? await getToken({
-    token: params.objectid, mode: 'w', uid: user.uid,
-  }) : null;
-
-  const objectid = param ? JSON.parse(param)?.id : params.objectid;
-
-  if (!objectid) {
-    return reply.status(400).send('not enough params: id');
-  }
-
-  const sqls = {
-    comment: pg.pk['admin.users']
-      ? `select communication_id, entity_id, body, subject, c.cdate, c.uid, 
-    ${username} as username, u.login, u.avatar
-    from crm.communications c
-    left join admin.users u on u.uid=c.uid 
-    where entity_id=$1 order by cdate desc`
-      : 'select communication_id, entity_id, body, subject, cdate, uid from crm.communications where entity_id=$1 order by cdate desc',
-
-    history: `select * from (
-      SELECT change_id, entity_id, entity_type, change_type, change_date, a.change_user_id, a.uid, a.cdate, b.json_agg as changes,
-      ${username} as username, u.login, u.avatar
-      FROM log.table_changes a
-      left join admin.users u on a.change_user_id = u.uid
-      left join lateral(
-        select json_agg(row_to_json(q)) from (
-          select change_data_id, entity_key, value_new, value_old from log.table_changes_data
-          where change_id=a.change_id
-        )q
-      )b on 1=1
-      where b.json_agg is not null and (entity_id=$1 or entity_id in (
-        select communication_id as comments from crm.communications where entity_id=$1
-        union all select checklist_id from crm.checklists where entity_id=$1)
-      )
-
-    union all
-    select change_id, entity_id, entity_type, change_type, change_date, a.change_user_id, a.uid, a.cdate, b.json_agg as changes,
-        ${username} as username, u.login, u.avatar
-        FROM log.table_changes a
-        left join admin.users u on a.change_user_id = u.uid
-            left join lateral(
-          select json_agg(o) from (
-            select json_object_agg(entity_key, coalesce(value_new, value_old)) as o from log.table_changes_data
-            where change_id=a.change_id and entity_key not in ('uid', 'file_status', 'editor_id', 'cdate', 'editor_date', 'entity_id')
-          )q 
-        )b on 1=1
-        where a.change_type in ('INSERT', 'DELETE') and a.entity_id in (select file_id from crm.files where entity_id=$1)
-        limit 100
-
-    )q order by cdate desc limit 100`,
-
-    checklist: pg.pk['admin.users']
-      ? `SELECT checklist_id, entity_id, subject, is_done, done_date, c.uid, c.cdate, ${username} as username, u.login, u.avatar
-      FROM crm.checklists c
-      left join admin.users u on u.uid=c.uid
-      where entity_id=$1 order by cdate desc`
-      : 'SELECT checklist_id, entity_id, subject, is_done, done_date, uid, cdate FROM crm.checklists where entity_id=$1 order by cdate desc',
-
-    file: pg.pk['admin.users']
-      ? `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, c.ismain, 
-    ${username} as username, u.login, isverified, u.avatar, u.uid as author, file_status 
-    FROM crm.files c 
-    left join admin.users u on u.uid=c.uid
-    where entity_id=$1 and file_status<>3 order by cdate desc`
-      : `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, uid, cdate, file_type, ismain,
-      isverified, uid as author, file_status FROM crm.files c where entity_id=$1 and file_status<>3 order by cdate desc`,
-    gallery: pg.pk['admin.users']
-      ? `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, c.ismain,
-    ${username} as username, u.login, u.avatar, isverified, u.avatar, c.uid as author, file_status 
-    FROM crm.files c 
-    left join admin.users u on u.uid=c.uid
-    where entity_id=$1 and file_status<>3 and ext = any($2) order by cdate desc`
-      : `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, ismain,
-      isverified, uid as author, file_status FROM crm.files c where entity_id=$1 and file_status<>3 and ext = any($2) order by cdate desc`,
-    reaction: 'SELECT count(*), reaction_type FROM crm.reactions c where entity_id=$1 group by reaction_type',
-  };
-
-  const q = sqls[params.type];
-
-  if (!q) {
-    return reply.status(400).send('invalid widget type');
-  }
-
-  /* data */
-  const time = [Date.now()];
-  const { rows = [] } = await pg.query(q, [objectid, params.type === 'gallery' ? galleryExtList : null].filter(Boolean));
-  rows.forEach(row => Object.assign(row, { username: row.username?.trim?.() || row.login }));
-  time.push(Date.now());
-
-  /* reactions */
-  const widgetPkey = pkList[params.type];
-  if (params.type === 'comment' && widgetPkey) {
-    const reactions = rows.length && user.uid ? await pg.query('select json_object_agg(entity_id, reaction_type) from crm.reactions where entity_id=any($1) and created_by=$2', [rows.map(row => row[widgetPkey]), user.uid]).then((el) => el.rows?.[0]?.json_object_agg || {}) : {};
-    rows.filter(row => reactions[row[widgetPkey]]).forEach((row) => {
-      Object.assign(row, { reaction: reactions[row[widgetPkey]] });
-    });
-  }
-
-  time.push(Date.now());
-
-  /* Object info  */
-  const { tableName } = pg.pk['log.table_changes'] ? await pg.query(
-    'select entity_type as "tableName" from log.table_changes where entity_id=$1 limit 1',
-    [objectid],
-  ).then(el => el.rows?.[0] || {}) : {};
-
-  const { pk, columns = [] } = await getMeta({ pg, table: tableName });
-
-  const authorIdColumn = columns.find(col => ['uid', 'created_by'].includes(col.name))?.name;
-
-  if (!pk && params.type === 'history' && !unittest) {
-    return reply.status(404).send('log table not found');
-  }
-
-  const q1 = `select ${username} as author, u.login, a.cdate, a.editor_date from ${tableName} a 
-  left join admin.users u on a.${authorIdColumn}=u.uid where a.${pk}=$1 limit 1`;
-
-  const data = pg.pk['admin.users'] && pk && tableName ? await pg.query(q, [objectid, params.type === 'gallery' ? galleryExtList : null].filter((el) => el)).then(el => el.rows?.[0] || {}) : {};
-
-  if (query.debug && user?.user_type === 'admin') {
-    return {
-      q, type: params.type, q1, id: objectid, data,
-    };
-  }
-
-  return reply.status(200).send({
-    time: { data: time[2] - time[0] },
-    rows,
-    user: { uid: user?.uid, name: user?.user_name },
-    data: { author: data?.author, cdate: data?.cdate, edate: data?.editor_date },
-    objectid: params.objectid,
-  });
-}