@opengis/admin 0.1.59 → 0.1.61

package/server/plugins/hook.js

@@ -1,228 +1,152 @@
-import fp from 'fastify-plugin';
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { addHook, getTemplatePath, getTemplate, pgClients } from '@opengis/fastify-table/utils.js';
-
-import getMenu from '../routes/menu/controllers/getMenu.js';
-
-import config from '../../config.js';
-
-// to export the decorators to the outer scope
-
-async function plugin(fastify) {
-  fastify.decorate('config', config);
-
-  addHook('afterTemplate', async ({ req, data = {} }) => {
-    const { uid } = req.session?.passport?.user || {};
-    if (!uid || !data || req.params?.type !== 'form' || !req.params?.name) return null;
-    const { pg, params = {} } = req;
-    const { rows: properties = [] } = await pg.query(`select name, title, format, data from admin.custom_column 
-      where entity=$1 and uid=$2`, [params.name?.replace('.form', '.table'), uid]);
-    await Promise.all(properties.map(async (el) => {
-      const clsData = el.data ? await getTemplate(['cls', 'select'], el.data) : undefined;
-      const type = clsData ? 'Select' : ({ date: 'DatePicker' }[el.format] || 'Text');
-      Object.assign(data?.schema || data || {}, { [el.name]: { type, ua: el.title, data: el.data, options: type === 'Select' && Array.isArray(clsData) && clsData?.length ? clsData : undefined, extra: 1 } });
-    }));
-  });
-
-  addHook('afterUpdate', async ({ req, res = {} }) => {
-    const {
-      pg, session = {}, params = {}, body = {},
-    } = req;
-    const { uid } = session?.passport?.user || {};
-    if (!uid) return null;
-
-    const loadTable = await getTemplate('table', params.table);
-    if (!pg.pk[loadTable?.table || params.table]) return null;
-    const pk = pg.pk[loadTable?.table || params.table];
-    const id = res[pk];
-
-    const { rows: properties = [] } = await pg.query(`select column_id, name, title, format, data from admin.custom_column 
-    where entity=$1 and uid=$2`, [params.table, uid]);
+import { addHook, getToken, setToken, getTemplate } from '@opengis/fastify-table/utils.js';
+
+export default async function plugin(fastify) {
+
+    addHook('preTable', async ({ req }) => {
+        if (!req?.routeOptions?.method) return;
+        const mode = { POST: 'a', DELETE: 'w', PUT: 'w', GET: 'w' }[req.routeOptions.method] || 'w';
+        const { funcs, params = {}, session = {} } = req;
+        const { uid } = funcs?.config?.auth?.disable ? { uid: '1' } : (session?.passport?.user || {});
+        const opt = await getToken({
+            uid, token: params.id || params.form || params.table, mode, json: 1,
+        });
+        if (opt) Object.assign(req, { opt });
+        if (!opt && !funcs?.config?.local) {
+            return { message: 'access restricted: edit', status: 403 };
+        }
+        return null;
+    });
+
+    addHook('afterTable', async ({ req = {}, res = {}, rows = [], table }) => {
+        const { pg, funcs, params = {}, session = {} } = req;
+        const { uid } = funcs?.config?.auth?.disable ? { uid: '1' } : (session?.passport?.user || {});
+        if (!uid || !table || !pg?.pk?.[table] || !rows.length || !params.table) return;
+
+        // admin.custom_column - user column data
+        const { rows: properties = [] } = await pg.query(`select column_id, name, title, format, data from admin.custom_column 
+    where _table and entity=$1 and uid=$2`, [params.table, uid]);
+        const extraColumnList = properties.map((row) => ({ id: row.column_id, name: row.name, title: row.title, format: row.format, data: row.data }));
+        if (!extraColumnList?.length) return;
+
+        if (res?.columns?.length) {
+            extraColumnList.forEach((col) => res.columns.push(col));
+        }
 
-    if (!id || !properties?.length) return null;
+        const { rows: extraData = [] } = await pg.query(`select object_id, json_object_agg( property_id, coalesce(value_date::text,value_text) ) as extra from crm.extra_data 
+    where property_entity=$1 and property_id=any($2) and object_id=any($3) group by object_id`, [params.table, extraColumnList?.map((el) => el.id), rows.map((el) => el.id)]);
 
-    const q = `delete from crm.extra_data where property_entity='${params.table}' and object_id='${id}';${properties
-      .filter((el) => Object.keys(body).includes(el.name))
-      .map((el) => `insert into crm.extra_data(property_id,property_key,property_entity,object_id,${el.format?.toLowerCase() === 'date' ? 'value_date' : 'value_text'})
+        if (!extraData?.length) {
+            // Object.assign(rows?.[0] || {}, { ...extraColumnList.reduce((acc, curr) => Object.assign(acc, { [curr.name]: null }), {}) });
+            return;
+        }
+
+        rows.filter((row) => extraData.map((el) => el?.object_id).includes(row.id)).forEach((row) => {
+            const { extra = {} } = extraData.find((el) => el.object_id === row.id);
+            Object.assign(row, { ...Object.fromEntries(Object.entries(extra).map((el) => [extraColumnList.find((col) => col.id === el[0]).name, el[1]])) });
+        });
+
+        // admin.custom_column - metaFormat
+        await Promise.all(extraColumnList.filter((el) => el?.data).map(async (attr) => {
+            const values = [...new Set(rows?.map((el) => el[attr.name]).flat())].filter((el) => el);
+            if (!values.length) return;
+            const cls = await getSelectVal({ name: attr.data, values });
+            if (!cls) return;
+            rows.forEach(el => {
+                const val = el[attr.name]?.map?.(c => cls[c] || c) || cls[el[attr.name]] || el[attr.name];
+                if (!val) return;
+                Object.assign(el, { [val?.color ? `${attr.name}_data` : `${attr.name}_text`]: (val.color ? val : val.text || val) });
+            });
+        }));
+    });
+
+    // extract table from form token for user columns - p.2 - read (refactor to global token)
+    /* addHook('preTemplate', async ({ req = {} }) => {
+        const { funcs, params = {}, session = {} } = req;
+        const { uid } = funcs?.config?.auth?.disable ? { uid: '1' } : (session?.passport?.user || {});
+        if (!uid || params?.type !== 'form' || !params?.name) return null;
+
+        const { table, form } = await getToken({
+            uid, token: params.name, mode: 'w', json: 1,
+        }) || {};
+        if (form) {
+            Object.assign(req.params || {}, { name: form, table });
+        }
+    }); */
+
+    addHook('afterTemplate', async ({ req = {}, data = {} }) => {
+        const { funcs, session = {} } = req;
+        const { uid } = funcs?.config?.auth?.disable ? { uid: '1' } : (session?.passport?.user || {});
+        const { pg, params = {} } = req;
+        // extract table from form token for user columns - p.1 - assign (refactor to global token)
+        /* if (params?.type === 'table') {
+            const { form } = await getTemplate('table', params.name) || {};
+            if (!form) return;
+            const editTokens = setToken({
+                ids: [{ table: params.name, form }],
+                mode: 'w',
+                uid,
+                array: 1,
+            });
+            Object.assign(data, { token: editTokens[0] });
+        } */
+        if (!uid || !data || params?.type !== 'form' || !params?.name) return null;
+
+        const { rows: properties = [] } = await pg.query(`select name, title, format, data from admin.custom_column 
+        where entity=$1 and uid=$2`, [params.table || params.name, uid]);
+        await Promise.all(properties.map(async (el) => {
+            const clsData = el.data ? await getTemplate(['cls', 'select'], el.data) : undefined;
+            const type = clsData ? 'Select' : ({ date: 'DatePicker' }[el.format] || 'Text');
+            Object.assign(data?.schema || data || {}, { [el.name]: { type, ua: el.title, data: el.data, options: type === 'Select' && Array.isArray(clsData) && clsData?.length ? clsData : undefined, extra: 1 } });
+        }));
+    });
+
+    addHook('afterUpdate', async ({ req, res = {} }) => {
+        const {
+            pg, funcs, session = {}, params = {}, body = {},
+        } = req;
+        const { uid } = funcs?.config?.auth?.disable ? { uid: '1' } : (session?.passport?.user || {});
+        if (!uid) return null;
+
+        const loadTable = await getTemplate('table', params.table);
+        if (!pg.pk[loadTable?.table || params.table]) return null;
+        const pk = pg.pk[loadTable?.table || params.table];
+        const id = res[pk];
+
+        const { rows: properties = [] } = await pg.query(`select column_id, name, title, format, data from admin.custom_column 
+        where entity=$1 and uid=$2`, [params.table, uid]);
+
+        if (!id || !properties?.length) return null;
+
+        const q = `delete from crm.extra_data where property_entity='${params.table}' and object_id='${id}';${properties
+            .filter((el) => Object.keys(body).includes(el.name))
+            .map((el) => `insert into crm.extra_data(property_id,property_key,property_entity,object_id,${el.format?.toLowerCase() === 'date' ? 'value_date' : 'value_text'})
         select '${el.column_id}', '${el.name}', '${params.table}', '${id}', ${el.format?.toLowerCase() === 'date' ? `'${body[el.name]}'::timestamp without time zone` : `'${body[el.name]}'::text`}`)
-      .join(';\n') || ''}`;
-    return pg.query(q);
-  });
-
-  addHook('afterInsert', async ({ req, res = {} }) => {
-    const {
-      pg, session = {}, params = {}, body = {},
-    } = req;
-    const { uid } = session?.passport?.user || {};
-    if (!uid) return null;
-
-    const loadTable = await getTemplate('table', params.table);
-    if (!pg.pk[loadTable?.table || params.table]) return null;
-    const pk = pg.pk[loadTable?.table || params.table];
-    const id = res.rows?.[0]?.[pk];
-
-    const { rows: properties = [] } = await pg.query(`select column_id, name, title, format, data from admin.custom_column 
+            .join(';\n') || ''}`;
+        return pg.query(q);
+    });
+
+    addHook('afterInsert', async ({ req, res = {} }) => {
+        const {
+            pg, funcs, session = {}, params = {}, body = {},
+        } = req;
+        const { uid } = funcs?.config?.auth?.disable ? { uid: '1' } : (session?.passport?.user || {});
+        if (!uid) return null;
+
+        const loadTable = await getTemplate('table', params.table);
+        if (!pg.pk[loadTable?.table || params.table]) return null;
+        const pk = pg.pk[loadTable?.table || params.table];
+        const id = res.rows?.[0]?.[pk];
+
+        const { rows: properties = [] } = await pg.query(`select column_id, name, title, format, data from admin.custom_column 
     where entity=$1 and uid=$2`, [params.table, uid]);
 
-    if (!id || !properties?.length) return null;
+        if (!id || !properties?.length) return null;
 
-    const q = properties
-      .filter((el) => Object.keys(body).includes(el.name))
-      .map((el) => `insert into crm.extra_data(property_id,property_key,property_entity,object_id,${el.format?.toLowerCase() === 'date' ? 'value_date' : 'value_text'})
+        const q = properties
+            .filter((el) => Object.keys(body).includes(el.name))
+            .map((el) => `insert into crm.extra_data(property_id,property_key,property_entity,object_id,${el.format?.toLowerCase() === 'date' ? 'value_date' : 'value_text'})
         select '${el.column_id}', '${el.name}', '${params.table}', '${id}', ${el.format?.toLowerCase() === 'date' ? `'${body[el.name]}'::timestamp without time zone` : `'${body[el.name]}'::text`}`)
-      .join(';\n');
-    return pg.query(q);
-  });
-
-  fastify.addHook('onListen', async () => {
-    const { client } = pgClients;
-    const json = await getMenu();
-    // insert interface list to db (user access management)
-    if (client?.pk?.['admin.routes'] && json?.length) {
-      const menuList = json.filter((el) => el?.menu?.length && el?.ua || el?.en || el?.name);
-      const interfaces = menuList.reduce((acc, curr) => { curr.menu.forEach((el) => acc.push(el.path)); return acc; }, []);
-      await client.query('update admin.routes set enabled=false where not array[route_id] <@ $1::text[]', [interfaces]);
-
-      const q = `insert into admin.menu(name, ord) values${menuList.map((el, i) => `('${(el?.ua || el?.en || el?.name).replace(/'/g, '’')}', ${i}) `).join(',')
-        } on conflict (name) do update set ord=excluded.ord, enabled=true returning name, menu_id`;
-      const { rows = [] } = await client.query(q);
-      await client.query('update admin.menu set enabled=false where not array[menu_id] <@ $1::text[]', [rows.map((el) => el.menu_id)]);
-
-      const menus = rows.reduce((acc, curr) => Object.assign(acc, { [curr.menu_id]: menuList.find((item) => (item?.ua || item?.en || item?.name) === curr.name) }), {});
-      const values = Object.entries(menus).reduce((acc, curr) => { curr[1]?.menu?.forEach((el) => acc.push({ ...el, menuId: curr[0] })); return acc; }, []);
-
-      await Promise.all(values.filter((el) => el?.table).map(async (el) => Object.assign(el, { table: (await getTemplate('table', el.table))?.table || el.table })));
-
-      const q1 = `insert into admin.routes(route_id, alias, title, menu_id, table_name) values ${values.map((el) => `('${el.path}', '${el.path}', '${el.title}', '${el.menuId}', '${el.table}')`).join(',')} 
-      on conflict (route_id) do update set menu_id=excluded.menu_id, title=excluded.title, enabled=true,
-      table_name=excluded.table_name returning route_id, table_name`;
-      try {
-        const { rowCount } = await client.query(q1);
-        // console.log('interface insert ok', values, rowCount);
-      } catch (err) {
-        console.log('interface insert error', values, q1, err);
-      }
-    }
-  });
-
-  fastify.addHook('onListen', async () => {
-    const { client: pg } = pgClients;
-    const clsQuery = [];
-    if (!pg.pk?.['admin.cls']) return;
-
-    const selectList = await getTemplatePath('select');
-    const clsList = (await getTemplatePath('cls'))?.filter((el) => !(selectList?.map((el) => el?.[0]) || []).includes(el[0]));
-    const cls = (selectList || []).concat(clsList || [])
-      ?.map((el) => ({ name: el[0], module: path.basename(path.dirname(path.dirname(el[1]))), type: { 'json': 'cls', 'sql': 'select' }[el[2]] }))
-    if (!cls?.length) return;
-
-    const dupes = cls.filter((el, idx, arr) => arr.map((item) => item.name).indexOf(el.name) !== idx);
-    // console.log('cls insert skip dupes', dupes.map((el) => el.name));
-
-    try {
-      await Promise.all(cls.filter((el, idx, arr) => arr.map((item) => item.name).indexOf(el.name) === idx).map(async (el) => {
-        const { name, module, type } = el;
-        const loadTemplate = await getTemplate(type, name);
-        //console.log(name, type);
-        if (type === 'select') {
-          clsQuery.push(`insert into admin.cls(name,type,data,module) values('${name}','sql','${(loadTemplate?.sql || loadTemplate)?.replace(/'/g, "''")}', '${module?.replace(/'/g, "''")}')`);
-        } else if (type === 'cls' && loadTemplate?.length) {
-          clsQuery.push(`insert into admin.cls(name,type, module) values('${name}','json', '${module?.replace(/'/g, "''")}'); 
-            insert into admin.cls(code,name,parent,icon) 
-            select value->>'id',value->>'text','${name}',value->>'icon' 
-            from json_array_elements('${JSON.stringify(loadTemplate).replace(/'/g, "''")}'::json)`);
-        } else {
-          console.log(name, type, 'empty');
-        }
-      }));
-
-      await pg.query('truncate admin.cls');
-      if (clsQuery.filter((el) => el).length) {
-        await pg.query(clsQuery.filter((el) => el).join(';'));
-        console.log('cls insert ok', clsQuery?.length);
-      }
-    } catch (err) {
-      console.error('cls insert error', err.toString());
-    }
-  });
-
-  // pre Request
-  fastify.addHook('onRequest', async (req) => {
-    req.funcs = fastify;
-    const { user } = req.session?.passport || {};
-    req.user = user;
-  });
-
-  // preSerialization
-  fastify.addHook('preSerialization', async (req, reply, payload) => {
-    if (req.url.includes('/suggest/') && !req.query.json) {
-      return payload?.data;
-    }
-    if (payload?.redirect) {
-      return reply.redirect(payload.redirect);
-    }
-    if (reply.sent) {
-      return null;
-    }
-
-    if (['200', '400', '500', '403', '404'].includes(payload?.status)) {
-      reply.status(payload.status);
-    }
-    /* if (payload.headers) {
-      reply.headers(payload.headers);
-    } */
-    if (payload?.buffer) {
-      return payload.buffer;
-    }
-    if (payload?.file) {
-      // const buffer = await readFile(payload.file);
-      // return reply.send(buffer);
-      const stream = fs.createReadStream(payload.file);
-      return stream;
-      // return reply.send(stream);
-    }
-
-    if (payload?.message) {
-      return payload.message;
-    }
-    return payload;
-  });
-
-  //  preValidation
-  fastify.addHook('preValidation', async (req) => {
-    const parseRawBody = ['POST', 'PUT'].includes(req.method) && req.body && typeof req.body === 'string'
-      && req.body.trim(/\r\n/g).startsWith('{')
-      && req.body.trim(/\r\n/g).endsWith('}');
-    if (parseRawBody) {
-      try {
-        req.body = JSON.parse(req.body || '{}');
-      }
-      catch (err) {
-        // throw new Error('invalid body');
-        // return { error: 'invalid body', status: 400 };
-      }
-    }
-  });
-
-  // allow upload file
-  const kIsMultipart = Symbol.for('[FastifyMultipart.isMultipart]');
-  fastify.addContentTypeParser('multipart', (request, _, done) => {
-    request[kIsMultipart] = true;
-    done(null);
-  });
-
-  // parse Body
-  function contentParser(req, body, done) {
-    const parseBody = decodeURIComponent(body.toString()).split('&').reduce((acc, el) => {
-      const [key, val] = el.split('=');
-      return { ...acc, [key]: val };
-    }, {});
-    done(null, parseBody);
-  }
-
-  fastify.addContentTypeParser('application/x-www-form-urlencoded', { parseAs: 'buffer' }, contentParser);
-}
-
-export default fp(plugin);
+            .join(';\n');
+        return pg.query(q);
+    });
+}

package/server/routes/data/controllers/cardData.js

@@ -2,9 +2,10 @@ import { setToken, getTemplate } from "@opengis/fastify-table/utils.js";
 // import yaml from 'js-yaml';
 import getTableData from "./tableData.js";
 
-export default async function getCardData({
-    pg, funcs, params = {}, session = {},
-}) {
+export default async function getCardData(req) {
+    const {
+        pg, funcs, params = {}, session = {},
+    } = req;
     const { table, id } = params;
     const { uid } = session.passport?.user || {};
 
@@ -40,7 +41,7 @@ export default async function getCardData({
     }
 
     const data = {};
-    const { message, rows = [] } = await getTableData({ pg, funcs, params: { table, id }, session, mode: 'card' });
+    const { message, rows = [] } = await getTableData({ pg, funcs, params: { table, id }, session });
 
     if (message) return { message };
 

package/server/routes/data/controllers/funcs/getFilterSQL/util/formatValue.js

@@ -54,7 +54,7 @@ function formatValue({
     const min = formatDateISOString(startDate);
     const max = formatDateISOString(endDate);
     const query = extra && pk
-      ? `${pk} in (select object_id from setting.extra_data where property_key='${name}' and value_date::date >= '${min}'::date and value_date::date <= '${max}'::date)`
+      ? `${pk} in (select object_id from crn.extra_data where property_key='${name}' and value_date::date >= '${min}'::date and value_date::date <= '${max}'::date)`
       : `${name}::date >= '${min}'::date and ${name}::date <= '${max}'::date`;
     return { op: 'between', query, extra };
   }
@@ -93,8 +93,8 @@ function formatValue({
     const values = value.split(',').filter((el) => el !== 'null');
     if (extra && pk) {
       const query = value?.indexOf('null') !== -1
-        ? `${pk} in (select object_id from setting.extra_data where property_key='${name}' and ( value_text is null or value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) ) )`
-        : `${pk} in (select object_id from setting.extra_data where property_key='${name}' and value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) )`;
+        ? `${pk} in (select object_id from crm.extra_data where property_key='${name}' and ( value_text is null or value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) ) )`
+        : `${pk} in (select object_id from crm.extra_data where property_key='${name}' and value_text in (${values?.map((el) => `'"${el}"'`).join(',')}) )`;
       return { op: 'in', query, extra };
     }
     const query = value?.indexOf('null') !== -1
@@ -136,8 +136,8 @@ function formatValue({
     const match = operator1 === '=' ? `='${value}'` : `ilike '%${value}%'`;
     if (extra && pk) {
       const query = data && sql
-        ? `${pk} in (select object_id from setting.extra_data where property_key='${name}' and value_text in ( ( with q(id,name)  as  (${sql}) select id from q where name ${match})))`
-        : `${pk} in (select object_id from setting.extra_data where property_key='${name}' and value_text ${match})`
+        ? `${pk} in (select object_id from crm.extra_data where property_key='${name}' and value_text in ( ( with q(id,name)  as  (${sql}) select id from q where name ${match})))`
+        : `${pk} in (select object_id from crm.extra_data where property_key='${name}' and value_text ${match})`
       return { op: 'ilike', query, extra };
     }
 

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

@@ -1,5 +1,5 @@
 import {
-    getMeta, getAccess, getTemplate, metaFormat, getSelectVal, gisIRColumn,
+    applyHook, getMeta, getAccess, getTemplate, metaFormat, getTableColumn,
 } from "@opengis/fastify-table/utils.js";
 
 import getFilterSQL from "./funcs/getFilterSQL/index.js";
@@ -36,9 +36,8 @@ export default async function getTableData(req) {
             return { message: `table not found: ${table}`, status: 404 };
         }
 
-        const { cols, columnList, extraKeys, schema } = await getColumns({
-            pg, columns, params, opt, loadTable, form, table, dbColumns, mode, uid,
-        });
+        const columnList = dbColumns.map((el) => el.name || el).join(',');
+        const cols = columns.filter((el) => columnList.includes(el?.name) && el?.name !== 'geom').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(',')}`
@@ -47,7 +46,7 @@ export default async function getTableData(req) {
         const sqlTable = sql?.filter?.((el) => !el?.disabled && el?.sql?.replace).map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
 
         if (params.id && columnList.includes(params.id)) {
-            return gisIRColumn({
+            return getTableColumn({
                 pg, funcs, layer: params.table, column: params.id, sql: query.sql,
             });
         }
@@ -95,47 +94,15 @@ export default async function getTableData(req) {
 
         const total = keyQuery || opt?.id || params.id ? rows.length : await pg.queryCache(`select count(*) from ${table} t ${sqlTable} where ${where.join(' and ') || 'true'}`).then((el) => (el?.rows[0]?.count || 0) - 0);
 
-        // form DataTable
-        if (extraKeys?.length && mode === 'card') {
-            await Promise.all(rows?.map(async (row) => {
-                await Promise.all(extraKeys?.map(async (key) => {
-                const { colModel, table: extraTable, parent_id: parentId } = schema[key];
-                const { rows: extraRows } = await pg.query(`select ${parentId} as parent, ${colModel.map((col) => col.name).join(',')} from ${extraTable} a where ${parentId}=$1`, [row.id]);
-                Object.assign(row, { [key]: extraRows });
-                }));
-            }));
-        }
-
-        // admin.custom_column - user column data
-        const { rows: properties = [] } = await pg.query(`select column_id, name, title, format, data from admin.custom_column 
-        where _table and entity=$1 and uid=$2`, [params.table, uid]);
-        const extraColumnList = properties.map((row) => ({ id: row.column_id, name: row.name, title: row.title, format: row.format, data: row.data }));
-        extraColumnList.forEach((col) => columns.push(col));
-        const { rows: extraData = [] } = await pg.query(`select object_id, json_object_agg( property_id, coalesce(value_date::text,value_text) ) as extra from crm.extra_data 
-        where property_entity=$1 and property_id=any($2) and object_id=any($3) group by object_id`, [params.table, extraColumnList?.map((el) => el.id), rows.map((el) => el.id)]);
-        rows.filter((row) => extraData.map((el) => el?.object_id).includes(row.id)).forEach((row) => {
-            const { extra = {} } = extraData.find((el) => el.object_id === row.id);
-            Object.assign(row, { ...Object.fromEntries(Object.entries(extra).map((el) => [extraColumnList.find((col) => col.id === el[0]).name, el[1]])) });
-        });
-
-        // admin.custom_column - metaFormat
-        await Promise.all(extraColumnList.filter((el) => el?.data).map(async (attr) => {
-            const values = [...new Set(rows?.map((el) => el[attr.name]).flat())].filter((el) => el);
-            if (!values.length) return;
-            const cls = await getSelectVal({ name: attr.data, values });
-            if (!cls) return;
-            rows.forEach(el => {
-                const val = el[attr.name]?.map?.(c => cls[c] || c) || cls[el[attr.name]] || el[attr.name];
-                if (!val) return;
-                Object.assign(el, { [val?.color ? `${attr.name}_data` : `${attr.name}_text`]: (val.color ? val : val.text || val) });
-            });
-        }));
-
-        await metaFormat({ funcs, rows, table: params.table });
 
         const res = {
             time: Date.now() - time, card: loadTable.card, actions: loadTable.actions, access, total, count: rows.length, pk, form, meta, columns,
         };
+
+        await applyHook('afterTable', { req, res, table, rows });
+        await metaFormat({ funcs, rows, table: params.table });
+
+
         const addToken = assignTokens({ rows, funcs, ispublic, uid: 1, loadTable });
         Object.assign(res, { rows, addToken });
 

package/server/routes/data/controllers/tableFilter.js

@@ -15,7 +15,7 @@ export default async function tableFilter(req) {
         return { message: 'table not found', status: 404 };
     }
 
-    const { columns } = await funcs.getMeta({ table: loadTable.table });
+    const { columns = [] } = await funcs.getMeta({ table: loadTable.table });
 
     const filters = loadTable?.filter_list || loadTable?.filters || loadTable?.filterList || [];
     filters.forEach(el => {
@@ -32,9 +32,9 @@ export default async function tableFilter(req) {
         const name = el.name || el.id;
 
         if (!cls?.length || !Array.isArray(cls) || !loadTable.table || !name) return;
-        const { dataTypeID } = columns.find((item) => item.name === name) || {};
+        const { dataTypeID } = columns.find((item) => item?.name === name) || {};
         if (el.extra && el.type === 'select' && Array.isArray(cls)) {
-            const countArr = await pg.query(`select value_text as id, count(*) from setting.extra_data where property_key='${name}' and property_entity='${params.name}' group by value_text`);
+            const countArr = await pg.query(`select value_text as id, count(*) from crm.extra_data where property_key='${name}' and property_entity='${params.name}' group by value_text`);
             const options = countArr.rows.map(cel => {
                 const data = cls.find(c => c.id === cel.id);
                 return { ...cel, ...data };

package/server/routes/data/controllers/utils/getColumns.js

@@ -4,19 +4,6 @@ export default async function getColumns({
     columns = [], params = {}, opt = {}, loadTable = {}, form, table, dbColumns = [], mode = 'table',
 }) {
     const columnList = dbColumns.map((el) => el.name || el).join(',');
-    if (mode === 'table') {
-        const cols = columns.filter((el) => columnList.includes(el?.name) && el?.name !== 'geom').map((el) => el?.name || el).join(',');
-        return { cols, columnList };
-    }
-    // card / edit form
-    const schema = await getTemplate('form', opt?.form || form) || {};
-    // skip DataTable from another table
-    const extraKeys = Object.keys(schema)?.filter((key) => schema[key]?.type === 'DataTable' && schema[key]?.table && schema[key]?.parent_id && schema[key]?.colModel?.length);
-    // skip non-existing columns
-    const { fields = [] } = !loadTable?.table ? await pg.query(`select * from ${table || opt?.table || params.table} limit 0`) : {};
-    const cols = loadTable?.table
-        ? Object.keys(schema || {}).filter((col) => columnList.includes(col) && !extraKeys.includes(col))?.join(',')
-        : fields.map((el) => (el?.name?.includes('geom') ? `st_asgeojson(${el.name})::json as "${el.name}"` : `"${el?.name}"`)).join(',');
-    
-    return { cols, columnList, extraKeys, schema };
+    const cols = columns.filter((el) => columnList.includes(el?.name) && el?.name !== 'geom').map((el) => el?.name || el).join(',');
+    return { cols, columnList };
 }

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

@@ -1,8 +1,12 @@
 import { applyHook, getTemplate } from "@opengis/fastify-table/utils.js";
 
 export default async function getTemplateApi(req) {
-    const { funcs, params, session = {} } = req;
+    const res = await applyHook('preTemplate', { req });
+    if (res) return res;
+
+    const { funcs, params = {}, session = {} } = req;
     const { type, name } = params;
+
     const data = await getTemplate(type, name);
     if (!['interface', 'table'].includes(type)
         && (!data?.public || !data?.ispublic)