@opengis/fastify-table 2.5.43 → 2.5.46

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

@@ -0,0 +1,703 @@
+import config from "../../../../config.js";
+import { handlebars, handlebarsSync } from "../../../helpers/index.js";
+import getAccess from "../../crud/funcs/getAccess.js";
+import setToken from "../../crud/funcs/setToken.js";
+import getToken from "../../crud/funcs/getToken.js";
+import gisIRColumn from "./gisIRColumn.js";
+import applyHook from "../../hook/applyHook.js";
+import getSelect from "./getSelect.js";
+import setOpt from "../../crud/funcs/setOpt.js";
+import getOpt from "../../crud/funcs/getOpt.js";
+import getFilter from "./getFilter.js";
+import logger from "../../logger/getLogger.js";
+import getTemplate from "./getTemplate.js";
+import getMeta from "../../pg/funcs/getMeta.js";
+import pgClients from "../../pg/pgClients.js";
+import metaFormat from "./metaFormat/index.js";
+import getFilterSQLParametrized from "./getFilterSQLParametrized/index.js";
+import extraDataGet from "../../extra/extraDataGet.js";
+import locales from "../../../routes/table/controllers/utils/locales.js";
+import conditions from "../../../routes/table/controllers/utils/conditions.js";
+import prettify from "../../../routes/table/functions/prettify.js";
+import { resources } from "../../access/funcs/getResources.js";
+import { BadRequestError, ForbiddenError, NotFoundError, UnauthorizedError, } from "../../../../errors.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({ table, id, page, limit: queryLimit, sql, filter: queryFilter, search: querySearch, state, custom, order: queryOrder, desc: queryDesc, bbox: bboxParam, polyline: polylineParam, query: queryParam, omitGeometry: omitGeometryParam = false, uid, referer, public: ispublicParam, userType, contextQuery, searchColumn, sufix = true, filterList, actions: actionsParam, accessQuery: accessQueryParam, columns: columnsParam, isExport = false, called = false, args: paramsArgs = [], }, pg = pgClients.client) {
+    const time = Date.now();
+    const timeArr = [Date.now()];
+    if (!table) {
+        throw BadRequestError("not enough params: table");
+    }
+    const hookData = (await applyHook("preData", {
+        pg,
+        table,
+        id,
+        user: { uid, user_type: userType },
+    }));
+    // 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(table, uid);
+    const tokenData2 = await getToken({
+        uid,
+        token: table,
+        json: true,
+    });
+    const tokenData = tokenData1 || tokenData2;
+    const resource = resources[table] ? table : undefined;
+    const templateName = resources[table] || tokenData?.table || hookData?.table || table;
+    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[table] && loadTable?.sql?.length && loadTable.table) {
+        const filterSql = loadTable.sql.filter((el) => !el?.disabled && (el.inline ?? true));
+        const sqlTable = filterSql
+            .map((el, i) => ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `)
+            ?.join("") || "";
+        const d = 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[table] = loadTable.sql;
+    }
+    else if (checkInline[table]) {
+        loadTable.sql = checkInline[table];
+    }
+    if (sql === 0 && process.platform === "win32")
+        return loadTable;
+    if (!pg) {
+        throw Error("empty pg");
+    }
+    const pkey = pg.pk?.[resources[table] || table] ||
+        pg.pk?.[resources[table] || table.replace(/"/g, "")] ||
+        (await getMeta({
+            pg,
+            table: resources[table] || loadTable?.table || table,
+        }))?.pk;
+    if (!loadTable &&
+        !(tokenData?.table && pg.pk?.[tokenData?.table]) &&
+        !(called && pkey)) {
+        throw NotFoundError("template not found");
+    }
+    const objectId = tokenData?.id || hookData?.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: { uid, userType },
+            method: "GET",
+        }, pg)) || {};
+    if (accessMessage) {
+        throw ForbiddenError(accessMessage);
+    }
+    const { table: table1, columns = [], sql: sqlQueryList, cardSql, form, meta, sqlColumns, editable = false, } = loadTable || hookData || tokenData || { table };
+    const ispublic = loadTable?.public ||
+        hookData?.public ||
+        tokenData?.public ||
+        ispublicParam ||
+        false;
+    if (!ispublic && !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: { uid, user_type: userType },
+        }, 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 || table}.${col.name}`] || {});
+    });
+    if (!pk) {
+        throw NotFoundError(`table not found: ${table1}`);
+    }
+    const idx = {};
+    const columnList = dbColumns.map((el) => el.name || el).join(",");
+    const sqlTable = sqlQueryList
+        ?.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`)
+            .then((r) => r.fields || [])
+        : await pg
+            .query(`select * from (${viewSql})q limit 0`)
+            .then((r) => r.fields || []);
+    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[table] || table,
+            column: objectId,
+            sql,
+            filter: queryFilter,
+            search: querySearch,
+            state,
+            custom,
+        });
+    }
+    const isdefault = !objectId ? filters.find((el) => el.default) : null;
+    const checkFilter = [
+        queryFilter,
+        querySearch,
+        state,
+        custom,
+        isdefault,
+    ].filter(Boolean).length;
+    const fData = checkFilter
+        ? await getFilterSQLParametrized({
+            pg,
+            table: loadTable
+                ? tokenData?.table || resources[table] || table
+                : table1,
+            filter: queryFilter,
+            search: querySearch,
+            searchColumn,
+            state,
+            custom,
+            uid,
+            objectId,
+            filterList,
+            args: paramsArgs,
+        })
+        : {
+            args: paramsArgs,
+        };
+    timeArr.push(Date.now());
+    const args = Array.from(fData.args || []);
+    if (objectId) {
+        args.push(objectId);
+        Object.assign(idx, { id: args.length });
+    }
+    const limit = (called
+        ? queryLimit || defaultLimit
+        : Math.min(maxLimit, +(queryLimit || defaultLimit))) || defaultLimit;
+    args.push(limit);
+    Object.assign(idx, { limit: args.length });
+    const offset = page && page > 0 && !objectId ? (page - 1) * limit : 0;
+    args.push(offset);
+    Object.assign(idx, { offset: args.length });
+    const order = getOrder({
+        queryOrder,
+        queryDesc,
+        defaultOrder: loadTable?.order,
+        columnList,
+        cols,
+        sqlColumns: loadTable?.sqlColumns,
+        iscalled: !!called,
+    });
+    const isSearchable = loadTable?.meta?.search &&
+        typeof loadTable.meta.search === "string" &&
+        querySearch &&
+        !idx.id;
+    if (isSearchable) {
+        args.push(`%${querySearch?.replace(/%/g, "\\%")}%`);
+        Object.assign(idx, { search: args.length });
+    }
+    if (meta?.bbox && polylineParam) {
+        args.push(polylineParam);
+        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 = bboxParam
+        ? bboxParam
+            .replace(/ /g, ",")
+            .split(",")
+            ?.map((el) => el - 0)
+        : [];
+    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 queryPolyline = meta?.bbox && polylineParam
+        ? `ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline($${idx.polyline})),${meta.bbox})`
+        : undefined;
+    const interfaceName = referer?.match?.(/.*\/([^?]+)/)?.[1];
+    const interfaceQuery1 = interfaceName && pg?.pk
+        ? await pg
+            .query("select query from admin.routes where route_id=$1", [
+            interfaceName,
+        ])
+            .then((r) => r.rows?.[0]?.query)
+        : null;
+    const interfaceQuery = queryParam
+        ? await handlebars.compile(queryParam)({ user: { uid }, uid })
+        : undefined;
+    const where = [
+        objectId ? ` "${pk}" = $${idx.id}` : null,
+        loadTable?.query,
+        tokenData?.query,
+        fData?.q,
+        search,
+        accessQuery || "1=1",
+        contextQuery,
+        bbox,
+        queryPolyline,
+        interfaceQuery,
+        interfaceQuery1,
+    ].filter(Boolean);
+    const omitGeometry = omitGeometryParam || (!objectId && loadTable?.showGeometryMode === "card");
+    const q1 = `select  ${pk ? `"${pk}" as id,` : ""} 
+  ${objectId ? "*" : 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 * ${sqlQueryList
+        ?.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 (sql === 1 && process.platform === "win32") {
+        return prettify(q, args);
+    }
+    const rows = await pg.query(q, args).then((r) => r.rows || []);
+    if (!rows.length &&
+        referer?.includes?.("/card/") &&
+        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 * ${sqlQueryList
+        ?.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 (sql === 2 && process.platform === "win32") {
+        return prettify(qCount, args1);
+    }
+    const counts = objectId
+        ? { total: rows.length, filtered: rows.length }
+        : await pg
+            .queryCache?.(qCount, {
+            args: args1,
+            table: loadTable?.table || tokenData?.table || table,
+            time: 5,
+        })
+            .then((r) => r.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 (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") ||
+                userType === "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 },
+                        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) => {
+                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 },
+                    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: { uid },
+                    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[table] || table])
+            .then((r) => r.rows?.[0] || {})
+        : {};
+    const card = !!(loadTable?.card ?? (await getTemplate("card", templateName)));
+    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,
+        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 && 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: { uid, user_type: userType },
+    });
+    return result || res;
+}