@opengis/fastify-table 1.1.50 → 1.1.52

package/Changelog.md

@@ -1,10 +1,11 @@
 # fastify-table
 
-## 1.1.49 - 22.10.2024
+## 1.1.51 - 24.10.2024
 
 - addHook params refactor
 - add getFolder, handlebars to utils
 - refactor getAccess for CRUD
+- add migrations
 
 ## 1.1.40 - 18.10.2024
 

package/cron/index.js

@@ -1,10 +1,12 @@
 import cronApi from './controllers/cronApi.js';
 import addCron from './funcs/addCron.js';
 
+import { cronSchema } from './schema.js'
+
 async function plugin(fastify, config = {}) {
   const prefix = config.prefix || '/api';
   fastify.decorate('addCron', addCron);
-  fastify.get(`${prefix}/cron/:name`, {}, cronApi);
+  fastify.get(`${prefix}/cron/:name`, { schema: cronSchema }, cronApi);
 }
 
 export default plugin;

package/cron/schema.js

@@ -0,0 +1,8 @@
+const cronSchema = {
+  params: {
+    name: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+  },
+};
+
+export default null;
+export { cronSchema };

package/crud/funcs/getAccess.js

@@ -30,6 +30,8 @@ export default async function getAccess({ table, user = {} }) {
   const body = await getTemplate('table', table) || {};
 
   // console.log(user?.type);
+  if (body.access === 'admin' && user?.type !== 'admin') return null;
+
   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' };
   }

package/crud/index.js

@@ -9,12 +9,7 @@ import insert from './controllers/insert.js';
 import deleteCrud from './controllers/deleteCrud.js';
 import getAccessFunc from './funcs/getAccess.js';
 
-const tableSchema = {
-  params: {
-    id: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    table: { type: 'string', pattern: '^([\\w\\d_.]+)$' },
-  },
-};
+import { tableSchema } from './schema.js';
 
 async function plugin(fastify, config = {}) {
   const prefix = config.prefix || '/api';

package/crud/schema.js

@@ -0,0 +1,11 @@
+const tableSchema = {
+  params: {
+    id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+    table: { type: 'string', pattern: '^([\\w\\d_.]+)$' },
+  },
+};
+
+export {
+  tableSchema,
+};
+export default null;

package/notification/controllers/readNotifications.js

@@ -7,7 +7,7 @@ export default async function readNotifications({
     return { message: 'access restricted', status: 403 };
   }
 
-  try {
+
     const { userId } = await pg.query('select uid as "userId" from admin.users where $1 in (uid,login) limit 1', [uid])
       .then((res) => res.rows?.[0] || {});
 
@@ -23,8 +23,5 @@ export default async function readNotifications({
     const { rowCount = 0 } = await pg.query(q, [userId, params?.id].filter((el) => el));
 
     return { message: `${rowCount} unread notifications marked as read`, status: 200 };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
+
 }

package/notification/controllers/testEmail.js

@@ -22,7 +22,6 @@ export default async function testNotification({
     return { message: 'param to is required', status: 400 };
   }
 
-  try {
     const {
       to, template, table, id, nocache,
     } = query;
@@ -43,8 +42,5 @@ export default async function testNotification({
     return {
       message: data || 'ok',
     };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
+
 }

package/notification/controllers/userNotifications.js

@@ -31,7 +31,7 @@ export default async function userNotifications({
   const limit = Math.min(maxLimit, +(query.limit || 5));
   const offset = query.page && query.page > 0 ? (query.page - 1) * limit : 0;
 
-  try {
+
     const { userId } = await pg.query('select uid as "userId" from admin.users where $1 in (uid,login) limit 1', [uid])
       .then((res) => res.rows?.[0] || {});
 
@@ -57,8 +57,5 @@ export default async function userNotifications({
     }
 
     return { time: Date.now() - time, total: rows?.length, rows };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
+
 }

package/notification/index.js

@@ -4,17 +4,12 @@ import testEmail from './controllers/testEmail.js';
 import addNotification from './funcs/addNotification.js'; // add to db
 import notification from './funcs/sendNotification.js'; // send notification
 
+import emailSchema from './schema.js'
+
 async function plugin(fastify, config = {}) {
   const prefix = config.prefix || '/api';
 
-  fastify.route({
-    method: 'GET',
-    url: `${prefix}/test-email`,
-    config: {
-      policy: ['user'],
-    },
-    handler: testEmail,
-  });
+  fastify.get(`${prefix}/test-email`, { config: { policy: ['user'] }, schema: emailSchema }, testEmail);
 
   fastify.decorate('addNotification', addNotification);
   fastify.decorate('notification', notification);

package/notification/schema.js

@@ -0,0 +1,10 @@
+const emailSchema = {
+  quertstring: {
+    to: { type: 'string', pattern: '^((?!\\.)[\\w\\-_.]*[^.])(@\\w+)(\\.\\w+(\\.\\w+)?[^.\\W])$' },
+  },
+};
+
+export {
+  emailSchema,
+};
+export default null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.1.50",
+  "version": "1.1.52",
   "type": "module",
   "description": "core-plugins",
   "main": "index.js",

package/server/migrations/roles.sql

@@ -37,6 +37,8 @@ alter table admin.routes DROP constraint if exists admin_route_menu_id_fkey casc
 alter table admin.routes add column if not exists route_id text NOT NULL default next_id();
 alter table admin.routes add column if not exists alias text NOT NULL;
 alter table admin.routes add column if not exists table_name text NOT NULL;
+alter table admin.routes add column if not exists actions text[];
+alter table admin.routes add column if not exists access text;
 alter table admin.routes add column if not exists title text;
 alter table admin.routes add column if not exists public boolean;
 alter table admin.routes add column if not exists menu_id text;
@@ -50,6 +52,10 @@ alter table admin.routes add CONSTRAINT admin_route_id_pkey PRIMARY KEY (route_i
 COMMENT ON TABLE admin.routes IS 'Список інтерфейсів';
 COMMENT ON COLUMN admin.routes.route_id IS 'Ідентифікатор інтерфейса';
 COMMENT ON COLUMN admin.routes.alias IS 'Назва файлу інтерфейса';
+
+COMMENT ON COLUMN admin.routes.access IS 'Рівень доступу';
+COMMENT ON COLUMN admin.routes.actions IS 'Дії';
+
 COMMENT ON COLUMN admin.routes.table_name IS 'Таблиця в БД';
 COMMENT ON COLUMN admin.routes.title IS 'Назва інтерфейсу українською';
 COMMENT ON COLUMN admin.routes.public IS 'Ознака чи для всіх показується';

package/server.js

@@ -1,7 +1,7 @@
 // This file contains code that we reuse
 // between our tests.
 import Fastify from 'fastify';
-import config from './test/config.js';
+import config from './config.js';
 import appService from './index.js';
 import logger from './logger/getLogger.js';
 import loggerTest from './logger/logger.test.api.js';

package/table/controllers/data.js

@@ -59,7 +59,14 @@ export default async function dataAPI(req) {
 
   if (params.id && columnList.includes(params.id)) {
     return gisIRColumn({
-      pg, layer: params.table, column: params.id, sql: query.sql,
+      pg,
+      layer: params.table,
+      column: params.id,
+      sql: query.sql,
+      filter: query.filter,
+      state: query.state,
+      search: query.search,
+      custom: query.custom,
     });
   }
 

package/table/controllers/filter.js

@@ -3,17 +3,28 @@ import getSelect from './utils/getSelect.js';
 import getMeta from '../../pg/funcs/getMeta.js';
 import getFilterSQL from '../funcs/getFilterSQL/index.js';
 
-export default async function filter(req) {
+export default async function filterAPI(req) {
   const time = Date.now();
 
   const {
-    params,
+    params, query = {},
   } = req;
   const loadTable = await getTemplate('table', params.table);
   if (!loadTable) { return { status: 404, message: 'not found' }; }
   const { columns } = await getMeta({ table: loadTable.table });
 
-  const { optimizedSQL = `select * from ${loadTable.table}` } = loadTable?.sql ? await getFilterSQL({ table: params.table, pg: req.pg }) : {};
+  const {
+    filter, custom, state, search,
+  } = query;
+
+  const { optimizedSQL = `select * from ${loadTable.table}` } = loadTable?.sql || filter || custom || state || search ? await getFilterSQL({
+    pg: req.pg,
+    table: params.table,
+    filter,
+    custom,
+    state,
+    search,
+  }) : {};
 
   const filters = loadTable?.filters || loadTable?.filterList || [];
   await Promise.all(filters.filter((el) => el.data).map(async (el) => {

package/table/controllers/search.js

@@ -59,7 +59,6 @@ export default async function search({
 }) {
   const time = Date.now();
 
-  try {
     const tables = query.table ? [query.table] : await getTemplates('table');
     const res = { rows: [], sql: [], total: 0 };
 
@@ -73,8 +72,5 @@ export default async function search({
     return {
       time: Date.now() - time, total: res.total, count: res.rows.length, rows: res.rows,
     };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
+
 }

package/table/controllers/utils/gisIRColumn.js

@@ -6,7 +6,7 @@ import getSelect from './getSelect.js';
 import getFilterSQL from '../../funcs/getFilterSQL/index.js';
 
 export default async function gisIRColumn({
-  pg = pgClients.client, layer, column, sql, query = '1=1',
+  pg = pgClients.client, layer, column, sql, query = '1=1', filter, state, search, custom,
 }) {
   const time = Date.now();
 
@@ -14,25 +14,30 @@ export default async function gisIRColumn({
 
   const body = await getTemplate('table', layer);
   const fData = await getFilterSQL({
-    table: body?.table || layer, query: body?.query,
+    table: layer, 
+    filter,
+    state,
+    search,
+    custom,
   });
 
   const { tlist } = await pg.one(`select array_agg((select nspname from pg_namespace where oid=relnamespace)||'.'||relname) tlist from pg_class 
   where relkind in ('r','v','m')`);
 
   const tableName = body?.table || layer;
-  if (!tlist.includes(body?.table || layer)) return { error: `table not found: ${tableName}`, status: 400 };
+  if (!tlist.includes(tableName)) return { error: `table not found: ${tableName}`, status: 400 };
 
   // eslint-disable-next-line max-len
-  const { fields } = await pg.query(`select * from (${fData?.optimizedSQL || `select * from ${body?.table || layer}`})q limit 0`);
+  const { fields } = await pg.query(`select * from (${fData?.optimizedSQL || `select * from ${tableName}`})q limit 0`);
 
   const col = fields.find((el) => el.name === column);
 
   if (!col) return { status: 404, message: 'not found' };
   const colField = pg.pgType[col.dataTypeID]?.includes('[]') ? `unnest(${column})` : column;
 
-  const q = `select ${colField} as id, count(*)::int from ${tableName} t where ${body?.query || 'true'} 
-  group by ${colField} order by count desc limit 15`;
+  const q = `select ${colField} as id, count(*)::int from (
+    ${fData?.optimizedSQL || `select * from ${tableName} where ${body?.query || 'true'}`}
+  )t group by ${colField} order by count desc limit 15`;
 
   if (sql) return q;
 

package/table/schema.js

@@ -1,12 +1,22 @@
 const tableSchema = {
-  querystring1: {
+  querystring: {
+    limit: { type: 'string', pattern: '^(\\d+)$' },
     page: { type: 'string', pattern: '^(\\d+)$' },
-    order: { type: 'string', pattern: '^(\\d+)$' },
-    filter: { type: 'string', pattern: '^([\\w\\d_-]+)=([\\w\\d_-]+)$' },
+    // filter: { type: 'string', pattern: '^([\\w\\d_-]+)=([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
+    // search: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' },
+    order: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+    desc: { type: 'string', pattern: '^(\\d+)$' },
+    // state: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+    // custom: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+    bbox: { type: 'string', pattern: '^([\\d\\s,.-]+)$' },
+    polyline: { type: 'string', pattern: '^([\\d\\w\\|@\\/\\{\\}~_`]+)$' },
+    key: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.-]+)$' },
+    uid: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+    sql: { type: 'string', pattern: '^(\\d)$' },
   },
   params: {
     id: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    table: { type: 'string', pattern: '^([\\w\\d_.]+)$' },
+    table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
   },
 };
 
@@ -14,38 +24,38 @@ const searchSchema = {
   querystring: {
     page: { type: 'string', pattern: '^(\\d+)$' },
     limit: { type: 'string', pattern: '^(\\d+)$' },
-    order: { type: 'string', pattern: '^([\\w_.]+)$' },
-    desc: { type: 'string', pattern: '^(desc)|(asc)$' },
-    key: { type: 'string', pattern: '^([\\w\\d_]+)$' },
-    table: { type: 'string', pattern: '^([\\w\\d_.]+)$' },
+    order: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+    desc: { type: 'string', pattern: '^(\\d+)$' },
+    key: { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.-]+)$' },
+    table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
     sql: { type: 'string', pattern: '^(\\d)$' },
   },
 };
 
 const suggestSchema = {
   querystring: {
-    lang: { type: 'string', pattern: '^([\\w.]+)$' },
-    // parent: { type: 'string', pattern: '^([\\w,./]+)$' },
-    sel: { type: 'string', pattern: '^([\\w,./]+)$' },
-    name: { type: 'string', pattern: '^([\\w,./]+)$' },
-    // key: { type: 'string', pattern: '^([\\w\\d_]+)$' },
-    // val: { type: 'string', pattern: '^([\\w.,]+)$' },
+    lang: { type: 'string', pattern: '^([\\w]+)$' },
+    parent: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+    sel: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+    name: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+    // key: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
+    val: { type: 'string', pattern: '([\\d\\w]+)$' },
     sql: { type: 'string', pattern: '^(\\d)$' },
   },
   params: {
-    id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+  //  data: { type: 'string', pattern: '^([\\d\\w]+)$' },
   },
 };
 
 const formSchema = {
   params: {
-    form: { type: 'string', pattern: '^([\\w\\d_.]+)$' },
+    form: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
   },
 };
 
 const filterSchema = {
   params: {
-    table: { type: 'string', pattern: '^([\\w\\d_.]+)$' },
+    table: { type: 'string', pattern: '^([\\d\\w_.-]+)$' },
   },
 };
 

package/user/controllers/user.cls.js

@@ -36,7 +36,7 @@ export default async function userCls(req) {
 
   if (query?.sql) return q;
 
-  try {
+
     const { rows = [] } = await pg.query(q, [uid, params.id].filter((el) => el));
 
     rows.forEach((row) => {
@@ -68,8 +68,4 @@ export default async function userCls(req) {
     }));
 
     return { message: { rows: rows.concat(res) }, status: 200 };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 200 };
-  }
 }

package/user/controllers/user.cls.post.js

@@ -22,7 +22,7 @@ export default async function userClsPost({
     return { message: 'invalid params: sql (string)', status: 400 };
   }
 
-  try {
+
     const { rowCount = 0 } = await pg.query(`with recursive rows as (
       select user_clsid, name, code, icon, color, parent
       from admin.user_cls a
@@ -48,8 +48,5 @@ export default async function userClsPost({
       return { id, children: rows };
     }
     return { id, data };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
+
 }

package/user/controllers/user.info.js

@@ -10,12 +10,8 @@ export default async function userInfo({
   const data = await pg.query(`select user_name, sur_name, father_name, user_rnokpp, user_type, email, login from admin.users 
   where uid=$1`, [uid]).then((res) => res.rows?.[0] || {});
 
-  try {
     const { notifications = 0 } = await pg.query(`select count(*)::int as notifications from crm.notifications 
     where addressee_id=$1 and read is not true`, [uid]).then((res) => res.rows?.[0] || {});
     return { uid, ...data, notifications };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
+
 }

package/user/index.js

@@ -3,44 +3,15 @@ import userClsId from './controllers/user.cls.id.js';
 import userInfo from './controllers/user.info.js';
 import userClsPost from './controllers/user.cls.post.js';
 
+import { userClsSchema, userClsIdSchema } from './schema.js'
+
 async function plugin(fastify, opts) {
   const { prefix = '/api' } = opts || {};
-  fastify.route({
-    method: 'GET',
-    url: `${prefix}/user-cls`,
-    config: {
-      policy: ['user'],
-    },
-    schema: {},
-    handler: userCls,
-  });
-  fastify.route({
-    method: 'GET',
-    url: `${prefix}/user-cls/:id`,
-    config: {
-      policy: ['user'],
-    },
-    schema: {},
-    handler: userClsId,
-  });
-  fastify.route({
-    method: 'POST',
-    url: `${prefix}/user-cls`,
-    config: {
-      policy: ['user'],
-    },
-    schema: {},
-    handler: userClsPost,
-  });
-  fastify.route({
-    method: 'GET',
-    url: `${prefix}/user-info`,
-    config: {
-      policy: ['user'],
-    },
-    schema: {},
-    handler: userInfo,
-  });
+
+  fastify.get(`${prefix}/user-cls`, { config: { policy: ['user'] }, schema: userClsSchema }, userCls);
+  fastify.get(`${prefix}/user-cls/:id`, { config: { policy: ['user'] }, schema: userClsIdSchema }, userClsId);
+  fastify.get(`${prefix}/user-info`, { config: { policy: ['user'] } }, userInfo);
+  fastify.post(`${prefix}/user-cls/:id`, { config: { policy: ['user'] }, schema: userClsIdSchema }, userClsPost);
 }
 
 export default plugin;

package/user/schema.js

@@ -0,0 +1,17 @@
+const userClsSchema = {
+  params: {
+    id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+  },
+  quertstring: {
+    sql: { type: 'string', pattern: '^(\\d)$' },
+  },
+};
+
+const userClsIdSchema = {
+  params: {
+    id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+  },
+};
+
+export { userClsSchema, userClsIdSchema };
+export default null;

package/util/controllers/logger.file.js

@@ -14,13 +14,13 @@ import getRootDir from './utils/getRootDir.js';
  */
 
 export default async function loggerFile({
-  params = {}, user = {}, query = {}, originalUrl, funcs = {},
+  log, params = {}, user = {}, query = {}, originalUrl,
 }, reply) {
   const limit = 200000;
-  const access = await checkUserAccess({ user });
+  const access = checkUserAccess({ user });
+  // log.info('Сервер запущен по адресу?'); // test!
 
-  const { config = {} } = funcs;
-  if (access?.status === 403 && !config?.local) return access;
+  if (access?.status !== 200) return access;
 
   // absolute / relative path
   const rootDir = getRootDir();
@@ -28,7 +28,7 @@ export default async function loggerFile({
   const filepath = path.join(rootDir, params['*'] || '');
 
   if (!existsSync(filepath)) {
-    return { error: 'file not exists', status: 404 };
+    return { message: 'file not exists', status: 404 };
   }
   const stat = await lstat(filepath);
   const isFile = stat.isFile();

package/util/controllers/properties.add.js

@@ -34,7 +34,7 @@ export default async function addExtraProperties({
     return { message: 'table not found: crm.properties', status: 400 };
   }
 
-  try {
+
     await pg.query('delete from crm.properties where object_id=$1', [id]); // rewrite?
     const keyTypeMatch = extraProperties.filter((key) => body[key]).reduce((acc, curr) => Object.assign(acc, checkKeyType({ body, key: curr })), {});
     const res = await Promise.all(Object.keys(keyTypeMatch).map(async (key) => {
@@ -53,8 +53,4 @@ export default async function addExtraProperties({
       return { id: rows[0]?.property_id, type: propertyType, value: body[key] };
     }));
     return { message: { rows: res }, status: 200 };
-  }
-  catch (err) {
-    return { error: err.toString(), status: 500 };
-  }
 }

package/util/controllers/properties.get.js

@@ -5,7 +5,7 @@ export default async function getExtraProperties({
     if (!id) {
         return { message: 'not enougn params', status: 400 };
     }
-    try {
+
         const { rows = [] } = pg.pk?.['crm.properties']
             ? await pg.query(`select property_key, property_type, property_text, property_int,
             property_json, property_date from crm.properties where property_key is not null and object_id=$1`, [id])
@@ -14,7 +14,4 @@ export default async function getExtraProperties({
 
         const data = rows.reduce((acc, curr) => Object.assign(acc, { [curr.property_key]: curr[`property_${curr.property_type}`] }), {});
         return { message: data, status: 200 };
-    } catch (err) {
-        return { error: err.toString(), status: 500 };
-    }
 }

package/util/controllers/utils/checkUserAccess.js

@@ -1,14 +1,17 @@
+import config from '../../../config.js';
+
 /**
  *
  * @summary check user access to logger interface - per admin user type or user group
  * @returns {Object} message, status
  */
 
-export default async function checkUserAccess({
-  user,
+export default function checkUserAccess({
+  user = {},
 }) {
-  // console.log(user);
-  if (!user?.uid) return { message: 'access restricted', status: 403 };
+  if (user?.uid && !config?.local) {
+    return { message: 'access restricted', status: 403 };
+  }
 
   /* if (!['admin', 'superadmin']?.includes(user.user_type) && count === '0') {
     return { message: 'access restricted', status: 403 };

package/util/index.js

@@ -4,11 +4,7 @@ import nextId from './controllers/next.id.js';
 import statusMonitor from './controllers/status.monitor.js';
 import loggerFile from './controllers/logger.file.js';
 
-const propertiesSchema = {
-  params: {
-    id: { type: 'string', pattern: '^([\\d\\w]+)$' },
-  },
-};
+import { propertiesSchema, loggerSchema } from './schema.js'
 
 async function plugin(fastify, config = {}) {
   const prefix = config.prefix || '/api';
@@ -17,7 +13,7 @@ async function plugin(fastify, config = {}) {
   fastify.get(`${prefix}/status-monitor`, {}, statusMonitor);
   fastify.get(`${prefix}/properties/:id`, { schema: propertiesSchema }, getExtraProperties);
   fastify.post(`${prefix}/properties/:id`, { schema: propertiesSchema }, addExtraProperties);
-  fastify.get('/logger-file/*', { config: { policy: ['log'] } }, loggerFile);
+  fastify.get('/logger-file/*', { config: { policy: ['log'] }, schema: loggerSchema }, loggerFile);
 }
 
 export default plugin;

package/util/schema.js

@@ -0,0 +1,19 @@
+const propertiesSchema = {
+    params: {
+      id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+    },
+  };
+  const loggerSchema = {
+    // params: {
+    //   
+    // },
+    querystring: {
+        download: { type: 'string', pattern: '^(\\d+)$' },
+        full: { type: 'string', pattern: '^(\\d+)$' },
+        dir: { type: 'string', pattern: '^(\\d+)$' },
+    }
+  };
+  export { 
+    propertiesSchema, loggerSchema
+ }
+export default null;

package/utils.js

@@ -14,6 +14,7 @@ import getPGAsync from './pg/funcs/getPGAsync.js';
 import initPG from './pg/funcs/init.js';
 import pgClients from './pg/pgClients.js';
 import getRedis from './redis/funcs/getRedis.js';
+import redisClients from './redis/funcs/redisClients.js';
 
 import dataInsert from './crud/funcs/dataInsert.js';
 import dataUpdate from './crud/funcs/dataUpdate.js';
@@ -54,6 +55,7 @@ export {
   addCron,
   execMigrations,
   getRedis,
+  redisClients,
   logger,
   isFileExists,
 

package/widget/controllers/widget.del.js

@@ -34,11 +34,8 @@ export default async function widgetDel({
   };
   const sql = sqls[type];
   if (!sql) return { error: 'type not valid', status: 401 };
-  try {
-    await pg.query(sql, [objectid, user.uid, id]);
-    return { data: { id }, user: { uid: user.uid, name: user.user_name } };
-  }
-  catch (err) {
-    return { message: err.toString(), status: 500 };
-  }
+  
+  await pg.query(sql, [objectid, user.uid, id]);
+  return { data: { id }, user: { uid: user.uid, name: user.user_name } };
+  
 }

package/widget/controllers/widget.get.js

@@ -65,7 +65,7 @@ export default async function widgetGet({
     return { error: 'param type not valid', status: 400 };
   }
 
-  try {
+
     /* data */
     const time = [Date.now()];
     const { rows } = await pg.query(sql, [objectid, params.type === 'gallery' ? galleryExtList : null].filter((el) => el));
@@ -93,10 +93,4 @@ export default async function widgetGet({
       data: { author: data?.author, cdate: data?.cdate, edate: data?.editor_date },
       objectid: params.objectid,
     };
-  }
-  catch (err) {
-    // 'history', 'file',  'checklist'
-    /* 'document', 'image' - Макс на клиенте */
-    return { message: err.toString(), status: 500 };
-  }
 }

package/widget/controllers/widget.set.js

@@ -26,7 +26,7 @@ export default async function widgetSet(req) {
 
   const table = tableList[type];
 
-  try {
+
     if (['gallery', 'file'].includes(type)) {
       const file = await funcs.uploadMultiPart(req);
       const extName = path.extname(file.filepath).slice(1).toLowerCase();
@@ -71,9 +71,4 @@ export default async function widgetSet(req) {
     return {
       rowCount: result.rowCount, data: 'ok', command: result.command, id: result.rows?.[0]?.[pkList[type]] || result?.[pkList[type]],
     };
-  }
-  catch (err) {
-    log.error('widget/upload', { error: err.toString(), params });
-    return { error: err.toString(), status: 500 };
-  }
 }