@opengis/fastify-table 1.2.69 → 1.2.71

package/package.json

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

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

@@ -70,7 +70,7 @@ async function init(client) {
 
   async function queryCache(q, param = {}) {
     const { table, args = [], time = 15 } = param;
-    const seconds = typeof time !== 'number' || time < 0 ? 15 : (config.local ? 0 : time * 60);
+    const seconds = typeof time !== 'number' || time < 0 ? 0 : time * 60;
 
     // CRUD table state
     const keyCacheTable = `pg:${table}:crud`;
@@ -92,6 +92,7 @@ async function init(client) {
     if (seconds > 0) {
       rclient.set(keyCache, JSON.stringify(data), 'EX', seconds);
     }
+
     // console.log('no cache', table, crudInc, query);
     return data;
   }

package/server/plugins/table/funcs/getFilterSQL/index.js

@@ -44,16 +44,17 @@ export default async function getFilterSQL({
   // console.log('extra getFilterSQL', extraDataTable, pg.pk?.[extraDataTable]);
 
   // check sql inline fields count
-  if (!checkInline[body.table] && body.sql?.length && body.table) {
-    const filterSql = body.sql.filter(el => el.inline ?? true);
-    const d = await Promise.all(filterSql.map(el => pg.query(`select  q.* from(select * from ${body.table})t left join lateral(${el.sql})q on 1=1 limit 0`).then(el => el.fields)))
+  if (!checkInline[body?.table] && body?.sql?.length && body.table) {
+    const filterSql = body.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 = await Promise.all(filterSql.map((el, i) => pg.query(`select  ${el.name || `t${i}`}.* from(select * from ${body.table})t ${sqlTable} limit 0`).then(el => el.fields)))
     d.forEach((el, i) => {
       filterSql[i].inline = el.length == 1 ? true : false;
       filterSql[i].fields = el.map(f => f.name);
     });
-    checkInline[table] = body.sql;
-  } else if (checkInline[table]) {
-    body.sql = checkInline[table]
+    checkInline[body?.table] = body.sql;
+  } else if (checkInline[body?.table]) {
+    body.sql = checkInline[body?.table]
   }
 
   const sqlTable = body?.sql?.length

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

@@ -30,7 +30,9 @@ export default async function getSelectVal({
   const filteredValues = values.filter(el => !cache[el]);
 
   // query select
-  const q = `with c(id,text) as (select * from (${cls.sql})q where ${id} = any('{${filteredValues}}')) select * from c`;
+
+  const q = `with c(id,text) as (select * from (${cls.sql})q where ${id} = any('{${filteredValues.join(',').replace(/\"/g, '\\"')}}')) select * from c`;
+
   const data = filteredValues.length ? await pg.query(q).then(el => el.rows) : [];
 
   const clsObj = { ...cache, ...data.reduce((p, el) => ({ ...p, [el.id.toString()]: el.color ? el : el.text }), {}) };

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

@@ -1,92 +1,92 @@
-import {
-  config, getAccess, getTemplate, getMeta, setToken, applyHook, getToken, pgClients,
-} from '../../../../utils.js';
-
-export default async function tableAPI(req) {
-  const {
-    pg = pgClients.client, params, user = {}, query = {},
-  } = req;
-  const tokenData = await getToken({ token: params?.table, uid: user.uid, json: 1 }) || {};
-
-  const hookData = await applyHook('preTable', {
-    pg, table: params?.table, id: params?.id, ...tokenData || {}, user,
-  });
-
-  if (hookData?.message && hookData?.status) {
-    return { message: hookData?.message, status: hookData?.status };
-  }
-  const tableName1 = hookData?.table || tokenData.table || params.table;
-
-  const loadTable = await getTemplate('table', tableName1) || {};
-  if (!loadTable && !pg.pk?.[tokenData.table]) {
-    return { message: 'not found', status: 404 };
-  }
-
-  const { table, /* columns, */ form } = loadTable;
-
-  const templateName = hookData?.table || tokenData.table || params.table;
-  const tableName = table || templateName;
-
-  const id = hookData?.id || tokenData.id || params.id;
-
-  if (tokenData && !id) return { message: {} };
-  if (!tableName && !id) {
-    return { message: 'not enough params', status: 400 };
-  }
-
-  const { actions = [], query: accessQuery } = await getAccess({ table: templateName, id, user }, pg) || {};
-
-  if (!actions.includes('edit') && !config?.local && !tokenData) {
-    return { message: 'access restricted', status: 403 };
-  }
-
-  const { pk, columns: dbColumns = [] } = await getMeta({ pg, table: tableName });
-  if (!pk) return { message: `table not found: ${table}`, status: 404 };
-
-  // const cols = columns.map((el) => el.name || el).join(',');
-  const formName = hookData?.form || tokenData?.form || form;
-  const formData = await getTemplate('form', formName) || {};
-  const schema = formData?.schema || formData || {};
-  // 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 columnList = dbColumns.map((el) => el.name || el).join(',');
-
-  const { fields = [] } = !loadTable?.table ? await pg.query(`select * from ${tableName} limit 0`) : {};
-  const cols = loadTable?.table
-    ? Object.keys(schema || {}).filter((col) => columnList.includes(col) && !extraKeys.includes(col))?.map((col) => (col?.includes('geom') && schema?.[col]?.type === 'Geom' ? `st_asgeojson(${col})::json as "${col}"` : `"${col}"`))?.join(',')
-    : fields.map((el) => (el?.name?.includes('geom') && pg.pgType[el?.dataTypeID] === 'geometry' ? `st_asgeojson(${el.name})::json as "${el.name}"` : `"${el?.name}"`)).join(',');
-  const where = [`"${pk}" = $1`, loadTable.query, accessQuery].filter((el) => el);
-  const geom = dbColumns.find((el) => el.name === 'geom' && pg.pgType[el.dataTypeID] === 'geometry') ? ',st_asgeojson(geom)::json as geom' : '';
-  const q = `select "${pk}" as id, ${cols || '*'} ${geom} from ${tableName} t where ${where.join(' and ') || 'true'} limit 1`;
-
-  if (query?.sql === '1') return q;
-
-  const data = await pg.query(q, [id]).then(el => el.rows[0]);
-  if (!data) return { message: 'not found', status: 404 };
-
-  Object.keys(schema).filter(key => schema[key]?.type === 'DataTable').forEach(key => {
-    if (data[key] && !Array.isArray(data[key])) { data[key] = null };
-  });
-
-  if (extraKeys?.length) {
-    await Promise.all(extraKeys?.map(async (key) => {
-      const { colModel, table: extraTable, parent_id: parentId } = schema[key];
-      const q1 = `select ${parentId} as parent, ${colModel.map((col) => col.name || col.key).join(',')} from ${extraTable} a where ${parentId}=$1`;
-      // console.log(tableName, formName, q1);
-      const { rows: extraRows } = await pg.query(q1, [hookData?.id || tokenData?.id || params?.id]);
-      Object.assign(data, { [key]: extraRows });
-    }));
-  }
-  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,
-      array: 1,
-    })[0];
-  }
-  const res = await applyHook('afterTable', {
-    pg, table: tableName, payload: [data], user,
-  });
-  return res || data || {};
-}
+import {
+  config, getAccess, getTemplate, getMeta, setToken, applyHook, getToken, pgClients,
+} from '../../../../utils.js';
+
+export default async function tableAPI(req) {
+  const {
+    pg = pgClients.client, params, user = {}, query = {},
+  } = req;
+  const tokenData = await getToken({ token: params?.table, uid: user.uid, json: 1 }) || {};
+
+  const hookData = await applyHook('preTable', {
+    pg, table: params?.table, id: params?.id, ...tokenData || {}, user,
+  });
+
+  if (hookData?.message && hookData?.status) {
+    return { message: hookData?.message, status: hookData?.status };
+  }
+  const tableName1 = hookData?.table || tokenData.table || params.table;
+
+  const loadTable = await getTemplate('table', tableName1) || {};
+  if (!loadTable && !pg.pk?.[tokenData.table]) {
+    return { message: 'not found', status: 404 };
+  }
+
+  const { table, /* columns, */ form } = loadTable;
+
+  const templateName = hookData?.table || tokenData.table || params.table;
+  const tableName = table || templateName;
+
+  const id = hookData?.id || tokenData.id || params.id;
+
+  if (tokenData && !id) return { message: {} };
+  if (!tableName && !id) {
+    return { message: 'not enough params', status: 400 };
+  }
+
+  const { actions = [], query: accessQuery } = await getAccess({ table: templateName, id, user }, pg) || {};
+
+  if (!actions.includes('edit') && !config?.local && !tokenData) {
+    return { message: 'access restricted', status: 403 };
+  }
+
+  const { pk, columns: dbColumns = [] } = await getMeta({ pg, table: tableName });
+  if (!pk) return { message: `table not found: ${table}`, status: 404 };
+
+  // const cols = columns.map((el) => el.name || el).join(',');
+  const formName = hookData?.form || tokenData?.form || form;
+  const formData = await getTemplate('form', formName) || {};
+  const schema = formData?.schema || formData || {};
+  // 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 columnList = dbColumns.map((el) => el.name || el).join(',');
+
+  const { fields = [] } = !loadTable?.table ? await pg.query(`select * from ${tableName} limit 0`) : {};
+  const cols = loadTable?.table
+    ? Object.keys(schema || {}).filter((col) => columnList.includes(col) && !extraKeys.includes(col))?.map((col) => (col?.includes('geom') && schema?.[col]?.type === 'Geom' ? `st_asgeojson(${col})::json as "${col}"` : `"${col}"`))?.join(',')
+    : fields.map((el) => (el?.name?.includes('geom') && pg.pgType[el?.dataTypeID] === 'geometry' ? `st_asgeojson(${el.name})::json as "${el.name}"` : `"${el?.name}"`)).join(',');
+  const where = [`"${pk}" = $1`, loadTable.query, accessQuery].filter((el) => el);
+  const geom = dbColumns.find((el) => el.name === 'geom' && pg.pgType[el.dataTypeID] === 'geometry') ? ',st_asgeojson(geom)::json as geom' : '';
+  const q = `select "${pk}" as id, ${cols || '*'} ${geom} from ${tableName} t where ${where.join(' and ') || 'true'} limit 1`;
+
+  if (query?.sql === '1') return q;
+
+  const data = await pg.query(q, [id]).then(el => el.rows[0]);
+  if (!data) return { message: 'not found', status: 404 };
+
+  Object.keys(schema).filter(key => schema[key]?.type === 'DataTable').forEach(key => {
+    if (data[key] && !Array.isArray(data[key])) { data[key] = null };
+  });
+
+  if (extraKeys?.length) {
+    await Promise.all(extraKeys?.map(async (key) => {
+      const { colModel, table: extraTable, parent_id: parentId } = schema[key];
+      const q1 = `select ${parentId} as parent, ${colModel.map((col) => col.name || col.key).join(',')} from ${extraTable} a where ${parentId}=$1`;
+      // console.log(tableName, formName, q1);
+      const { rows: extraRows } = await pg.query(q1, [hookData?.id || tokenData?.id || params?.id]);
+      Object.assign(data, { [key]: extraRows });
+    }));
+  }
+  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,
+      array: 1,
+    })[0];
+  }
+  const res = await applyHook('afterTable', {
+    pg, table: tableName, payload: [data], user,
+  });
+  return res || data || {};
+}

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

@@ -19,7 +19,7 @@ export default async function dataAPI(req, reply, called) {
   } = req;
 
   const time = Date.now();
-
+  const timeArr = [Date.now()];
   const { uid } = user;
 
   const hookData = await applyHook('preData', {
@@ -63,7 +63,7 @@ export default async function dataAPI(req, reply, called) {
   } = loadTable || tokenData;
 
   const tableMeta = await getMeta({ pg, table });
-
+  timeArr.push(Date.now())
   if (tableMeta?.view) {
     if (!loadTable?.key && !tokenData?.key) return { message: `key not found: ${table}`, status: 404 };
     Object.assign(tableMeta, { pk: loadTable?.key || tokenData?.key });
@@ -78,7 +78,8 @@ export default async function dataAPI(req, reply, called) {
   const cardSqlFiltered = hookData?.id || params.id ? (cardSql?.filter?.((el) => !el?.disabled && el?.name && el?.sql?.replace) || []) : [];
   const cardSqlTable = cardSqlFiltered.length ? cardSqlFiltered.map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ct${i}  on 1=1 `).join('\n') || '' : '';
 
-  const { fields = [] } = pg.queryCache ? await pg.queryCache(`select * from ${table} t ${sqlTable}  ${cardSqlTable} limit 0`) : {};
+  const sqlInline = loadTable.sql?.filter?.(el => el.inline).map(el => `,(${el.sql})`).join('');
+  const { fields = [] } = pg.queryCache ? await pg.queryCache(`select * ${sqlInline} from ${table} t ${sqlTable}  ${cardSqlTable} limit 0`) : {};
   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
@@ -109,10 +110,10 @@ export default async function dataAPI(req, reply, called) {
     uid,
     json: 1,
   }) : {};
-
+  timeArr.push(Date.now())
   const keyQuery = query.key && (loadTable?.key || tokenData?.key) && !(hookData?.id || tokenData?.id || params.id) ? `${loadTable?.key || tokenData?.key}=$1` : null;
 
-  const limit = Math.min(maxLimit, +(query.limit || 20));
+  const limit = called ? (query.limit || 20) : Math.min(maxLimit, +(query.limit || 20));
 
   const offset = query.page && query.page > 0 ? ` offset ${(query.page - 1) * limit}` : '';
   // id, query, filter
@@ -135,11 +136,9 @@ export default async function dataAPI(req, reply, called) {
   const q = `select  ${pk ? `"${pk}" as id,` : ''} 
                      ${params.id || query.key ? '*' : sqlColumns || cols || '*'} 
                      ${metaCols} 
-                     ${sql?.filter?.(el => el.inline && el.fields?.length)?.length 
-                      ? `,${sql?.filter(el => el.inline && el.fields).map(el => el.fields).join(',')}` || ''
-                      : ''}
+                     
                      ${dbColumns.find((el) => el.name === 'geom' && pg.pgType?.[el.dataTypeID] === 'geometry') ? ',st_asgeojson(geom)::json as geom' : ''} 
-                     from (select * ${sql?.filter(el => el.inline).map(el => `,(${el.sql})`).join('') || ''} from ${table} t where ${sqlTable ? 'true' : (where.join(' and ') || 'true')}  ) t 
+                     from (select * ${sql?.filter(el => el.inline).map(el => `,(${el.sql})`).join('') || ''} from ${table} t   ) t 
                      ${sqlTable} 
                      ${params.id ? cardSqlTable : ''} 
                      where ${where.join(' and ') || 'true'} 
@@ -152,6 +151,8 @@ export default async function dataAPI(req, reply, called) {
 
   const { rows = [] } = await pg.query(q, (tokenData?.id || hookData?.id || params.id ? [tokenData?.id || hookData?.id || params.id] : null) || (query.key && loadTable.key ? [query.key] : []));
 
+  timeArr.push(Date.now())
+
   if (uid && rows.length && editable) {
     rows.forEach(row => {
       row.token = setToken({
@@ -178,15 +179,16 @@ export default async function dataAPI(req, reply, called) {
 
   const counts = keyQuery || tokenData?.id || hookData?.id || params.id
     ? { total: rows.length, filtered: rows.length }
-    : await pg.queryCache?.(qCount, { table: loadTable?.table || tokenData?.table, time: 5 }).then(el => el?.rows[0] || {});
+    : await pg.queryCache?.(qCount, { table: loadTable?.table || tokenData?.table, time: 5 * 60 }).then(el => el?.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: tokenData?.table || hookData?.table || params.table }, pg);
-
+  timeArr.push(Date.now())
   const status = [];
   if (loadTable?.meta?.status) {
     const statusColumn = loadTable.meta?.cls?.[loadTable.meta?.status]
@@ -273,7 +275,15 @@ export default async function dataAPI(req, reply, called) {
   }
 
   const res = {
-    time: Date.now() - time,
+    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],
+    },
+
     public: ispublic,
     tokens,
     card: loadTable?.card,

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

@@ -1,7 +1,5 @@
 import { logger, autoIndex, getSelect, getFilterSQL, getTemplate, getSelectVal, pgClients } from '../../../../utils.js';
 
-const checkInline = {};
-
 export default async function filterAPI(req) {
   const time = Date.now();
 
@@ -12,38 +10,23 @@ export default async function filterAPI(req) {
   const loadTable = await getTemplate('table', params.table);
   if (!loadTable) { return { status: 404, message: 'not found' }; }
 
-  // check sql inline fields count
-  if (!checkInline[params.table] && loadTable.sql?.length && loadTable.table) {
-    const filterSql = loadTable.sql.filter(el => el.inline ?? true);
-    const d = await Promise.all(filterSql.map(el => pg.query(`select  q.* from(select * from ${loadTable.table})t left join lateral(${el.sql})q on 1=1 limit 0`).then(el => el.fields)))
-    d.forEach((el, i) => {
-      filterSql[i].inline = el.length == 1 ? true : false;
-      filterSql[i].fields = el.map(f => f.name);
-    });
-    checkInline[params?.table] = loadTable.sql;
-  } else if (checkInline[params?.table]) {
-    loadTable.sql = checkInline[params?.table]
-  }
-
-  const sqlTable = false ? loadTable.sql?.filter?.((el) => !el.inline && !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 sqlInline = loadTable.sql?.filter?.(el => el.inline).map(el => `,(${el.sql})`).join('');
-  const { fields: columns = [] } = await pg.query(`select q.* from (select * ${sqlInline || ''} from ${loadTable.table} t ${sqlTable} limit 0)q`);
+  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 { fields = [] } = await pg.query(`select * from ${loadTable.table} t limit 0`);
 
   const {
     filter, custom, state, search,
   } = query;
 
-  const { extra } = loadTable?.form ? await getTemplate('form', loadTable?.form) || {} : {};
+  // const { extra } = loadTable?.form ? await getTemplate('form', loadTable?.form) || {} : {};
 
-  const { optimizedSQL = `select * ${sqlInline || ''} from ${loadTable.table}` } = loadTable?.sql || filter || custom || state || search || extra ? await getFilterSQL({
+  const { optimizedSQL = `select * from ${loadTable.table}` } = false ? await getFilterSQL({
     pg,
     table: params.table,
     filter,
     custom,
     state,
     search,
-    uid: user?.uid,
   }) : {};
 
   const filters = (loadTable?.filter_list || loadTable?.filters || loadTable?.filterList || []).concat(loadTable?.filterSql || []);
@@ -64,8 +47,8 @@ export default async function filterAPI(req) {
   await Promise.all(filters.filter((el) => el.data && el.id && el.type !== 'Autocomplete').map(async (el) => {
     const cls = await getSelect(el.data, pg);
 
+    if (!cls || !loadTable.table) return;
     const { dataTypeID } = columns.find((item) => item.name === el.id) || {};
-    if (!cls || !loadTable.table || !dataTypeID) return;
 
     if (el.extra && el.type === 'select' && Array.isArray(cls)) {
       const countArr = await pg.query(`select value_text as id, count(*) from crm.extra_data where property_key=$1 and property_entity=$2 group by value_text`, [el.id, params.table]);
@@ -159,4 +142,4 @@ export default async function filterAPI(req) {
     inline: loadTable?.filterInline,
     state: loadTable?.filterState,
   };
-}
+}