@opengis/fastify-table 2.5.53 → 3.0.0-beta.0

package/dist/server/routes/table/functions/getData.js

@@ -1,721 +0,0 @@
-import config from "../../../../config.js";
-import { handlebars, handlebarsSync } from "../../../helpers/index.js";
-import getFilterSQLParametrized from "../../../plugins/table/funcs/getFilterSQLParametrized/index.js";
-import getAccess from "../../../plugins/crud/funcs/getAccess.js";
-import setToken from "../../../plugins/crud/funcs/setToken.js";
-import getToken from "../../../plugins/crud/funcs/getToken.js";
-import gisIRColumn from "../../../plugins/table/funcs/gisIRColumn.js";
-import applyHook from "../../../plugins/hook/applyHook.js";
-import getSelect from "../../../plugins/table/funcs/getSelect.js";
-import setOpt from "../../../plugins/crud/funcs/setOpt.js";
-import getOpt from "../../../plugins/crud/funcs/getOpt.js";
-import getFilter from "../../../plugins/table/funcs/getFilter.js";
-import logger from "../../../plugins/logger/getLogger.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 metaFormat from "../../../plugins/table/funcs/metaFormat/index.js";
-import extraDataGet from "../../../plugins/extra/extraDataGet.js";
-import locales from "../controllers/utils/locales.js";
-import conditions from "../controllers/utils/conditions.js";
-import { resources } from "../../../plugins/access/funcs/getResources.js";
-import { BadRequestError, ForbiddenError, NotFoundError, UnauthorizedError, } from "../../../../errors.js";
-import prettify from "./prettify.js";
-const components = {
-    "vs-widget-file": "select 'vs-widget-file' as component, count(*) from crm.files where entity_id=$1 and file_status<>3",
-    "vs-widget-comments": "select 'vs-widget-comments' as component, count(*) from crm.communications where entity_id=$1",
-};
-function getOrder({ queryOrder, queryDesc, defaultOrder, columnList, cols, sqlColumns, iscalled = false, }) {
-    if (iscalled && queryOrder) {
-        return `order by ${queryOrder}`;
-    }
-    if (!queryOrder) {
-        return `order by ${defaultOrder || "true::boolean"} nulls last`;
-    }
-    const orderArr = queryOrder.split(/[|]/g).map((el) => el.split(/[-]/));
-    const validOrder = orderArr
-        .filter((el) => el[0] &&
-        (columnList || "")
-            .concat(sqlColumns || "")
-            .concat(cols || "")
-            .includes(el[0]))
-        .map((el) => `${el[0]} ${queryDesc || el[1] === "desc" ? "desc" : ""}`)
-        .join(",");
-    return `order by ${validOrder || "true::boolean"} nulls last`;
-}
-const checkInline = {};
-const maxLimit = 100;
-const defaultLimit = 20;
-export default async function dataAPI({ pg = pgClients.client, params, table, id, headers = {}, query = {}, user = {}, contextQuery, searchColumn, sufix = true, filterList, actions: actionsParam, accessQuery: accessQueryParam, columns: columnsParam, isExport = false, called: isCalled, }, _, called1) {
-    const called = called1 || isCalled;
-    const time = Date.now();
-    const timeArr = [Date.now()];
-    const { uid } = user;
-    const method = "GET";
-    const paramsTable = params?.table || table;
-    if (!paramsTable) {
-        throw BadRequestError("not enough params: table");
-    }
-    const hookData = (await applyHook("preData", {
-        pg,
-        table: paramsTable,
-        id: params?.id || id,
-        user,
-    }));
-    // hooks should throw custom errors instead, this is temp solution to avoid breaking changes in hooks
-    if (hookData?.message && hookData?.status) {
-        if (hookData.status >= 400) {
-            throw new Error(hookData.message);
-        }
-        return hookData.message;
-    }
-    /* from tableData START */
-    const tokenData1 = await getOpt(paramsTable, uid);
-    const tokenData2 = await getToken({
-        uid,
-        token: paramsTable,
-        json: true,
-    });
-    const tokenData = tokenData1 || tokenData2;
-    const resource = resources[paramsTable] ? paramsTable : undefined;
-    const templateName = resources[paramsTable] ||
-        tokenData?.table ||
-        hookData?.table ||
-        paramsTable;
-    const loadTable = await getTemplate("table", templateName);
-    if (tokenData?.table && !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 };
-    }
-    /* from tableData END */
-    // check sql inline fields count
-    if (!checkInline[paramsTable] && 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 = pg
-            ? await Promise.all(filterSql.map((el, i) => pg
-                .query(`select  ${el.name || `t${i}`}.* from(select * from ${loadTable.table})t ${sqlTable} limit 0`)
-                .then((item) => item.fields)))
-            : [];
-        d.forEach((el, i) => {
-            filterSql[i].inline = el.length === 1;
-            filterSql[i].fields = el.map((f) => f.name);
-        });
-        checkInline[paramsTable] = loadTable.sql;
-    }
-    else if (checkInline[paramsTable]) {
-        loadTable.sql = checkInline[paramsTable];
-    }
-    if (query?.sql === 0 && process.platform === "win32")
-        return loadTable;
-    if (!pg) {
-        throw Error("empty pg");
-    }
-    const pkey = pg.pk?.[resources[paramsTable] || paramsTable] ||
-        pg.pk?.[resources[paramsTable] || paramsTable.replace(/"/g, "")] ||
-        (await getMeta({
-            pg,
-            table: resources[paramsTable] || loadTable?.table || paramsTable,
-        }))?.pk;
-    if (!loadTable &&
-        !(tokenData?.table && pg.pk?.[tokenData?.table]) &&
-        !(called && pkey)) {
-        throw NotFoundError("template not found");
-    }
-    const objectId = tokenData?.id || hookData?.id || params?.id || id;
-    const { actions = [], query: accessQuery, message: accessMessage, } = actionsParam
-        ? {
-            actions: actionsParam,
-            query: accessQueryParam || "1=1",
-            message: undefined,
-        }
-        : (await getAccess({
-            resource,
-            table: templateName,
-            id: objectId,
-            user,
-            method,
-        }, pg)) || {};
-    if (accessMessage) {
-        throw ForbiddenError(accessMessage);
-    }
-    // const body = loadTable || hookData || tokenData;
-    const { table: table1, columns = [], sql, cardSql, form, meta, sqlColumns, editable = false, } = loadTable || hookData || tokenData || params || { table };
-    const ispublic = loadTable?.public ||
-        hookData?.public ||
-        tokenData?.public ||
-        params?.public ||
-        false;
-    if (!ispublic &&
-        !user?.uid &&
-        !called &&
-        !accessQueryParam &&
-        !actionsParam) {
-        throw UnauthorizedError("unauthorized");
-    }
-    if (!ispublic && !actions.includes("view") && !config?.local && !called) {
-        throw ForbiddenError("access restricted");
-    }
-    const { list: filters = [] } = objectId
-        ? {}
-        : (await getFilter({
-            pg,
-            table: templateName,
-            user,
-        }, null)) || {};
-    const tableMeta = await getMeta({ pg, table: table1 });
-    const viewSql = await getTemplate("view", table1);
-    timeArr.push(Date.now());
-    if (tableMeta?.view) {
-        if (!loadTable?.key && !tokenData?.key) {
-            throw NotFoundError(`key  not found: ${table1}`);
-        }
-        Object.assign(tableMeta, { pk: loadTable?.key || tokenData?.key });
-    }
-    const { pk, columns: dbColumns = [] } = (viewSql
-        ? { pk: loadTable?.key, columns: loadTable?.columns }
-        : tableMeta) || {};
-    const columns1 = columns ||
-        dbColumns.map(({ name, title, dataTypeID }) => ({
-            name,
-            title,
-            type: pg.pgType?.[dataTypeID],
-        }));
-    columns1.forEach((col) => {
-        Object.assign(col, locales[`${table1 || paramsTable}.${col.name}`] || {});
-    });
-    if (!pk) {
-        throw NotFoundError(`table not found: ${table1}`);
-    }
-    const idx = {};
-    const columnList = dbColumns.map((el) => el.name || el).join(",");
-    const sqlTable = sql
-        ?.filter?.((el) => !el?.disabled &&
-        !el.inline &&
-        el?.sql?.replace &&
-        !(isExport && el.export === false))
-        .map((el, i) => ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `)
-        ?.join("") || "";
-    const cardSqlFiltered = objectId
-        ? cardSql?.filter?.((el) => !el?.disabled && el?.name && el?.sql?.replace) || []
-        : [];
-    const cardSqlTable = cardSqlFiltered.length
-        ? cardSqlFiltered
-            .map((el, i) => ` left join lateral (${el.sql}) ct${i}  on 1=1 `)
-            .join("\n") || ""
-        : "";
-    const sqlInline = loadTable?.sql
-        ?.filter?.((el) => el.inline && !(isExport && el.export === false))
-        ?.map((el) => `,(${el.sql})`)
-        ?.join("") || "";
-    const { fields = [] } = !viewSql
-        ? await pg.query(`select * ${sqlInline} from ${table1} t ${sqlTable} ${cardSqlTable} limit 0`)
-        : await pg.query(`select * from (${viewSql})q limit 0`);
-    const dbColumnsTable = fields.map((el) => el.name);
-    const cols = columns
-        .filter((el) => el.name !== "geom" && dbColumnsTable.includes(el.name))
-        .map((el) => `"${el.name || el}"`)
-        .join(",");
-    const metaCols = Object.keys(loadTable?.meta?.cls || {}).filter((el) => !cols.includes(el)).length
-        ? `,${Object.keys(loadTable?.meta?.cls || {})
-            ?.filter((el) => !cols.includes(el))
-            .join(",")}`
-        : "";
-    if (objectId && columnList.includes(objectId)) {
-        return gisIRColumn({
-            pg,
-            layer: resources[paramsTable] || paramsTable,
-            column: objectId,
-            sql: query?.sql,
-            filter: query?.filter,
-            search: query?.search,
-            state: query?.state,
-            custom: query?.custom,
-        });
-    }
-    const isdefault = !objectId ? filters.find((el) => el.default) : null;
-    const checkFilter = [
-        query?.filter,
-        query?.search,
-        query?.state,
-        query?.custom,
-        isdefault,
-    ].filter(Boolean).length;
-    const fData = checkFilter
-        ? await getFilterSQLParametrized({
-            pg,
-            table: loadTable
-                ? tokenData?.table || resources[paramsTable] || paramsTable
-                : table1,
-            filter: query?.filter,
-            search: query?.search,
-            searchColumn,
-            state: query?.state,
-            custom: query?.custom,
-            uid,
-            objectId,
-            filterList,
-        })
-        : {};
-    timeArr.push(Date.now());
-    const args = Array.from(fData.args || []);
-    if (objectId) {
-        args.push(objectId);
-        Object.assign(idx, { id: args.length });
-    }
-    else if (query?.key && loadTable.key) {
-        args.push(query.key);
-        Object.assign(idx, { id: args.length });
-    }
-    const keyQuery = query?.key && (loadTable?.key || tokenData?.key) && !objectId
-        ? `${loadTable?.key || tokenData?.key}=$${args.length}`
-        : null;
-    const limit = (called
-        ? query?.limit || defaultLimit
-        : Math.min(maxLimit, +(query?.limit || defaultLimit))) || defaultLimit;
-    args.push(limit);
-    Object.assign(idx, { limit: args.length });
-    const offset = query?.page && query?.page > 0 && !objectId ? (query?.page - 1) * limit : 0;
-    args.push(offset);
-    Object.assign(idx, { offset: args.length });
-    const order = getOrder({
-        queryOrder: query?.order,
-        queryDesc: query?.desc,
-        defaultOrder: loadTable?.order,
-        columnList,
-        cols,
-        sqlColumns: loadTable?.sqlColumns,
-        iscalled: !!called,
-    });
-    const isSearchable = loadTable?.meta?.search &&
-        typeof loadTable.meta.search === "string" &&
-        query?.search &&
-        !idx.id;
-    if (isSearchable) {
-        args.push(`%${query.search.replace(/%/g, "\\%")}%`);
-        Object.assign(idx, { search: args.length });
-    }
-    if (meta?.bbox && query?.polyline) {
-        args.push(query.polyline);
-        Object.assign(idx, {
-            polyline: args.length,
-        });
-    }
-    if (config.trace)
-        console.log(order);
-    const search = isSearchable
-        ? `(${loadTable.meta.search
-            .split(",")
-            .map((el) => `${el} ilike $${idx.search}`)
-            .join(" or ")})`
-        : null;
-    const queryBbox = query?.bbox
-        ? query?.bbox
-            .replace(/ /g, ",")
-            .split(",")
-            ?.map((el) => el - 0)
-        : [];
-    const queryPolyline = meta?.bbox && query?.polyline
-        ? `ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline($${idx.polyline})),${meta.bbox})`
-        : undefined;
-    const bbox = meta?.bbox && queryBbox.filter((el) => !Number.isNaN(el))?.length === 4
-        ? `${meta.bbox} && 'box(${queryBbox[0]} ${queryBbox[1]},${queryBbox[2]} ${queryBbox[3]})'::box2d `
-        : undefined;
-    const interfaceName = headers?.referer?.match?.(/.*\/([^?]+)/)?.[1];
-    const interfaceQuery1 = interfaceName && pg?.pk
-        ? await pg
-            .query("select query from admin.routes where route_id=$1", [
-            interfaceName,
-        ])
-            .then((el) => el.rows?.[0]?.query)
-        : null;
-    const interfaceQuery = params?.query
-        ? await handlebars.compile(params?.query)({ user, uid })
-        : undefined;
-    const where = [
-        objectId ? ` "${pk}" = $${idx.id}` : null,
-        keyQuery,
-        loadTable?.query,
-        tokenData?.query,
-        fData?.q,
-        search,
-        accessQuery || "1=1",
-        contextQuery,
-        bbox,
-        queryPolyline,
-        interfaceQuery,
-        interfaceQuery1,
-    ].filter(Boolean);
-    const omitGeometry = !objectId && loadTable?.showGeometryMode === "card";
-    const q1 = `select  ${pk ? `"${pk}" as id,` : ""} 
-  ${objectId || query?.key ? "*" : columnsParam || sqlColumns || cols || "*"} 
-  ${metaCols}
-  ${dbColumns.filter((el) => pg.pgType?.[el.dataTypeID] === "geometry")
-        .length &&
-        !columnsParam &&
-        !omitGeometry
-        ? `,${dbColumns
-            .filter((el) => pg.pgType?.[el.dataTypeID] === "geometry")
-            .map((el) => `st_asgeojson("${el.name.replace(/'/g, "''")}")::json as "${el.name.replace(/'/g, "''")}"`)
-            .join(",")}`
-        : ""} 
-  from (select * ${sql
-        ?.filter((el) => el.inline && !(isExport && el.export === false))
-        .map((el) => `,(${el.sql})`)
-        .join("") || ""} from ${viewSql ? `(${viewSql})` : table1} t  ${sqlTable} ) t 
-                      
-  ${objectId ? cardSqlTable : ""} 
-  where ${where.join(" and ") || "true"} 
-  ${order} limit $${idx.limit}::bigint offset $${idx.offset}::bigint`;
-    if (q1.includes("{{uid}}")) {
-        args.push(uid || "");
-        Object.assign(idx, { uid: args.length });
-    }
-    const q = q1.replace(/'{{uid}}'/g, `$${idx.uid}`);
-    if (config.trace)
-        console.log(q);
-    if (query?.sql === 1 && process.platform === "win32") {
-        return prettify(q, args);
-    }
-    const rows = await pg.query(q, args).then((r) => r.rows || []);
-    if (!rows.length &&
-        headers?.referer?.includes?.("/card/") &&
-        headers?.referer?.includes?.(templateName)) {
-        throw ForbiddenError("access restricted: empty rows");
-    }
-    timeArr.push(Date.now());
-    if (uid &&
-        rows.length &&
-        // !config.security?.disableToken &&
-        (editable ||
-            (tokenData?.actions || actionsParam)?.includes("edit") ||
-            actions.includes("edit") ||
-            actions.includes("del"))) {
-        rows.forEach((row) => {
-            Object.assign(row, {
-                token: setToken({
-                    ids: [
-                        JSON.stringify({
-                            id: row.id,
-                            table: templateName,
-                            form: loadTable?.form,
-                            resource,
-                            obj: tokenData?.obj || hookData?.obj,
-                        }),
-                    ],
-                    uid,
-                    array: 1,
-                })?.[0],
-            });
-        });
-    }
-    const idx1 = {};
-    const args1 = Array.from(fData.args || []);
-    if (idx.search) {
-        args1.push(args[idx.search - 1]);
-        Object.assign(idx1, { search: args1.length });
-    }
-    if (idx.uid) {
-        args1.push(args[idx.uid - 1]);
-        Object.assign(idx1, { uid: args1.length });
-    }
-    if (idx.polyline) {
-        args1.push(args[idx.polyline - 1]);
-        Object.assign(idx1, { polyline: args1.length });
-    }
-    const search1 = idx.search
-        ? `(${loadTable.meta.search
-            .split(",")
-            .map((el) => `${el} ilike $${idx1.search}`)
-            .join(" or ")})`
-        : null;
-    const queryPolyline1 = idx.polyline
-        ? `ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline($${idx1.polyline})),${meta.bbox})`
-        : undefined;
-    const filterWhere = [
-        fData.q,
-        search1,
-        bbox,
-        queryPolyline1,
-        interfaceQuery,
-        loadTable?.query,
-        tokenData?.query,
-    ].filter(Boolean);
-    const aggColumns = columns
-        .filter((el) => el.agg)
-        .reduce((acc, curr) => Object.assign(acc, { [curr.name]: curr.agg }), {});
-    const aggregates = dbColumns
-        .map((el) => ({
-        name: el.name,
-        type: pg.pgType?.[el.dataTypeID],
-    }))
-        .filter((el) => ["numeric", "double precision"].includes(el.type) && aggColumns[el.name]);
-    const qCount = `select 
-  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 (select * ${sql
-        ?.filter((el) => el.inline)
-        .map((el) => `,(${el.sql})`)
-        .join("") || ""} from ${viewSql ? `(${viewSql})` : table1} t ${sqlTable})t 
-  where ${[loadTable?.query, tokenData?.query, accessQuery, contextQuery]
-        .filter(Boolean)
-        .join(" and ") || "true"} `.replace(/'{{uid}}'/g, `$${idx1.uid}`);
-    if (query?.sql === 2 && process.platform === "win32") {
-        return prettify(qCount, args1);
-    }
-    const counts = keyQuery || objectId
-        ? { total: rows.length, filtered: rows.length }
-        : await pg
-            .queryCache?.(qCount, {
-            args: args1,
-            table: loadTable?.table || tokenData?.table,
-            time: 5,
-        })
-            .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: templateName, sufix }, pg);
-    timeArr.push(Date.now());
-    const status = [];
-    if (loadTable?.meta?.status) {
-        const statusColumn = loadTable.meta?.cls?.[loadTable.meta?.status]
-            ? {
-                name: loadTable.meta?.status,
-                data: loadTable.meta?.cls?.[loadTable.meta?.status],
-            }
-            : loadTable.columns.find((col) => col.name === loadTable.meta?.status) || {};
-        const statusCls = statusColumn.data || statusColumn.option;
-        const statusClsData = statusCls ? await getSelect(statusCls, pg) : {};
-        statusClsData?.arr?.forEach((el) => status.push({
-            ...el,
-            count: rows.filter((row) => el.id === row[statusColumn.name])
-                .length,
-        }));
-    }
-    const template = await getTemplate("card", templateName);
-    const index = template?.find((el) => el[0] === "index.yml")?.[1] || {};
-    const html = {};
-    const { panels = [] } = index;
-    const tokens = {};
-    if (template && objectId) {
-        // tokens result
-        if (
-        // !config.security?.disableToken &&
-        index?.tokens &&
-            typeof index?.tokens === "object" &&
-            !Array.isArray(index?.tokens)) {
-            Object.keys(index.tokens || {})
-                .filter((key) => index?.tokens[key]?.public ||
-                actions?.includes?.("edit") ||
-                actions?.includes?.("add") ||
-                user?.user_type === "viewer" ||
-                !index?.tokens[key]?.table)
-                .forEach((key) => {
-                const item = index?.tokens[key];
-                Object.keys(item)
-                    .filter((el) => item[el]?.includes?.("{{"))
-                    .forEach((el) => {
-                    item[el] = handlebarsSync.compile(item[el])({
-                        user,
-                        uid,
-                        id: objectId,
-                        data: rows[0],
-                    });
-                });
-                const token = item.form && item.table
-                    ? setToken({
-                        ids: [
-                            JSON.stringify({
-                                ...item,
-                                resource,
-                            }),
-                        ],
-                        uid,
-                        array: 1,
-                    })[0]
-                    : setOpt(item, uid);
-                tokens[key] = token;
-            });
-        }
-        // console.log('token');
-        panels?.forEach?.((panel) => panel?.items
-            ?.filter?.((item) => item.token)
-            ?.forEach?.((el1) => Object.assign(el1, { token: tokens[el1.token] })));
-        // conditions
-        panels
-            ?.filter((el) => el.items)
-            .forEach((el) => {
-            Object.assign(el, {
-                items: el.items?.filter((item) => conditions(item.conditions, rows[0])),
-            });
-        });
-        // title, count
-        await Promise.all(panels
-            .filter((el) => el.items)
-            .map(async (el) => {
-            const filtered1 = el.items.filter((item) => item.count?.toLowerCase?.().includes("select"));
-            const data = await Promise.all(filtered1.map(async (item) => pg
-                .query(item.count.replace(/{{id}}/g, objectId))
-                .then((item1) => item1.rows[0] || {})));
-            filtered1.forEach((el1, i) => {
-                // el1.title = data[i].title;
-                Object.assign(el1, data[i] || {}, data[i].count ? {} : { count: undefined });
-            });
-            const q1 = el.items
-                .map((item) => item.component ? components[item.component] : null)
-                .filter((item) => item)
-                .join(" union all ");
-            const counts1 = q1 && objectId
-                ? await pg
-                    .query(q1, [objectId])
-                    .then((e) => e.rows.reduce((acc, curr) => Object.assign(acc, { [curr.component]: curr.count }), {}))
-                : {};
-            el.items
-                ?.filter?.((item) => item.component)
-                ?.forEach((item) => Object.assign(item, { count: counts1?.[item.component] }));
-        }));
-        // data result
-        const data = {};
-        if (index?.data && index?.data?.[0]?.name) {
-            await Promise.all(index.data
-                .filter((el) => el?.name && el?.sql)
-                .map(async (el) => {
-                const q2 = handlebarsSync.compile(el.sql)({
-                    data: rows[0],
-                    user,
-                    uid,
-                    id: objectId,
-                });
-                const { rows: sqlData } = await pg.query(q2);
-                data[el.name] = sqlData;
-            }));
-        }
-        // html
-        await Promise.all(template
-            .filter((el) => typeof el[1] === "string" && el[0].includes(".hbs"))
-            .map(async (el) => {
-            try {
-                const htmlContent = await handlebars.compile(el[1])({
-                    ...rows[0],
-                    user,
-                    data,
-                    tokens,
-                    actions,
-                });
-                const name = el[0].substring(0, el[0].lastIndexOf("."));
-                html[name] = htmlContent;
-            }
-            catch (err) {
-                const name = el[0].substring(0, el[0].lastIndexOf("."));
-                logger.file("handlebars/error", {
-                    table,
-                    id: objectId,
-                    error: err.toString(),
-                    stack: err.stack,
-                });
-                html[name] = "handlebars compile error";
-            }
-        }));
-        panels?.forEach?.((panel) => {
-            panel?.items?.forEach?.((el) => {
-                if (html[el.name]) {
-                    Object.assign(el, { html: html[el.name] });
-                }
-                el.items?.forEach?.((el1) => {
-                    Object.assign(el1, { html: html[el1.name] });
-                });
-            });
-        });
-    }
-    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", [resources[paramsTable] || paramsTable])
-            .then((el) => el.rows?.[0] || {})
-        : {};
-    const res = {
-        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],
-        },
-        route,
-        resource,
-        public: ispublic,
-        tokens,
-        card: !!(loadTable?.card ?? (await getTemplate("card", templateName))),
-        actions: tokenData?.actions || actionsParam || actions || ["view"],
-        total,
-        filtered,
-        count: rows.length,
-        pk,
-        form,
-        agg,
-        status,
-        panels,
-        html,
-        rows,
-        meta,
-        columns: columns1,
-        filters: filters?.map?.((el) => ({
-            ...el,
-            sql: undefined,
-            label: el.label || el.ua,
-        })),
-    };
-    if (!res.columns?.length && dbColumns?.length) {
-        Object.assign(res, {
-            columns: dbColumns.map(({ name, title, dataTypeID }) => ({
-                name,
-                title,
-                type: pg.pgType?.[dataTypeID],
-            })),
-        });
-    }
-    if (uid &&
-        // !config.security?.disableToken &&
-        actions.includes("add") &&
-        !objectId) {
-        const addTokens = setToken({
-            ids: [
-                JSON.stringify({
-                    resource,
-                    table: templateName,
-                    form: loadTable?.form,
-                    obj: tokenData?.obj || hookData?.obj,
-                }),
-            ],
-            uid,
-            array: 1,
-        });
-        Object.assign(res, { addToken: addTokens?.[0] });
-    }
-    const result = await applyHook("afterData", {
-        pg,
-        table: loadTable?.table || tokenData?.table,
-        id: objectId,
-        template: templateName,
-        payload: res,
-        user,
-    });
-    return result || res;
-}