@opengis/fastify-table 1.4.22 → 1.4.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.4.22",
+  "version": "1.4.24",
   "type": "module",
   "description": "core-plugins",
   "keywords": [

package/server/plugins/crud/funcs/dataInsert.js

@@ -41,8 +41,9 @@ export default async function dataInsert({
   // for transactions
   const isClient = typeof pg.query === 'function' && typeof pg.release === 'function';
   const client = isClient ? pg : await pg.connect();
+
   if (!isClient) {
-    client.caller = 'dataInsert';
+    // client.caller = 'dataInsert';
   }
 
   if (isClient || !client.pk) {
@@ -54,7 +55,7 @@ export default async function dataInsert({
   }
 
   try {
-    if (client.caller === 'dataInsert') {
+    if (!isClient) {
       await client.query('begin;');
     }
     const res = await client.query(insertQuery, args).then(el => el || {});
@@ -107,7 +108,7 @@ export default async function dataInsert({
     });
 
     if (config.redis) { rclient.incr(`pg:${table}:crud`); }
-    if (client.caller === 'dataInsert') {
+    if (!isClient) {
       await client.query('commit;');
     }
     return res;
@@ -116,13 +117,13 @@ export default async function dataInsert({
     logger.file('crud/insert', {
       error: err.toString(), stack: err.stack, table, id, referer, uid, form: tokenData?.form,
     });
-    if (client.caller === 'dataInsert') {
+    if (!isClient) {
       await client.query('rollback;');
     }
     throw err;
   }
   finally {
-    if (client.caller === 'dataInsert') {
+    if (!isClient) {
       client.release();
     }
   }

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

@@ -42,7 +42,7 @@ export default async function tableAPI(req, reply) {
     return reply.status(400).send('invalid token');
   }
 
-  if (!actions.includes('edit') && !config?.local) {
+  if (!actions.includes('edit') && !config?.local && !tokenData) {
     return reply.status(403).send('access restricted: actions');
   }
 

package/server/routes/properties/controllers/admin.properties.get.js

@@ -0,0 +1,23 @@
+/* eslint-disable camelcase */
+const table = 'admin.properties';
+
+import { pgClients, getTemplatePath, getTemplate } from '../../../../utils.js';
+
+export default async function getSettingsApp({
+  pg = pgClients.client,
+}, reply) {
+  const time = Date.now();
+
+  if (!pg.pk?.[table]) {
+    return reply.status(404).send('table not found');
+  }
+
+  const { rows = [] } = await pg.query('select property_key as key, property_text, property_json from admin.properties');
+
+  const settings = rows.reduce((acc, { key, property_text, property_json }) => ({ ...acc, [key]: property_text || property_json }), {});
+
+  const forms = await Promise.all(getTemplatePath('setting')
+    .map(async (el) => ({ name: el[0], body: await getTemplate('setting', el[0]) })));
+
+  return reply.status(200).send({ time: Date.now() - time, forms, settings });
+}

package/server/routes/properties/controllers/admin.properties.post.js

@@ -0,0 +1,50 @@
+const table = 'admin.properties';
+
+import { dataInsert, pgClients } from '../../../../utils.js';
+
+function checkValueType(val) {
+  if (val) {
+    if (typeof val === 'object') {
+      return 'property_json';
+    }
+    if (typeof val === 'number' && (!/\D/.test(val.toString()) && val.toString().length < 10)) {
+      return 'property_int';
+    }
+  }
+  return 'property_text';
+}
+
+export default async function postSettingsApp({
+  pg = pgClients.client, body = {}, user = {}, uid = user?.uid,
+}, reply) {
+  if (!user?.user_type?.includes?.('admin')) {
+    return reply.status(403).send('access restricted');
+  }
+  const { key, val } = body;
+
+  if ((!key || !val) && !Object.keys(body).length) {
+    return reply.status(400).send('not enough body params');
+  }
+
+  if (!pg?.pk?.[table]) {
+    return reply.status(404).send('table not found');
+  }
+
+  const keys = Object.keys(body);
+  await pg.query(`delete from ${table} where property_key=any($1)`, [keys]);
+
+  await Promise.all(keys.filter(el => body[el]).map(async (el) => {
+    const columnType = table === 'admin.user_properties'
+      ? 'property_json'
+      : checkValueType(body[el]);
+
+    await dataInsert({
+      pg,
+      table,
+      data: { property_key: el, [columnType]: body[el] },
+      uid,
+    });
+  }));
+
+  return reply.status(200).send('ok');
+}

package/server/routes/properties/controllers/table.properties.get.js

@@ -0,0 +1,112 @@
+import { pgClients, getMeta, getTemplate } from '../../../../utils.js';
+
+import getColumnMetaData from '../utils/getColumnMetaData.js';
+
+/**
+ *
+ * @method GET
+ * @priority 4
+ * @alias getSettingsTable
+ * @type api
+ * @tag custom
+
+ * @returns {String} message and status
+ */
+
+export default async function getSettingsTable({
+  pg = pgClients.client, params = {}, user = {}, query = {},
+}, reply) {
+  const { table, entity } = params;
+  const { uid } = user;
+  const time = [];
+
+  if (!uid) {
+    return reply.status(401).send('unauthorized');
+  }
+
+  if (!table) {
+    return reply.status(400).send('not enough params: table');
+  }
+
+  const loadTable = await getTemplate('table', table);
+
+  const tableName = loadTable?.table || table;
+  const meta = await getMeta({ pg, table: tableName });
+  const { view, pk } = meta || {};
+  time.push(Date.now());
+
+  if (!pk && !view) {
+    return reply.status(400).send(`table primary key not found: ${tableName}`);
+  }
+
+  const { rows: geometry } = meta?.geom
+    ? await pg.queryCache(`select st_geometrytype(${meta?.geom}) as type ,count(*) 
+    from ${tableName} group by st_geometrytype(${meta?.geom})`, { table: tableName }) : [];
+  time.push(Date.now());
+
+  const stat = !view ? await getColumnMetaData({ pg, table: tableName }) : {};
+  time.push(Date.now());
+
+  const { total = 0 } = await pg.queryCache(`select count(*) as total from ${tableName}`, { table: tableName })
+    .then(el => el.rows?.[0] || {});
+  time.push(Date.now());
+
+  const { property_json: customColumns = [] } = await pg.query(`select property_json::json from setting.property 
+  where property_entity='customColumn' and object_id=$1`, [table]).then(el => el.rows?.[0] || {});
+
+  const { property_json: tableSettingColumns } = await pg.query(`select property_json::json from setting.property 
+  where property_entity='column' and object_id=$1`, [table]).then(el => el.rows?.[0] || {});
+
+  const columns = (tableSettingColumns || loadTable?.columns || meta?.columns)?.map((el) => ({ ...el, title: el.title || el.name }))
+    ?.filter((value, index, array) => array?.map((el) => el.name).indexOf(value.name) === index); // get unique columns
+
+  const cls = columns?.filter((el) => ['badge', 'select'].includes(el.format) && (el.option || el.data))
+    ?.map((el) => (el.option || el.data))
+    ?.filter((value, index, array) => array.indexOf(value) === index); // get unique cls
+
+  const { property_json: userFilterList } = await pg.query(`select property_json::json from setting.property
+    where property_entity='filter' and object_id=$1`, [table]).then(el => el.rows?.[0] || {});
+
+  const { property_json: customQuery } = await pg.query(`select json_agg(json_build_object('id',property_id,'name', property_key,
+  'query', property_text, 'disabled', coalesce((property_json::json->>'disabled')::boolean,false) )) as property_json
+  from setting.property where 1=1 and property_entity='customQuery' and object_id=$1`, [table]).then(el => el.rows?.[0] || {});
+
+  time.push(Date.now());
+
+  const debug = user?.user_type?.includes('admin') && query?.debug
+    ? {
+      view,
+      tableName,
+      metaColumns: meta?.columns,
+      columnProperties: tableSettingColumns,
+    }
+    : undefined;
+
+  const res = {
+    time: {
+      geom: time[1] - time[0],
+      stat: time[2] - time[1],
+      count: time[3] - time[2],
+      total: time[4] - time[0],
+    },
+    debug,
+    model: tableName,
+    total,
+    geometry,
+    stat,
+    cls,
+    columns,
+    filters: userFilterList?.length
+      ? userFilterList
+      : loadTable?.filters?.map((el) => ({ ...el, title: el.title || el.ua })),
+    customQuery: customQuery?.length ? customQuery : [],
+    customColumns,
+    customFilters: userFilterList || [],
+  };
+
+  if (entity) {
+    return reply.status(200).send({ [entity]: res[entity] });
+  }
+
+  return reply.status(200).send(res);
+}

package/server/routes/properties/controllers/table.properties.post.js

@@ -0,0 +1,121 @@
+import { pgClients, getRedis } from '../../../../utils.js';
+
+import refreshData from '../utils/refreshData.js';
+
+const rclient = getRedis();
+
+/**
+ *
+ * @method POST
+ * @priority 4
+ * @alias postSettingsTable
+ * @type api
+ * @tag custom
+ * @returns {String} message and status
+ */
+
+export default async function postTablpostSettingsTableeProperties({
+  pg = pgClients.client, params = {}, body = {}, user = {},
+}, reply) {
+  const { table } = params;
+  const { uid } = user;
+
+  if (!uid) {
+    return reply.status(401).send('unauthorized');
+  }
+
+  if (!table) {
+    return reply.status(400).send('not enough params: table');
+  }
+
+  const {
+    deleted = [],
+    columns = [],
+    filters = [],
+    customColumns = [],
+    customQuery = [],
+  } = body;
+
+  const cacheKey = `${pg.options?.database}:filter-list:${table}`;
+
+  if (Array.isArray(deleted) && deleted?.length) {
+    const sqlList = {
+      columns: 'delete from setting.property where property_entity=\'column\' and object_id=$1',
+      filters: 'delete from setting.property where property_entity=\'filter\' and object_id=$1',
+      customColumns: `delete from setting.custom_data where attr in (select cf_id from setting.custom_field where object_id=$1);
+      delete from setting.custom_field where object_id=$1;
+      delete from setting.property where property_entity='customColumn' and object_id=$1;`,
+      customQuery: 'delete from setting.property where property_entity=\'customQuery\' and object_id=$1;',
+    };
+    const q = deleted.map((item) => sqlList[item])?.filter((el) => el)?.join(' ');
+    const { rowCount = 0 } = await pg.query(q, [table]);
+
+    if (['customColumn', 'column'].find((el) => deleted.includes(el))) {
+      // await funcs.applyHook('preTemplate', { pg, name: table, type: 'table' });
+    }
+    if (['customQuery', 'filter'].find((el) => deleted.includes(el))) {
+      await rclient.del(cacheKey);
+    }
+
+    if (rowCount === 0) {
+      return reply.status(200).send('nothing to restore');
+    }
+
+    return reply.status(200).send({
+      command: 'DELETE',
+      deleted,
+      table,
+      result: 'success',
+    });
+  }
+
+  const result = {};
+  // custom filter query (sql)
+  if (customQuery?.length) {
+    const res = await refreshData({
+      pg, entity: 'customQuery', table, uid, data: customQuery,
+    });
+    if (res?.error) return res;
+    Object.assign(result, { customQuery: res });
+  }
+
+  // columns
+  if (columns?.length) {
+    const res = await refreshData({
+      pg, entity: 'column', table, uid, data: columns,
+    });
+    if (res?.error) return res;
+    Object.assign(result, { columns: res });
+  }
+
+  // custom columns
+  if (customColumns?.length) {
+    const colModel = await pg.query(`select property_json::json from setting.property
+    where property_entity='customColumn' and object_id=$1`, [table]).then((el) => el.rows?.[0]?.property_json);
+
+    const res = await refreshData({
+      pg, entity: 'customColumn', table, uid, data: customColumns, colModel,
+    });
+    if (res?.error) return res;
+    Object.assign(result, { customColumns: res });
+  }
+
+  // filters
+  if (filters?.length) {
+    const res = await refreshData({
+      pg, entity: 'filter', table, uid, data: filters,
+    });
+    if (res?.error) return res;
+
+    Object.assign(result, { filters: res });
+  }
+
+  if (columns?.length || customColumns?.length) {
+    // await funcs.applyHook('preTemplate', { pg, type: 'table', name: table });
+  }
+  if (filters?.length || customQuery?.length) {
+    await rclient.del(cacheKey);
+  }
+
+  return reply.status(200).send(result);
+}

package/server/routes/properties/index.js

@@ -1,11 +1,21 @@
 import getExtraProperties from './controllers/properties.get.js';
 import addExtraProperties from './controllers/properties.add.js';
 
+import getSettingsApp from './controllers/admin.properties.get.js';
+import postSettingsApp from './controllers/admin.properties.post.js';
+
+import getSettingsTable from './controllers/table.properties.get.js';
+import postSettingsTable from './controllers/table.properties.post.js';
+
 const propertiesSchema = {
   type: 'object',
-    properties: {
+  properties: {
     params: {
       id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+      key: { type: 'string', pattern: '^([\\d\\w._]+)$' },
+    },
+    querystring: {
+      json: { type: 'string', pattern: '^([\\d\\w]+)$' },
     },
   },
 };
@@ -14,6 +24,12 @@ async function plugin(app, config = {}) {
   const { prefix = '/api' } = config;
   app.get(`${prefix}/properties/:id`, { schema: propertiesSchema }, getExtraProperties);
   app.post(`${prefix}/properties/:id`, { schema: propertiesSchema }, addExtraProperties);
+
+  app.get(`${prefix}/settings-app/:key?`, { scheme: propertiesSchema }, getSettingsApp);
+  app.post(`${prefix}/settings-app`, { config: { policy: ['admin'] } }, postSettingsApp);
+
+  app.get(`${prefix}/settings-table/:table/:entity?`, {}, getSettingsTable);
+  app.post(`${prefix}/settings-table/:table`, {}, postSettingsTable);
 }
 
 export default plugin;

package/server/routes/properties/utils/dataInsert.js

@@ -0,0 +1,26 @@
+import { getMeta, getPG } from '../../../../utils.js';
+
+export default async function dataInsert({
+  table, data, pg: pg1,
+}) {
+  const pg = pg1 || getPG({ name: 'client' });
+  if (!data) return null;
+  const { columns } = await getMeta(table);
+  if (!columns) return null;
+
+  const names = columns.map((el) => el.name);
+  const filterData = Object.keys(data)
+    .filter((el) => data[el] && names.includes(el)).map((el) => [el, data[el]]);
+
+  const insertQuery = `insert into ${table}
+
+    ( ${filterData?.map((key) => `"${key[0]}"`).join(',')}) 
+
+    values  (${filterData?.map((key, i) => (key[0] === 'property_json' ? `to_json($${i + 1}::${key[1] && typeof key[1] === 'object' ? 'json' : 'text'})` : `$${i + 1}`)).join(',')}) 
+    
+    returning *`;
+
+  const res = await pg.query(insertQuery, [...filterData.map((el) => (typeof el[1] === 'object' && (!Array.isArray(el[1]) || typeof el[1]?.[0] === 'object') ? JSON.stringify(el[1]) : el[1]))]) || {};
+
+  return res;
+}

package/server/routes/properties/utils/getColumnMetaData.js

@@ -0,0 +1,19 @@
+import { pgClients, getMeta } from '../../../../utils.js';
+
+const systemColumns = ['files', 'uid', 'editor_date', 'editor_id', 'cdate', 'created_at', 'updated_at', 'created_by', 'updated_by'];
+
+export default async function getColumnMetaData({
+  pg = pgClients.client, table,
+}) {
+  if (!table) return null;
+
+  const { columns = [] } = await getMeta({ pg, table });
+  const columnList = columns.filter(el => !systemColumns.includes(el.name)).map(el => el.name);
+
+  const sql = `select count(*) as total, ${columnList.map((item) => `(count(*) filter(where ${item} is not null)) as "${item}"`).join(',')} from ${table}`;
+  const res = await pg.queryCache(sql, { table }).then(el => el.rows?.[0] || {});
+
+  return columns
+    .filter(el => !systemColumns.includes(el.name))
+    .map((row) => Object.assign(row, { percent: ((+res[row.name] / +res.total) * 100).toFixed(0) }));
+}

package/server/routes/properties/utils/refreshData.js

@@ -0,0 +1,129 @@
+import { randomUUID, createHash } from 'node:crypto';
+
+import { dataInsert, pgClients } from '../../../../utils.js';
+
+function prepareResult(res) {
+  const arr = (res.rows || (Array.isArray(res) ? res : Object.values(res || {})));
+  return {
+    command: 'INSERT',
+    count: res?.rowCount || arr.filter((el) => el.command === 'INSERT')
+      ?.map((el) => ({ result: 'success', count: el.rowCount }))
+      ?.reduce((acc, curr) => acc + curr.count, 0),
+  };
+}
+
+export default async function refreshData({
+  pg = pgClients.client, entity, table, uid, data,
+}) {
+  if (!['filter', 'column', 'customQuery', 'customColumn'].includes(entity)) {
+    return { message: 'invalid params: entity', status: 400 };
+  }
+
+  const client = await pg.connect();
+
+  /* getMeta support */
+  client.options = pg.options;
+  client.tlist = pg.tlist;
+  client.pgType = pg.pgType;
+  client.pk = pg.pk;
+  client.relkinds = pg.relkinds;
+
+  const result = {};
+
+  try {
+    await client.query('BEGIN');
+
+    if (['filter', 'column'].includes(entity)) {
+      data?.forEach((el) => Object.assign(el, { id: el.id || randomUUID() }));
+      await client.query('delete from setting.property where object_id=$1 and property_entity=$2', [table, entity]);
+
+      const res = await dataInsert({
+        pg: client,
+        table: 'setting.property',
+        data: {
+          property_entity: entity,
+          object_id: table,
+          property_json: JSON.stringify(data), // ?.replace(/'+/g, "'")?.replace(/'/g, "''")
+        },
+        uid,
+      });
+      Object.assign(result, res);
+    }
+
+    if (['customQuery'].includes(entity)) {
+      await client.query('delete from setting.property where object_id=$1 and property_entity=$2', [table, entity]);
+
+      const res = await Promise.all(data?.map(async (el) => dataInsert({
+        pg: client,
+        table: 'setting.property',
+        data: {
+          property_entity: entity,
+          object_id: table,
+          property_key: el.name,
+          property_text: el.query,
+          property_json: { disabled: el.disabled },
+        },
+        uid,
+      })));
+      Object.assign(result, res);
+    }
+
+    if (entity === 'customColumn') {
+      const prefix = createHash('md5').update(table).digest('hex').substr(0, 10);
+      const data1 = [];
+
+      await Promise.all(data.map(async (el, index) => {
+        const obj = {
+          cf_id: `col_${prefix}_${index}`,
+          cf_name: el.title || el.ua || el.name,
+          cf_type: el.format || el.type,
+          cf_default: el.default,
+          cf_notnull: el.notnull,
+          object_id: table,
+          tablename: table,
+        };
+
+        data1.push({
+          name: obj.cf_id,
+          title: obj.cf_name,
+          format: obj.cf_type,
+          option: data[index]?.option,
+          hidden: data[index]?.hidden,
+          custom: true,
+        });
+
+        await dataInsert({
+          pg: client,
+          table: 'setting.custom_field',
+          data: obj,
+          uid,
+        });
+      }));
+
+      await client.query('delete from setting.custom_field where $1 in (tablename, object_id)', [table]);
+      await client.query('delete from setting.property where object_id=$1 and property_entity=$2', [table, entity]);
+
+      const data2 = JSON.stringify(data1?.filter((value, index, array) => array.indexOf(value) === index)); // ?.replace(/'+/g, "'")?.replace(/'/g, "''")
+      const res = await dataInsert({
+        pg: client,
+        table: 'setting.property',
+        data: {
+          property_entity: 'customColumn',
+          object_id: table,
+          property_json: data2,
+        },
+        uid,
+      });
+      Object.assign(result, res);
+    }
+    await client.query('COMMIT');
+    return prepareResult(result);
+  }
+  catch (err) {
+    await client.query('ROLLBACK');
+    return { error: err.toString(), status: 500 };
+  }
+  finally {
+    client.release();
+  }
+}