@opengis/fastify-table 1.1.118 → 1.1.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.1.118",
+  "version": "1.1.120",
   "type": "module",
   "description": "core-plugins",
   "keywords": ["fastify", "table", "crud", "pg", "backend" ],

package/server/routes/cron/controllers/cronApi.js

@@ -5,7 +5,7 @@ export default async function cronApi(req) {
     params = {}, user = {}, hostname,
   } = req;
 
-  if ((!user.uid || !user.user_type?.includes('admin')) && !hostname?.includes('localhost')) {
+  if ((!user.uid || !user.user_type?.includes('admin')) && !hostname?.includes('local')) {
     return { message: 'access restricted', status: 403 };
   }
 

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

@@ -106,28 +106,36 @@ export default async function dataAPI(req) {
                      where ${where.join(' and ') || 'true'} 
                      ${order} ${offset}  limit ${limit}`
     .replace(/{{uid}}/g, uid);
-  
+
   // if (user?.user_type === 'superadmin') console.log(q);
 
   if (query.sql === '1') { return q; }
 
   const { rows } = await pg.query(q, (hookData?.id || params.id ? [hookData?.id || params.id] : null) || (query.key && loadTable.key ? [query.key] : []));
 
-  const filterWhere = [fData.q, search, bbox, queryPolyline, interfaceQuery].filter((el) => el);
+  const filterWhere = [fData.q, search, bbox, queryPolyline, interfaceQuery, loadTable.query].filter((el) => el);
 
+  const aggregates = dbColumns.map((el) => ({ name: el.name, type: pg.pgType[el.dataTypeID] })).filter((el) => ['numeric', 'double precision'].includes(el.type));
   const qCount = `select 
             count(*)::int as total,  
-            count(*) FILTER(WHERE ${filterWhere.filter(el => el).join(' and ') || 'true'})::int as filtered 
+            count(*) FILTER(WHERE ${filterWhere.join(' and ') || 'true'})::int as filtered
+            ${aggregates.length ? `,${aggregates.map((el) => `sum(${el.name}) FILTER(WHERE ${filterWhere.join(' and ') || 'true'}) as ${el.name}`).join(',')}` : ''}
             from ${table} t ${sqlTable} 
             where ${[loadTable.query, accessQuery].filter(el => el).join(' and ') || 'true'} `
     .replace(/{{uid}}/g, uid);
 
-  const { total, filtered } = keyQuery || hookData?.id || params.id ? rows.length
-    : await pg.queryCache(qCount, { table: loadTable.table, time: 5 }).then((el) => el?.rows[0]);
+  if (query.sql === '2') { return qCount; }
+
+  const counts = keyQuery || hookData?.id || params.id
+    ? { total: rows.length, filtered: rows.length }
+    : await pg.queryCache(qCount, { table: loadTable.table, time: 5 }).then(el => el?.rows[0] || {});
+
+  const { total, filtered } = counts;
+  const agg = Object.keys(counts).filter(el => !['total', 'filtered'].includes(el)).reduce((acc, el) => ({ ...acc, [el]: counts[el] }), {});
 
   await metaFormat({ rows, table: hookData?.table || params.table });
   const res = {
-    time: Date.now() - time, public: ispublic, card: loadTable.card, 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, agg, rows, meta, columns, filters,
   };
 
   // console.log({ add: loadTable.table, form: loadTable.form });

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

@@ -21,17 +21,21 @@ export default async function suggest(req) {
   const [table, column] = params.data?.includes(':') ? params.data.split(':') : [];
   const selectName = query.sel || query.name || params.data;
 
-  if (!selectName) return { headers, status: 400, message: 'name is required' };
+  if (!selectName) return { status: 400, message: 'name is required' };
 
   const body = await getTemplate('table', table);
 
   if (table && !pg1.pk[body?.table || table]) {
-    return { headers, status: 400, message: 'param name is invalid: 1' };
+    return { status: 400, message: 'param name is invalid: 1' };
   }
   const columnExists = body?.columns?.find((col) => col?.name === column);
 
   if (table && (!column || !columnExists)) {
-    return { headers, status: 400, message: 'param name is invalid: 2' };
+    return { status: 400, message: 'param name is invalid: 2' };
+  }
+
+  if (query.limit && query.limit < 0) {
+    return { status: 400, message: 'param limit is invalid' };
   }
 
   const meta = table && column
@@ -59,11 +63,17 @@ export default async function suggest(req) {
 
   if (arr) {
     const lower = query.key?.toLowerCase();
-    const data = query.key || query.val
+    const data1 = query.key || query.val
       ? arr?.filter((el) => !lower || (el[lang] || el.text)?.toLowerCase()?.indexOf(lower) !== -1)?.filter((el) => !query.val || el.id === query.val)
       : arr;
+    const data = data1.slice(0, Math.min(query.limit || limit, limit));
     return {
-      limit, count: data.length, mode: 'array', time: Date.now() - time, data,
+      time: Date.now() - time,
+      limit: Math.min(query.limit || limit, limit),
+      count: data.length,
+      total: arr.length,
+      mode: 'array',
+      data,
     };
   }
 
@@ -85,7 +95,7 @@ export default async function suggest(req) {
     ? `id in (select ${filterColumn} from ${(loadTable?.table || query.token).replace(/'/g, "''")})`
     : 'true';
 
-  const sqlSuggest = `with c(id,text) as ( ${meta.original.replace(/{{parent}}/gi, parent)} where ${where} order by 2) select * from c where ${filter} limit ${meta.limit || limit}`.replace(/{{uid}}/g, user?.uid || '0');
+  const sqlSuggest = `with c(id,text) as ( ${meta.original.replace(/{{parent}}/gi, parent)} where ${where} order by 2) select * from c where ${filter} limit ${Math.min(query.limit || meta.limit || limit, limit)}`.replace(/{{uid}}/g, user?.uid || '0');
 
   if (query.sql && config.local) {
     return sqlSuggest;
@@ -99,6 +109,7 @@ export default async function suggest(req) {
 
   const message = {
     time: Date.now() - time,
+    limit: Math.min(query.limit || meta.limit || limit, limit),
     count: data.length,
     total: meta.count - 0,
     mode: 'sql',