@opengis/fastify-table 1.1.109 → 1.1.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.1.109",
+  "version": "1.1.111",
   "type": "module",
   "description": "core-plugins",
   "main": "index.js",
@@ -15,7 +15,8 @@
     "test": "node --test",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
+    "docs:preview": "vitepress preview docs",
+    "compress": "node compress.js"
   },
   "dependencies": {
     "@fastify/sensible": "^5.0.0",
@@ -27,7 +28,8 @@
     "js-yaml": "^4.1.0",
     "pg": "^8.11.3",
     "pino": "^9.5.0",
-    "pino-abstract-transport": "^2.0.0"
+    "pino-abstract-transport": "^2.0.0",
+    "uglify-js": "^3.19.3"
   },
   "devDependencies": {
     "@panzoom/panzoom": "^4.5.1",
@@ -44,4 +46,4 @@
   },
   "author": "Softpro",
   "license": "ISC"
-}
+}

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

@@ -1,10 +1,11 @@
 import getPG from '../../pg/funcs/getPG.js';
 import getMeta from '../../pg/funcs/getMeta.js';
-
-// import { getPG, getMeta } from '../../../../utils.js';
+import getRedis from '../../redis/funcs/getRedis.js';
 
 import logChanges from './utils/logChanges.js';
 
+const rclient = getRedis();
+
 export default async function dataDelete({
   table, id, pg: pg1, uid,
 }) {
@@ -13,9 +14,10 @@ export default async function dataDelete({
   if (!pg.tlist?.includes(table)) return 'table not exist';
   const delQuery = `delete from ${table} WHERE ${pk} = $1 returning *`;
   //  console.log(updateDataset);
-  const res = await pg.one(delQuery, [id]) || {};
+  const res = await pg.query(delQuery, [id]).then(el => el.rows?.[0] || {});
   await logChanges({
     pg, table, id, uid, type: 'DELETE',
   });
+  rclient.incr(`pg:${table}:crud`);
   return res;
 }

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

@@ -1,10 +1,11 @@
 import getPG from '../../pg/funcs/getPG.js';
 import getMeta from '../../pg/funcs/getMeta.js';
-
-// import { getPG, getMeta } from '../../../../utils.js';
+import getRedis from '../../redis/funcs/getRedis.js';
 
 import logChanges from './utils/logChanges.js';
 
+const rclient = getRedis();
+
 export default async function dataInsert({
   id, table, data, pg: pg1, uid,
 }) {
@@ -38,5 +39,7 @@ export default async function dataInsert({
   await logChanges({
     pg, table, data, id: res.rows?.[0]?.[pg.pk[table]], uid, type: 'INSERT',
   });
+
+  rclient.incr(`pg:${table}:crud`);
   return res;
 }

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

@@ -1,10 +1,10 @@
 import getPG from '../../pg/funcs/getPG.js';
 import getMeta from '../../pg/funcs/getMeta.js';
-
-// import { getPG, getMeta } from '../../../../utils.js';
+import getRedis from '../../redis/funcs/getRedis.js';
 
 import logChanges from './utils/logChanges.js';
 
+const rclient = getRedis();
 const srids = {};
 
 function assignValue(key, i, srid = 4326) {
@@ -60,5 +60,6 @@ export default async function dataUpdate({
     pg, table, data, id, uid, type: 'UPDATE',
   });
 
+  rclient.incr(`pg:${table}:crud`);
   return res;
 }

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

@@ -4,9 +4,7 @@ import pgClients from '../../pg/pgClients.js';
 import getTemplate from '../../table/funcs/getTemplate.js';
 import applyHook from '../../hook/funcs/applyHook.js';
 
-// import { config, pgClients, getTemplate, applyHook } from '../../../../utils.js';
-
-const q = `select a.route_id as id, coalesce(b.actions,array['get']) as actions, b.scope 
+const q = `select a.route_id as id, coalesce(b.actions,array['view']) as "userActions", b.scope as "userScope"
 from admin.routes a 
 left join admin.role_access b on 
   a.route_id=b.route_id
@@ -20,7 +18,7 @@ left join admin.user_roles d on
             then d.expiration > CURRENT_DATE 
             else 1=1 
         end )
-where $1 in (a.route_id, a.alias) and $2 in (b.user_uid, d.user_uid)`;
+where $1 in (a.route_id, a.alias, a.table_name) and $2 in (b.user_uid, d.user_uid)`;
 
 export default async function getAccess({ table, user = {} }) {
   if (!table) return null;
@@ -28,21 +26,28 @@ export default async function getAccess({ table, user = {} }) {
   const hookData = await applyHook('getAccess', { table, user });
   if (hookData) return hookData;
 
-  const { uid } = user;
+  const { uid, user_type: userType } = user;
   const body = await getTemplate('table', table) || {};
 
-  // console.log(user?.type);
-  if (body.access === 'admin' && user?.type !== 'admin') return null;
+  if (body.access === 'admin' && !userType?.includes?.('admin')) {
+    const { userActions = [] } = uid ? await pgClients.client.query(q, [table, uid]).then(el => el.rows?.[0] || {}) : {};
+    const customActions = userActions.filter((el => ['view'].concat(body.actions || body.action_default || []).includes(el)));
+    return { actions: customActions, query: '1=1' };
+  }
+
+  const actions = uid ? ['view'].concat(body.actions || body.action_default || []) : [];
 
-  if (config.auth?.disable || user?.type === 'admin' || body?.public || body.access === 'public' || (body.access === 'user' && user.uid)) {
-    return { actions: ['get'].concat(user.uid ? body.actions || body.action_default || [] : []), query: '1=1' };
+  if (config.auth?.disable || userType?.includes?.('admin') || body?.public || body.access === 'public') {
+    return { actions, query: '1=1' };
   }
 
-  if (!uid || !body?.table) return null;
+  const dbTable = pgClients.client?.pk?.[table] ? table : body?.table;
+  if (!uid || !dbTable) return null;
 
-  const { scope, actions = [] } = await pgClients.client.query(q, [table, uid]).then((res) => res.rows?.[0] || {});
+  const { userScope, userActions = [] } = await pgClients.client.query(q, [table, uid]).then(el => el.rows?.[0] || {});
+  const query = body.access === 'user' || userScope === 'my' ? `uid='${uid}'` : null;
+  const customActions = userActions.filter((el => actions.includes(el)));
+  const scope = body.access === 'user' ? 'my' : userScope;
 
-  return {
-    scope, actions, query: scope === 'my' ? `uid='${uid}` : null,
-  };
+  return { scope, actions: customActions, query };
 }

package/server/plugins/pg/funcs/init.js

@@ -1,7 +1,9 @@
-import { createHash } from 'crypto';
+import { createHash } from 'node:crypto';
 
 import getRedis from '../../redis/funcs/getRedis.js';
 
+const rclient = getRedis({ db: 0 });
+
 async function init(client) {
   const textQuery = `select 
   (select json_object_agg(conrelid::regclass  ,(SELECT attname FROM pg_attribute WHERE attrelid = c.conrelid and attnum = c.conkey[1]))
@@ -40,16 +42,31 @@ async function init(client) {
     return result;
   }
 
-  async function queryCache(query) {
-    const rclient = getRedis({ db: 0 });
+  async function queryCache(query, param = {}) {
+    const { table, args = [], time = 15 } = param;
+    const seconds = typeof time !== 'number' || time < 0 ? 15 : time * 60;
+
+    // CRUD table state
+    const keyCacheTable = `pg:${table}:crud`;
+    const crudInc = table ? await rclient.get(keyCacheTable) || 0 : 0;
+
+    //
     const hash = createHash('sha1').update(query).digest('base64');
-    const keyCache = `pg:${hash}`;
-    const cache = await rclient.get(keyCache);
-    if (cache) {
-      return JSON.parse(cache);
+    const keyCache = `pg:${hash}:${crudInc}`;
+
+    const cacheData = await rclient.get(keyCache);
+
+    if (cacheData) {
+      // console.log('from cache', table, query);
+      return JSON.parse(cacheData);
+    }
+
+    const data = await client.query(query, args || []);
+
+    if (seconds > 0) {
+      rclient.set(keyCache, JSON.stringify(data), 'EX', seconds);
     }
-    const data = await client.query(query);
-    rclient.set(keyCache, JSON.stringify(data), 'EX', 60 * 60);
+    // console.log('no cache', table, crudInc, query);
     return data;
   }
 

package/server/plugins/table/funcs/metaFormat/getSelectVal.js

@@ -26,7 +26,7 @@ export default async function getSelectVal({
 
   // cache
   const key = `select:${name}`;
-  const cache = (await redis.hmget(key, values)).reduce((p, el, i) => ({ ...p, [values[i]]: el }), {});
+  const cache = values?.length ? (await redis.hmget(key, values)).reduce((p, el, i) => ({ ...p, [values[i]]: el }), {}) : {};
   const filteredValues = values.filter(el => !cache[el]);
 
   // query select

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

@@ -34,7 +34,7 @@ export default async function tableAPI(req) {
   }
 
   const { actions = [], query: accessQuery } = await getAccess({
-    table: tableName,
+    table: hookData?.table || tokenData.table || params.table,
     id,
     user,
   }) || {};
@@ -77,7 +77,7 @@ export default async function tableAPI(req) {
       Object.assign(data, { [key]: extraRows });
     }));
   }
-  if (user?.uid) {
+  if (user?.uid && actions?.includes?.('edit')) {
     data.token = tokenData?.table ? params.table : setToken({
       ids: [JSON.stringify({ id, table: tableName, form: loadTable.form })],
       uid: user.uid,

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

@@ -24,7 +24,7 @@ export default async function card(req) {
     user,
   }) || {};
 
-  if (!actions.includes('get') || (scope === 'my' && !my)) {
+  if (!actions.includes('view') || (scope === 'my' && !my)) {
     return { message: 'access restricted', status: 403 };
   }
 

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

@@ -26,7 +26,7 @@ export default async function dataAPI(req) {
   const id = hookData?.id || params?.id;
   const { actions = [], query: accessQuery } = await getAccess({ table: hookData?.table || params.table, id, user }) || {};
 
-  if (!actions.includes('get') && !config?.local) {
+  if (!actions.includes('view') && !config?.local) {
     return { message: 'access restricted', status: 403 };
   }
 
@@ -123,11 +123,11 @@ export default async function dataAPI(req) {
     .replace(/{{uid}}/g, uid);
 
   const { total, filtered } = keyQuery || hookData?.id || params.id ? rows.length
-    : await pg.queryCache(qCount).then((el) => el?.rows[0]);
+    : await pg.queryCache(qCount, { table: loadTable.table, time: 5 }).then((el) => el?.rows[0]);
 
-  await metaFormat({ rows, table: params.table });
+  await metaFormat({ rows, table: hookData?.table || params.table });
   const res = {
-    time: Date.now() - time, public: ispublic, card: loadTable.card, actions: loadTable.actions, total, filtered, count: rows.length, pk, form, rows, meta, columns, filters,
+    time: Date.now() - time, public: ispublic, card: loadTable.card, actions, total, filtered, count: rows.length, pk, form, rows, meta, columns, filters,
   };
 
   // console.log({ add: loadTable.table, form: loadTable.form });

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

@@ -1,18 +1,16 @@
-import {
-  getSelect, getFilterSQL, getTemplate,
-  getSelectVal,
-} from '../../../../utils.js';
+import { getSelect, getFilterSQL, getTemplate, getSelectVal, pgClients } from '../../../../utils.js';
 
 export default async function filterAPI(req) {
   const time = Date.now();
 
   const {
-    params, query = {}, pg,
+    params, query = {}, pg = pgClients.client, user = {},
   } = req;
+
   const loadTable = await getTemplate('table', params.table);
   if (!loadTable) { return { status: 404, message: 'not found' }; }
 
-  const sqlTable = loadTable.sql?.filter?.((el) => !el?.disabled && el?.sql?.replace).map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', req.user?.uid)}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
+  const sqlTable = loadTable.sql?.filter?.((el) => !el?.disabled && el?.sql?.replace).map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', user?.uid)}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
   const { fields: columns } = await pg.query(`select * from ${loadTable.table} t ${sqlTable} limit 0`);
 
   const {
@@ -20,7 +18,7 @@ export default async function filterAPI(req) {
   } = query;
 
   const { optimizedSQL = `select * from ${loadTable.table}` } = loadTable?.sql || filter || custom || state || search ? await getFilterSQL({
-    pg: req.pg,
+    pg,
     table: params.table,
     filter,
     custom,
@@ -30,17 +28,17 @@ export default async function filterAPI(req) {
 
   const filters = loadTable?.filters || loadTable?.filterList || [];
   await Promise.all(filters.filter((el) => el.data).map(async (el) => {
-    const cls = await getSelect(el.data, req.pg);
+    const cls = await getSelect(el.data, pg);
 
     if (!cls || !loadTable.table) return;
     const { dataTypeID } = columns.find((item) => item.name === el.id) || {};
 
-    const countArr = req.pg.pgType[dataTypeID]?.includes('[]')
-      ? await req.pg.queryCache(`select unnest(${el.id})::text as id,count(*) from (${optimizedSQL})q group by unnest(${el.id})`)
-      : await req.pg.queryCache(`select ${el.id}::text as id,count(*) from (${optimizedSQL})q group by ${el.id}`);
+    const countArr = pg.pgType[dataTypeID]?.includes('[]')
+      ? await pg.queryCache(`select unnest(${el.id})::text as id,count(*) from (${optimizedSQL})q group by unnest(${el.id})`, { table: loadTable.table, time: 5 })
+      : await pg.queryCache(`select ${el.id}::text as id,count(*) from (${optimizedSQL})q group by ${el.id}`, { table: loadTable.table, time: 5 });
     const ids = countArr.rows.map(el1 => el1.id);
 
-    const clsData = await getSelectVal({ pg: req.pg, values: ids, name: el.data });
+    const clsData = await getSelectVal({ pg, values: ids, name: el.data });
 
     const options = countArr.rows.map(cel => {
       const data = cls?.arr?.find(c => c.id === cel.id) || { text: clsData[cel.id] };
@@ -50,7 +48,7 @@ export default async function filterAPI(req) {
   }));
 
   const q = ((loadTable?.filterState || []).concat(loadTable?.filterCustom || [])).filter((el) => el.name && el.sql).map((el) => `select count(*), '${el.name}' as name from (${optimizedSQL})q where ${el.sql}`).join(' union all ');
-  const { rows = [] } = q ? await req.pg.query(q) : {};
+  const { rows = [] } = q ? await pg.query(q) : {};
   if (rows?.length) {
     ((loadTable?.filterState || []).concat(loadTable?.filterCustom || [])).filter((el) => el.name && el.sql).forEach((el) => {
       const { count } = rows.find((row) => row.name === el.name) || {};