@opengis/fastify-table 1.1.42 → 1.1.43

package/table/controllers/card.js

@@ -1,44 +1,44 @@
-import getTemplate from './utils/getTemplate.js';
-import getMeta from '../../pg/funcs/getMeta.js';
-import metaFormat from '../funcs/metaFormat/index.js';
-
-export default async function card(req) {
-  const time = Date.now();
-  const {
-    pg, params = {}, query = {}, opt = {},
-  } = req;
-
-  const loadTable = await getTemplate('table', params.table);
-
-  if (!loadTable) { return { message: 'template not found', status: 404 }; }
-
-  const {
-    table, columns, meta, sql, cardSql,
-  } = loadTable;
-
-  const { pk, columns: dbColumns = [] } = await getMeta(table);
-
-  if (!pk) return { message: `table not found: ${table}`, status: 404 };
-
-  const cols = columns.map((el) => el.name || el).join(',');
-  const columnList = dbColumns.map((el) => el.name || el).join(',');
-  const sqlTable = sql?.filter?.((el) => !el?.disabled && el?.sql?.replace).map((el, i) => ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
-  const cardSqlFiltered = opt.id || params.id ? cardSql?.filter?.((el) => !el?.disabled && el?.name && el?.sql?.replace) : [];
-  const cardSqlTable = cardSqlFiltered?.length ? cardSqlFiltered.map((el, i) => ` left join lateral (select json_agg(row_to_json(q)) as ${el.name} from (${el.sql})q) ct${i}  on 1=1 `).join('') || '' : '';
-
-  const where = [`"${pk}" = $1`, loadTable.query].filter((el) => el);
-  const cardColumns = cardSqlFiltered?.length ? `,${cardSqlFiltered.map((el) => el.name)}` : '';
-  const q = `select  ${pk ? `"${pk}" as id,` : ''} ${columnList.includes('geom') ? 'st_asgeojson(geom)::json as geom,' : ''} ${cols || '*'} ${cardColumns} from ${table} t ${sqlTable} ${cardSqlTable} 
-  where ${where.join(' and ') || 'true'} limit 1`;
-
-  if (query.sql === '1') { return q; }
-
-  const { rows } = await pg.query(q, [opt.id || params.id]);
-
-  await metaFormat({ rows, table: params.table });
-
-  const data = meta.card?.length ? meta.card.reduce((acc, curr) => Object.assign(acc, { [columns.find((col) => col.name === curr)?.ua || '']: rows[0][curr] }), {}) : {};
-  return {
-    time: Date.now() - time, data,
-  };
-}
+import getTemplate from './utils/getTemplate.js';
+import getMeta from '../../pg/funcs/getMeta.js';
+import metaFormat from '../funcs/metaFormat/index.js';
+
+export default async function card(req) {
+  const time = Date.now();
+  const {
+    pg, params = {}, query = {}, opt = {},
+  } = req;
+
+  const loadTable = await getTemplate('table', params.table);
+
+  if (!loadTable) { return { message: 'template not found', status: 404 }; }
+
+  const {
+    table, columns, meta, sql, cardSql,
+  } = loadTable;
+
+  const { pk, columns: dbColumns = [] } = await getMeta(table);
+
+  if (!pk) return { message: `table not found: ${table}`, status: 404 };
+
+  const cols = columns.map((el) => el.name || el).join(',');
+  const columnList = dbColumns.map((el) => el.name || el).join(',');
+  const sqlTable = sql?.filter?.((el) => !el?.disabled && el?.sql?.replace).map((el, i) => ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
+  const cardSqlFiltered = opt.id || params.id ? cardSql?.filter?.((el) => !el?.disabled && el?.name && el?.sql?.replace) : [];
+  const cardSqlTable = cardSqlFiltered?.length ? cardSqlFiltered.map((el, i) => ` left join lateral (select json_agg(row_to_json(q)) as ${el.name} from (${el.sql})q) ct${i}  on 1=1 `).join('') || '' : '';
+
+  const where = [`"${pk}" = $1`, loadTable.query].filter((el) => el);
+  const cardColumns = cardSqlFiltered?.length ? `,${cardSqlFiltered.map((el) => el.name)}` : '';
+  const q = `select  ${pk ? `"${pk}" as id,` : ''} ${columnList.includes('geom') ? 'st_asgeojson(geom)::json as geom,' : ''} ${cols || '*'} ${cardColumns} from ${table} t ${sqlTable} ${cardSqlTable} 
+  where ${where.join(' and ') || 'true'} limit 1`;
+
+  if (query.sql === '1') { return q; }
+
+  const { rows } = await pg.query(q, [opt.id || params.id]);
+
+  await metaFormat({ rows, table: params.table });
+
+  const data = meta.card?.length ? meta.card.reduce((acc, curr) => Object.assign(acc, { [columns.find((col) => col.name === curr)?.ua || '']: rows[0][curr] }), {}) : {};
+  return {
+    time: Date.now() - time, data,
+  };
+}

package/table/controllers/data.js

@@ -6,24 +6,26 @@ import getAccess from '../../crud/funcs/getAccess.js';
 import setToken from '../../crud/funcs/setToken.js';
 import gisIRColumn from './utils/gisIRColumn.js';
 
-import { applyHook } from '../../utils.js';
+import { applyHook, config } from '../../utils.js';
 
 const maxLimit = 100;
 export default async function dataAPI(req) {
   const {
-    pg, params, funcs = {}, query = {}, opt = {}, uid: uid1, session,
+    pg, params, query = {}, opt = {}, user,
   } = req;
   const time = Date.now();
 
-  const uid = session?.passport?.user?.uid || uid1 || query.uid || 0;
+  const uid = user?.uid || query.uid || 0;
 
-  const loadTable = await getTemplate('table', params.table);
-
-  const check = await applyHook('preData', { req });
-  if (check?.message && check?.status) {
-    return { message: check?.message, status: check?.status };
+  const hookData = await applyHook('preData', {
+    table: params?.table, id: params?.id, user,
+  });
+  if (hookData?.message && hookData?.status) {
+    return { message: hookData?.message, status: hookData?.status };
   }
 
+  const loadTable = await getTemplate('table', hookData?.table || params.table);
+
   if (!loadTable) { return { message: 'template not found', status: 404 }; }
 
   const {
@@ -49,7 +51,7 @@ export default async function dataAPI(req) {
 
   if (params.id && columnList.includes(params.id)) {
     return gisIRColumn({
-      pg, funcs, layer: params.table, column: params.id, sql: query.sql,
+      pg, layer: params.table, column: params.id, sql: query.sql,
     });
   }
 
@@ -93,11 +95,11 @@ export default async function dataAPI(req) {
     time: Date.now() - time, card: loadTable.card, actions: loadTable.actions, access, total, count: rows.length, pk, form, rows, meta, columns, filters,
   };
 
-  if (!funcs.config?.security?.disableToken) {
+  if (!config?.security?.disableToken) {
     const addTokens = setToken({
       ids: [JSON.stringify({ add: loadTable.table, form: loadTable.form })],
       mode: 'a',
-      uid: funcs.config?.auth?.disable || ispublic ? '1' : uid,
+      uid: config?.auth?.disable || ispublic ? '1' : uid,
       array: 1,
     });
     Object.assign(res, { addToken: addTokens[0] });
@@ -106,14 +108,16 @@ export default async function dataAPI(req) {
       const editTokens = setToken({
         ids: [JSON.stringify({ id: row.id, table: loadTable.table, form: loadTable.form })],
         mode: 'w',
-        uid: funcs.config?.auth?.disable || ispublic ? '1' : uid,
+        uid: config?.auth?.disable || ispublic ? '1' : uid,
         array: 1,
       });
       Object.assign(row, { token: editTokens[0] });
     });
   }
 
-  const result = await applyHook('afterData', { req, table: loadTable.table, res });
+  const result = await applyHook('afterData', {
+    table: loadTable.table, payload: res, user,
+  });
 
   return result || res;
 }

package/table/controllers/form.js

@@ -1,4 +1,4 @@
-import getTemplate from './utils/getTemplate.js';
+import { applyHook, getTemplate } from '../../utils.js';
 
 const sql = `select property_key as key, property_json as json, property_int as int,
 property_text as text from admin.properties where 1=1`;
@@ -11,8 +11,15 @@ async function getSettings({ pg }) {
 
 export default async function formFunction(req) {
   const time = Date.now();
-  const { pg, params } = req;
-  const form = await getTemplate('form', params.form);
+
+  const { pg, params, user } = req;
+  const hookData = await applyHook('preForm', { form: params?.form, user });
+
+  if (hookData?.message && hookData?.status) {
+    return { message: hookData?.message, status: hookData?.status };
+  }
+
+  const form = await getTemplate('form', hookData?.form || params?.form);
   if (!form) { return { status: 404, message: 'not found' }; }
 
   // replace settings
@@ -24,5 +31,12 @@ export default async function formFunction(req) {
     const res = Object.keys(match).reduce((s, m) => s.replace(m, match[m]), string);
     return { time: Date.now() - time, form: JSON.parse(res) };
   }
-  return { time: Date.now() - time, form };
+
+  const res = { time: Date.now() - time, form };
+  const res1 = await applyHook('afterForm', {
+    form: hookData?.form || params?.form,
+    payload: res,
+    user,
+  });
+  return res1 || { time: Date.now() - time, form };
 }

package/table/controllers/table.js

@@ -5,46 +5,50 @@ import { applyHook } from '../../utils.js';
 
 export default async function tableAPI(req) {
   const {
-    pg, params = {}, query = {},
+    pg, params, user, query = {},
   } = req;
-  if (!params.id) return { message: 'not enough params', status: 400 };
+  const hookData = await applyHook('preTable', {
+    table: params?.table, id: params?.id, user,
+  });
 
-  const check = await applyHook('preTable', { req });
-  if (check?.message && check?.status) {
-    return { message: check?.message, status: check?.status };
+  if (hookData?.message && hookData?.status) {
+    return { message: hookData?.message, status: hookData?.status };
   }
-  const { opt = {} } = req;
 
-  const loadTable = await getTemplate('table', opt?.table || params.table) || {};
+  if (!params?.id && !hookData?.id) {
+    return { message: 'not enough params', status: 400 };
+  }
+
+  const loadTable = await getTemplate('table', hookData?.table || params.table) || {};
   if (!loadTable) {
-    if (!pg.pk?.[opt?.table || params.table]) { return { message: 'not found', status: 404 }; }
+    if (!pg.pk?.[hookData?.table || params.table]) { return { message: 'not found', status: 404 }; }
   }
 
   const {
     table, /* columns, */ form,
   } = loadTable;
 
-  const { pk, columns: dbColumns = [] } = await getMeta(table || opt?.table || params.table);
+  const { pk, columns: dbColumns = [] } = await getMeta(table || hookData?.table || params.table);
   if (!pk) return { message: `table not found: ${table}`, status: 404 };
 
   // const cols = columns.map((el) => el.name || el).join(',');
-  const schema = await getTemplate('form', opt?.form || form) || {};
+  const schema = await getTemplate('form', hookData?.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 columnList = dbColumns.map((el) => el.name || el).join(',');
 
-  const { fields = [] } = !loadTable?.table ? await pg.query(`select * from ${table || opt?.table || params.table} limit 0`) : {};
+  const { fields = [] } = !loadTable?.table ? await pg.query(`select * from ${table || hookData?.table || params.table} limit 0`) : {};
   const cols = loadTable?.table
     ? Object.keys(schema || {}).filter((col) => columnList.includes(col) && !extraKeys.includes(col))?.map((col) => (col?.includes('geom') ? `st_asgeojson(${col})::json as "${col}"` : `"${col}"`))?.join(',')
     : fields.map((el) => (el?.name?.includes('geom') ? `st_asgeojson(${el.name})::json as "${el.name}"` : `"${el?.name}"`)).join(',');
   const where = [`"${pk}" = $1`, loadTable.query].filter((el) => el);
   const geom = columnList.includes('geom') ? ',st_asgeojson(geom)::json as geom' : '';
-  const q = `select "${pk}" as id, ${cols || '*'} ${geom} from ${table || opt?.table || params.table} t where ${where.join(' and ') || 'true'} limit 1`;
+  const q = `select "${pk}" as id, ${cols || '*'} ${geom} from ${table || hookData?.table || params.table} t where ${where.join(' and ') || 'true'} limit 1`;
 
-  if (query.sql === '1') return q;
+  if (query?.sql === '1') return q;
 
-  const { rows } = await pg.query(q, [opt?.id || params.id]);
+  const { rows } = await pg.query(q, [hookData?.id || params.id]);
 
   if (extraKeys?.length) {
     await Promise.all(rows?.map(async (row) => {
@@ -56,6 +60,8 @@ export default async function tableAPI(req) {
     }));
   }
 
-  const res = await applyHook('afterTable', { req, table: loadTable?.table, rows });
+  const res = await applyHook('afterTable', {
+    table: loadTable?.table, payload: rows, user,
+  });
   return res || rows?.[0] || {};
 }

package/table/controllers/utils/gisIRColumn.js

@@ -1,16 +1,15 @@
 import pgClients from '../../../pg/pgClients.js';
+import config from '../../../config.js';
 
 import getTemplate from './getTemplate.js';
 import getSelect from './getSelect.js';
 import getFilterSQL from '../../funcs/getFilterSQL/index.js';
 
 export default async function gisIRColumn({
-  pg = pgClients.client, funcs = {}, layer, column, sql, query = '1=1',
+  pg = pgClients.client, layer, column, sql, query = '1=1',
 }) {
   const time = Date.now();
 
-  const { config = {} } = funcs;
-
   const sel = await getSelect(query.cls || column);
 
   const body = await getTemplate('table', layer);

package/table/index.js

@@ -72,7 +72,7 @@ async function plugin(fastify, config = {}) {
 
   fastify.get(`${prefix}/suggest/:data`, { schema: suggestSchema }, suggest);
   fastify.get(`${prefix}/data/:table/:id?`, { schema: tableSchema }, data); // vs.crm.data.api с node
-  fastify.get(`${prefix}/table/:table/:id`, { schema: tableSchema }, table);
+  fastify.get(`${prefix}/table/:table/:id?`, { schema: tableSchema }, table);
   fastify.get(`${prefix}/card/:table/:id`, { schema: tableSchema }, card);
   fastify.get(`${prefix}/search`, { schema: searchSchema }, search);
 

package/test/api/applyHook.test.js

@@ -18,15 +18,14 @@ test('applyHook to API data/table', async (t) => {
   await init(pgClients.client);
   addTemplateDir(path.join(cwd, 'test/templates'));
 
-  addHook('preData', async ({ req }) => {
-    if (req.params?.table === `${table}1`) {
+  addHook('preData', async ({ table: table1 }) => {
+    if (table1 === `${table}1`) {
       return { message: 'access restricted by hook', status: 403 };
     }
     return null;
   });
-  addHook('preTable', async ({ req }) => {
-    const { params = {} } = req;
-    if (params?.table === `${table}1`) {
+  addHook('preTable', async ({ table: table1 }) => {
+    if (table1 === `${table}1`) {
       return { message: 'access restricted by hook', status: 403 };
     }
     return null;

package/test/api/crud.xss.test.js

@@ -22,7 +22,7 @@ test('api crud xss', async (t) => {
   // before
   t.test('setToken', async () => {
     addTokens = setToken({
-      ids: [JSON.stringify({ add: 'gis.dataset', form: 'test.dataset.form' })],
+      ids: [JSON.stringify({ table: 'gis.dataset', form: 'test.dataset.form' })],
       mode: 'a',
       uid: 1,
       array: 1,
@@ -44,7 +44,7 @@ test('api crud xss', async (t) => {
     });
 
     const rep = JSON.parse(res?.body);
-    console.log(rep)
+    console.log(rep);
     assert.ok(rep.status, 409);
   });
 
@@ -56,7 +56,7 @@ test('api crud xss', async (t) => {
     });
 
     const rep = JSON.parse(res?.body);
-    console.log(rep)
+    console.log(rep);
     assert.equal(rep.status, 409);
   });
   await t.test('DELETE /delete', async () => {
@@ -66,7 +66,7 @@ test('api crud xss', async (t) => {
     });
 
     const rep = JSON.parse(res?.body);
-    console.log(rep)
+    console.log(rep);
     assert.ok(rep);
   });
 });

package/test/config.example

@@ -1,18 +1,18 @@
-import config from '../config.js';
-
-Object.assign(config, {
-  folder: 'test/templates',
-  pg: {
-    host: '192.168.3.160',
-    port: 5434,
-    database: 'mbk_rivne_dma',
-    user: 'postgres',
-    password: 'postgres',
-  },
-  redis: {
-    host: '192.168.3.160',
-    port: 6379,
-    family: 4,
-  },
-});
-export default config;
+import config from '../config.js';
+
+Object.assign(config, {
+  folder: 'test/templates',
+  pg: {
+    host: '192.168.3.160',
+    port: 5434,
+    database: 'mbk_rivne_dma',
+    user: 'postgres',
+    password: 'postgres',
+  },
+  redis: {
+    host: '192.168.3.160',
+    port: 6379,
+    family: 4,
+  },
+});
+export default config;

package/test/funcs/pg.test.js

@@ -1,34 +1,34 @@
-import { test } from 'node:test';
-import assert from 'node:assert';
-
-import '../config.js';
-
-import getMeta from '../../pg/funcs/getMeta.js';
-import autoIndex from '../../pg/funcs/autoIndex.js';
-import pgClients from '../../pg/pgClients.js';
-import rclient from '../../redis/client.js';
-// import pgClients from '../../pg/funcs/pgClients.js';
-
-test('funcs pg', async (t) => {
-  await pgClients.client.init();
-  await t.test('getMeta', async () => {
-    const { columns } = await getMeta({ table: 'gis.dataset' });
-    // console.log(columns)
-    assert.ok(columns);
-  });
-
-  /* await t.test('getPG', async (t) => {
-    const data = await getPG({});
-    assert.ok(data);
-  }); */
-
-  await t.test('autoIndex', async () => {
-    await autoIndex({ table: 'gis.dataset', columns: ['service_type'] });
-    assert.ok(1);
-  });
-  t.after(() => {
-    pgClients.client.end();
-
-    rclient.quit();
-  });
-});
+import { test } from 'node:test';
+import assert from 'node:assert';
+
+import '../config.js';
+
+import getMeta from '../../pg/funcs/getMeta.js';
+import autoIndex from '../../pg/funcs/autoIndex.js';
+import pgClients from '../../pg/pgClients.js';
+import rclient from '../../redis/client.js';
+// import pgClients from '../../pg/funcs/pgClients.js';
+
+test('funcs pg', async (t) => {
+  await pgClients.client.init();
+  await t.test('getMeta', async () => {
+    const { columns } = await getMeta({ table: 'gis.dataset' });
+    // console.log(columns)
+    assert.ok(columns);
+  });
+
+  /* await t.test('getPG', async (t) => {
+    const data = await getPG({});
+    assert.ok(data);
+  }); */
+
+  await t.test('autoIndex', async () => {
+    await autoIndex({ table: 'gis.dataset', columns: ['service_type'] });
+    assert.ok(1);
+  });
+  t.after(() => {
+    pgClients.client.end();
+
+    rclient.quit();
+  });
+});

package/test/funcs/redis.test.js

@@ -1,19 +1,19 @@
-import { test } from 'node:test';
-import assert from 'node:assert';
-
-import '../config.js';
-
-import rclient from '../../redis/client.js';
-
-test('funcs redis', async (t) => {
-  await t.test('get/set', async () => {
-    await rclient.set('test', '1');
-    const d = await rclient.get('test');
-    // console.log(columns)
-    assert.equal(d, '1');
-  });
-
-  t.after(() => {
-    rclient.quit();
-  });
-});
+import { test } from 'node:test';
+import assert from 'node:assert';
+
+import '../config.js';
+
+import rclient from '../../redis/client.js';
+
+test('funcs redis', async (t) => {
+  await t.test('get/set', async () => {
+    await rclient.set('test', '1');
+    const d = await rclient.get('test');
+    // console.log(columns)
+    assert.equal(d, '1');
+  });
+
+  t.after(() => {
+    rclient.quit();
+  });
+});

package/test/helper/formatDate.test.js

@@ -0,0 +1,62 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+
+import { handlebars } from '../../utils.js';
+
+await test('formatDate helper', async () => {
+  await test('should format the date as "dd.mm.yy hh:mi" by default', async () => {
+    const template = handlebars.compile('{{formatDate "2021-09-08T12:22:27.983" format="dd.mm.yy hh:mi"}}');
+    const result = await template({});
+    assert.equal(result, '08.09.2021 12:22');
+  });
+
+  await test('should shift the date by 5 days', async () => {
+    const template = handlebars.compile('{{formatDate "2021-09-08T12:22:27.983" shift=5 format="dd.mm.yy"}}');
+    const result = await template({});
+    assert.equal(result, '13.09.2021');
+  });
+
+  await test('should format the date with Ukrainian month name', async () => {
+    const template = handlebars.compile('{{formatDate "2021-09-08T12:22:27.983" format="dd month yy" lang="ua"}}');
+    const result = await template({});
+    assert.equal(result, '08 Вересень 2021');
+  });
+
+  await test('should format the date with English month name', async () => {
+    const template = handlebars.compile('{{formatDate "2021-09-08T12:22:27.983" format="dd mw_en yy" lang="en"}}');
+    const result = await template({});
+    assert.equal(result, '08 september 2021');
+  });
+
+  await test('should format the current date if input is 0', async () => {
+    const template = handlebars.compile('{{formatDate 0 format="dd.mm.yy"}}');
+    const currentDate = new Date();
+    const expected = `${(`0${currentDate.getDate()}`).slice(-2)}.${(`0${currentDate.getMonth() + 1}`).slice(-2)}.${currentDate.getFullYear()}`;
+    const result = await template({});
+    assert.equal(result, expected);
+  });
+
+  await test('should format the date with time (hh:mi:sec)', async () => {
+    const template = handlebars.compile('{{formatDate "2021-09-08T12:22:27.983" format="dd.mm.yy hh:mi:sec"}}');
+    const result = await template({});
+    assert.equal(result, '08.09.2021 12:22:27');
+  });
+
+  await test('should shift the year by 1', async () => {
+    const template = handlebars.compile('{{formatDate "2021-09-08T12:22:27.983" shift_year=1 format="dd.mm.yy"}}');
+    const result = await template({});
+    assert.equal(result, '08.09.2022');
+  });
+
+  await test('should truncate the date to the first day of the year', async () => {
+    const template = handlebars.compile('{{formatDate "2021-09-08T12:22:27.983" trunc="year" format="dd.mm.yy"}}');
+    const result = await template({});
+    assert.equal(result, '01.01.2021');
+  });
+
+  await test('should truncate the date to the first day of the quarter', async () => {
+    const template = handlebars.compile('{{formatDate "2021-09-08T12:22:27.983" trunc="quarter" format="dd.mm.yy"}}');
+    const result = await template({});
+    assert.equal(result, '01.07.2021');
+  });
+});

package/test/templates/cls/test.json

@@ -1,10 +1,10 @@
-[
-    {
-        "id": 1,
-        "text": "test"
-    },
-    {
-        "id": 2,
-        "text": "test2"
-    }
+[
+    {
+        "id": 1,
+        "text": "test"
+    },
+    {
+        "id": 2,
+        "text": "test2"
+    }
 ]