@opengis/fastify-table 1.3.63 → 1.3.65

package/package.json

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

package/server/plugins/cron/funcs/runCron.js

@@ -9,15 +9,16 @@ export default async function runCron({
     const unique = await verifyUnique(name);
     if (!unique) return;
 
-    const db = pg.options.database;
+    const db = pg?.options?.database;
+    if (!db) return;
 
     try {
         const data = await func({ pg });
-        const subdir = !!data ? 'cron' : 'cron/null';
+        const subdir = data ? 'cron' : 'cron/null';
         logger.file(subdir, { db, name, result: data });
     }
     catch (err) {
         logger.file('cron', { db, name, error: err.toString() });
         logger.error(err);
     }
-}
+}

package/server/plugins/cron/funcs/verifyUnique.js

@@ -9,6 +9,7 @@ const md5 = (string) => createHash('md5').update(string).digest('hex');
 const rclient = getRedis();
 
 export default async function verifyUnique(name) {
+    if (!config.redis) return true; // skip if redis is disabled
     const cronId = config.port || 3000 + md5(name);
     // one per node check
     const key = `cron:unique:${cronId}`;
@@ -19,4 +20,4 @@ export default async function verifyUnique(name) {
     }
     await rclient.expire(key, 20);
     return true;
-}
+}

package/server/plugins/cron/index.js

@@ -1,37 +1,39 @@
 import { createHash } from 'node:crypto';
 
-import config from "../../../config.js";
+import config from '../../../config.js';
 
-import getPG from "../pg/funcs/getPG.js";
-import pgClients from "../pg/pgClients.js";
+import getPG from '../pg/funcs/getPG.js';
+import pgClients from '../pg/pgClients.js';
 import getRedis from '../redis/funcs/getRedis.js';
-import logger from "../logger/getLogger.js";
-import interval2ms from "./funcs/interval2ms.js";
+import logger from '../logger/getLogger.js';
+import interval2ms from './funcs/interval2ms.js';
 
 const rclient = getRedis();
 
 async function runCron({
     pg = pgClients.client, query, name,
 }) {
-    const db = pg.options.database;
+    const db = pg?.options?.database;
 
     // verifyUnique
     const key = `cron:unique:${name}`;
-    const unique = await rclient.setnx(key, 1);
-    const ttl = await rclient.ttl(key);
+    const unique = config.redis ? await rclient.setnx(key, 1) : null;
+    const ttl = config.redis ? await rclient.ttl(key) : -1;
 
     if (!unique && ttl !== -1) {
         // if (config.trace) console.log(name, db, query, 'skip unique');
         return;
     }
 
-    await rclient.expire(key, 20);
+    if (config.redis) {
+        await rclient.expire(key, 20);
+    }
 
     try {
-        if (!pg.pk) await pg.init();
+        if (!pg.pk && config.pg) { await pg.init(); }
 
         if (config.trace) console.time(`${db}:${query}`);
-        const { command, rows = [], rowCount } = await pg.query(query);
+        const { command, rows = [], rowCount } = pg?.pk ? await pg.query(query) : {};
         if (config.trace) console.timeEnd(`${db}:${query}`);
 
         logger.file('cron', { db, name, result: { command, rows, rowCount } });

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

@@ -2,6 +2,7 @@ import getPG from '../../pg/funcs/getPG.js';
 import getMeta from '../../pg/funcs/getMeta.js';
 import getRedis from '../../redis/funcs/getRedis.js';
 import pgClients from '../../pg/pgClients.js';
+import config from '../../../../config.js';
 
 import extraData from '../../extra/extraData.js';
 import logChanges from './utils/logChanges.js';
@@ -15,7 +16,7 @@ export default async function dataDelete({
   const pg = pg1 || getPG({ name: 'client' });
 
   // pg client single transaction support
-  if (!pg.pk) {
+  if (!pg?.pk && config.pg) {
     pg.options = pgClients.client?.options;
     pg.tlist = pgClients.client?.tlist;
     pg.pgType = pgClients.client?.pgType;
@@ -25,7 +26,9 @@ export default async function dataDelete({
 
   const { pk } = await getMeta({ pg, table })
     .catch(err => {
-      logger.file('crud/delete', { error: err.toString(), stack: err.stack, table, id, referer, uid });
+      logger.file('crud/delete', {
+        error: err.toString(), stack: err.stack, table, id, referer, uid,
+      });
       throw new Error(err.toString());
     });
   const table1 = table.replace(/"/g, '');
@@ -38,7 +41,9 @@ export default async function dataDelete({
 
   const res = await pg.query(delQuery, [id])
     .catch(err => {
-      logger.file('crud/delete', { error: err.toString(), stack: err.stack, table, id, referer, uid, q: delQuery });
+      logger.file('crud/delete', {
+        error: err.toString(), stack: err.stack, table, id, referer, uid, q: delQuery,
+      });
       throw new Error(err.toString());
     })
     .then(el => el.rows?.[0] || {});
@@ -46,6 +51,6 @@ export default async function dataDelete({
   await logChanges({
     pg, table, tokenData, referer, id, uid, type: 'DELETE',
   });
-  rclient.incr(`pg:${table}:crud`);
+  if (config.redis) { rclient.incr(`pg:${table}:crud`); }
   return { ...res, ...extraRes || {} };
 }

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

@@ -2,6 +2,7 @@ import getPG from '../../pg/funcs/getPG.js';
 import getMeta from '../../pg/funcs/getMeta.js';
 import getRedis from '../../redis/funcs/getRedis.js';
 import pgClients from '../../pg/pgClients.js';
+import config from '../../../../config.js';
 
 import logChanges from './utils/logChanges.js';
 import logger from '../../logger/getLogger.js';
@@ -15,7 +16,7 @@ export default async function dataInsert({
   const pg = pg1 || getPG({ name: 'client' });
 
   // pg client single transaction support
-  if (!pg.pk) {
+  if (!pg?.pk && config.pg) {
     pg.options = pgClients.client?.options;
     pg.tlist = pgClients.client?.tlist;
     pg.pgType = pgClients.client?.pgType;
@@ -32,7 +33,9 @@ export default async function dataInsert({
   Object.assign(data, {
     ...(id && pg.pk?.[table] ? { [pg.pk?.[table]]: id } : {}),
     ...(table !== 'admin.users' ? { uid } : {}),
-    editor_id: uid, created_by: uid, updated_by: uid,
+    editor_id: uid,
+    created_by: uid,
+    updated_by: uid,
     // editor_id: uid,
   });
 
@@ -52,13 +55,17 @@ export default async function dataInsert({
 
   const res = await pg.query(insertQuery, [...filterData.map((el) => (typeof el[1] === 'object' && (!Array.isArray(el[1]) || typeof el[1]?.[0] === 'object') ? JSON.stringify(el[1]) : el[1]))])
     .catch(err => {
-      logger.file('crud/insert', { error: err.toString(), stack: err.stack, table, id, referer, uid, q: insertQuery });
+      logger.file('crud/insert', {
+        error: err.toString(), stack: err.stack, table, id, referer, uid, q: insertQuery,
+      });
       throw new Error(err.toString());
     }).then(el => el || {});
 
   const table1 = pg.pk[table] ? table : table.replace(/"/g, '');
 
-  const extraRes = await extraData({ table, form: tokenData?.form, id: res.rows?.[0]?.[pg.pk[table1]], data, uid }, pg);
+  const extraRes = await extraData({
+    table, form: tokenData?.form, id: res.rows?.[0]?.[pg.pk[table1]], data, uid,
+  }, pg);
   if (extraRes && res?.rows?.[0]) {
     Object.assign(res.rows[0], { ...extraRes });
   }
@@ -74,6 +81,6 @@ export default async function dataInsert({
     type: 'INSERT',
   });
 
-  rclient.incr(`pg:${table}:crud`);
+  if (config.redis) { rclient.incr(`pg:${table}:crud`); }
   return res;
 }

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

@@ -2,6 +2,7 @@ import getPG from '../../pg/funcs/getPG.js';
 import getMeta from '../../pg/funcs/getMeta.js';
 import getRedis from '../../redis/funcs/getRedis.js';
 import pgClients from '../../pg/pgClients.js';
+import config from '../../../../config.js';
 
 import extraData from '../../extra/extraData.js';
 import logChanges from './utils/logChanges.js';
@@ -28,7 +29,7 @@ export default async function dataUpdate({
   const pg = pg1 || getPG({ name: 'client' });
 
   // pg client single transaction support
-  if (!pg.pk) {
+  if (!pg?.pk && config.pg) {
     pg.options = pgClients.client?.options;
     pg.tlist = pgClients.client?.tlist;
     pg.pgType = pgClients.client?.pgType;
@@ -72,17 +73,39 @@ export default async function dataUpdate({
   // console.log(updateQuery, filterValue);
   const res = await pg.query(updateQuery, [id, ...filterValue])
     .catch(err => {
-      logger.file('crud/update', { error: err.toString(), stack: err.stack, table, id, referer, uid, data, q: updateQuery });
+      logger.file('crud/update', {
+        error: err.toString(),
+        stack: err.stack,
+        table,
+        id,
+        referer,
+        uid,
+        data,
+        q: updateQuery,
+      });
       throw new Error(err.toString());
     })
     .then(el => el?.rows?.[0]) || {};
 
-  const extraRes = await extraData({ table, form: tokenData?.form, id, data, uid }, pg);
+  const extraRes = await extraData({
+    table,
+    form: tokenData?.form,
+    id,
+    data,
+    uid,
+  }, pg);
 
   await logChanges({
-    pg, table, tokenData, referer, data, id, uid, type: 'UPDATE',
+    pg,
+    table,
+    tokenData,
+    referer,
+    data,
+    id,
+    uid,
+    type: 'UPDATE',
   });
 
-  rclient.incr(`pg:${table}:crud`);
+  if (config.redis) { rclient.incr(`pg:${table}:crud`); }
   return { ...res, ...extraRes || {} };
 }

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

@@ -1,9 +1,10 @@
+import config from '../../../../config.js';
 import getRedis from '../../redis/funcs/getRedis.js';
 
-// import { getRedis } from '../../../../utils.js';
+const rclient = getRedis({ db: 0 });
 
 export default async function getOpt(token, uid = 0) {
-  const rclient = getRedis({ db: 0 });
+  if (!config.redis) return null;
 
   const key = `opt:${uid}:${token}`;
   // console.log(key);

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

@@ -15,14 +15,15 @@ const keys = {
   e: '%s:token:exec:%s',
 };
 
+const rclient = getRedis({ db: 0 });
+
 async function getToken({
   uid, token, json,
 }) {
+  if (!config.redis) return null;
   const mode = 'w';
   // if (mode === 'r') return token;
 
-  const rclient = getRedis({ db: 0 });
-
   const key = sprintf(keys[mode], config?.pg?.database, uid?.toString());
   const id = await rclient.hget(key, token);
   // console.log(key, token);

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

@@ -1,21 +1,21 @@
 import { createHash, randomUUID } from 'crypto';
 
-const random = randomUUID();
-
+import config from '../../../../config.js';
 import getRedis from '../../redis/funcs/getRedis.js';
 
-// import { getRedis } from '../../../../utils.js';
+const random = randomUUID();
+const rclient = getRedis({ db: 0 });
 
 function md5(string) {
   return createHash('md5').update(string).digest('hex');
 }
 
 export default function setOpt(params, uid = 0) {
+  if (!config.redis) return null;
   const token = Buffer.from(md5(typeof params === 'object' ? JSON.stringify(params) : params) + random, 'hex').toString('base64').replace(/[+-=]+/g, '');
   // const token = md5(params);
   const key = `opt:${uid}:${token}`;
 
-  const rclient = getRedis({ db: 0 });
   rclient.set(key, JSON.stringify(params), 'EX', 60 * 60);
   return token;
 }

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

@@ -23,8 +23,7 @@ const generateCodes = (ids, userToken) => {
 function setToken({
   ids: idsOrigin, uid, array,
 }) {
-  //  const rclient5 = getRedis({ db: 0, funcs });
-
+  if (!config.redis) return null;
   if (!uid) return { user: 'empty' };
   if (!Object.keys(idsOrigin).length) return { ids: 'empty' };
 

package/server/plugins/logger/getLogger.js

@@ -49,6 +49,7 @@ if (config.debug) {
 logger.metrics = function metrics(key, val, dbName) {
   const dbname = dbName || config.pg?.database;
   if (!dbname && !isServer) return;
+  if (!config.redis) return;
   rclient2.hincrby(`${dbname}:system_metrics`, key, val || 1);
 };
 

package/server/plugins/metric/loggerSystem.js

@@ -3,7 +3,9 @@ import process from 'process';
 import util from 'node:util';
 import { exec } from 'node:child_process';
 
-import { config, getFolder, pgClients, getRedis } from '../../../utils.js';
+import {
+  config, getFolder, pgClients, getRedis,
+} from '../../../utils.js';
 
 const execAsync = util.promisify(exec);
 const platform = os.platform();
@@ -21,9 +23,9 @@ const sqlQuery = `select datname as dbname, application_name as app, client_addr
 
 export default async function loggerSystem(req) {
   const { pg = pgClients.client } = req;
-  const dbName = pg.options?.database;
+  const dbName = pg?.options?.database;
 
-  const dbsize = await rclient.get(`${dbName}:content:dbsize:${redisKey}`);
+  const dbsize = config.redis ? await rclient.get(`${dbName}:content:dbsize:${redisKey}`) : null;
 
   const dbVerion = await pg.query('select version();').then(el => el.rows?.[0]?.version);
 
@@ -46,7 +48,7 @@ export default async function loggerSystem(req) {
   const resource = process.resourceUsage();
 
   const currentCpuUsage = (((process.cpuUsage().user + process.cpuUsage().system) * 1000) / totalCpu) * 100;
-  const redisInfo = await rclient.info();
+  const redisInfo = config.redis ? await rclient.info() : '';
 
   const lines = redisInfo.split('\r\n').filter((el) => el && el.split);
   const redis = {};
@@ -58,21 +60,21 @@ export default async function loggerSystem(req) {
     }
   }
 
-  await rclient.set(`${dbName}:content:dbsize:${redisKey}`, dbSize, 'EX', 30 * 60);
+  if (config.redis) { await rclient.set(`${dbName}:content:dbsize:${redisKey}`, dbSize, 'EX', 30 * 60); }
 
-  const latency = await rclient.latency('latest');
+  const latency = config.redis ? await rclient.latency('latest') : null;
 
-  const uptime = await pg.query(`select extract('epoch' from current_timestamp - pg_postmaster_start_time())::int as uptime`)
+  const uptime = await pg.query('select extract(\'epoch\' from current_timestamp - pg_postmaster_start_time())::int as uptime')
     .then(el => el.rows?.[0]?.uptime);
 
-  const metric5 = await rclient2.hgetall(`${dbName}:system_metrics`);
+  const metric5 = config.redis ? await rclient2.hgetall(`${dbName}:system_metrics`) : {};
 
   Object.keys(metric5 || {}).filter((el) => el.startsWith('time')).forEach((m) => {
     metric5[m] /= 1000.0;
   });
 
   const metricSort = metric5 ? JSON.parse(JSON.stringify(metric5, Object.keys(metric5).sort())) : undefined;
-  const userOnline = await rclient2.scan(['0', 'match', `${dbName}:user:*`, 'count', '10000']);
+  const userOnline = config.redis ? await rclient2.scan(['0', 'match', `${dbName}:user:*`, 'count', '10000']) : [];
   // const userOnline = await rclient10.scan(['0', 'match', 'sess:*', 'count', '10000']);
 
   return {
@@ -80,8 +82,8 @@ export default async function loggerSystem(req) {
       root: process.cwd(),
       processFolder,
       saveDirectory: filesFolder,
-      dbhost: pg.options?.host,
-      dbport: pg.options?.port,
+      dbhost: pg?.options?.host,
+      dbport: pg?.options?.port,
       dbname: dbName,
     },
 
@@ -101,7 +103,7 @@ export default async function loggerSystem(req) {
       'node.cpu.time': resource.systemCPUTime,
       'node.cpu.load': os.loadavg()[0],
       'redis.ram': redis.used_memory_human,
-      'redis.latency': latency?.join(','),
+      'redis.latency': latency?.join?.(','),
       'redis.ram.peak': redis.used_memory_peak_human,
       'redis.clients': redis.connected_clients,
       'redis.db0': redis.db0?.split(',')?.[0]?.substring(5),
@@ -126,4 +128,4 @@ export default async function loggerSystem(req) {
     top: topProcess,
     query,
   };
-};
+}

package/server/plugins/metric/systemMetricsFifthly.js

@@ -1,6 +1,7 @@
 import pgClients from '../pg/pgClients.js';
 import logger from '../logger/getLogger.js';
 import getRedis from '../redis/funcs/getRedis.js';
+import config from '../../../config.js';
 
 import loggerSystem from './loggerSystem.js';
 
@@ -8,9 +9,9 @@ const rclient2 = getRedis({ db: 2 });
 
 export default async function systemMetricsFifthly({ pg = pgClients.client }) {
   const system = await loggerSystem({ pg });
-  const dbName = pg.options?.database;
+  const dbName = pg?.options?.database;
 
-  await rclient2.del(`${dbName}:system_metrics`);
+  if (config.redis) { await rclient2.del(`${dbName}:system_metrics`); }
 
   logger.file('metric', {
     dbname: dbName,
@@ -20,4 +21,4 @@ export default async function systemMetricsFifthly({ pg = pgClients.client }) {
   });
 
   return { message: 'Saved Fifthly' };
-}
+}

package/server/plugins/migration/exec.sql.js

@@ -31,7 +31,7 @@ export default async function execSql(filepath, pg = pgClients.client) {
     const sql = readFileSync(filepath, 'utf-8');
 
     const hash = createHash('md5').update(sql).digest('hex');
-    const hashes = await rclient.hgetall(`${pg.options?.database}:migration-hashes`).then(obj => Object.keys(obj));
+    const hashes = config.redis ? await rclient.hgetall(`${pg?.options?.database}:migration-hashes`).then(obj => Object.keys(obj)) : [];
 
     if (hashes.includes(hash) && !config.disableCache) {
         console.log(filename, 'skip equal hash', Date.now() - start);
@@ -41,7 +41,7 @@ export default async function execSql(filepath, pg = pgClients.client) {
     try {
         console.log(filename, 'start', Date.now() - start);
         await pg.query(sql);
-        if (!config.disableCache) await rclient.hset(`${pg.options?.database}:migration-hashes`, hash, 1);
+        if (!config.disableCache && config.redis) await rclient.hset(`${pg?.options?.database}:migration-hashes`, hash, 1);
         console.log(filename, 'finish', Date.now() - start);
         logger.file('migration/success', {
             filepath,

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

@@ -5,6 +5,7 @@ const data = {};
 // decorator
 export default async function getMeta(opt, nocache) {
   const pg = opt?.pg || getPG({ name: 'client' });
+  if (!pg) return { error: 'pg connection not established', status: 400 };
   const table = opt?.table || opt;
 
   if (pg?.options?.database && data[pg.options.database]?.[table] && !nocache) return data[pg.options.database][table];

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

@@ -20,8 +20,8 @@ function getPG(param) {
   if (pgClients[name]) return pgClients[name];
 
   const dbConfig = {
-    user: user || config.pg?.user,
-    password: password || config.pg?.password,
+    user: user || config.pg?.user || 'postgres',
+    password: password || config.pg?.password || 'postgres',
     host: host || config.pg?.host,
     port: port || config.pg?.port,
     database: db || database || config.pg?.db || config.pg?.database,

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

@@ -21,8 +21,8 @@ async function getPGAsync(param) {
   if (pgClients[name]?.tlist) return pgClients[name];
 
   const dbConfig = {
-    user: user || config.pg?.user,
-    password: password || config.pg?.password,
+    user: user || config.pg?.user || 'postgres',
+    password: password || config.pg?.password || 'postgres',
     host: host || config.pg?.host,
     port: port || config.pg?.port,
     database: db || database || config.pg?.db || config.pg?.database,

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

@@ -7,7 +7,7 @@ import logger from '../../logger/getLogger.js';
 const rclient = getRedis({ db: 0 });
 
 async function init(client) {
-  if (!client.options?.database) {
+  if (!client?.options?.database) {
     return;
   }
   const textQuery = `select 
@@ -23,7 +23,7 @@ async function init(client) {
       from pg_class where relkind in ('r','v')`);
   const relkinds = rows.reduce((acc, curr) => Object.assign(acc, { [curr.tname]: curr.relkind }), {});
 
-  async function query(q, args = [], isstream) {
+  async function query(q, args = [], isstream = false) {
     try {
       if (isstream) {
         await client.query('set statement_timeout to 100000000');
@@ -83,13 +83,13 @@ async function init(client) {
 
     // CRUD table state
     const keyCacheTable = `pg:${table}:crud`;
-    const crudInc = table ? await rclient.get(keyCacheTable) || 0 : 0;
+    const crudInc = table && config.redis ? (await rclient.get(keyCacheTable) || 0) : 0;
 
     //
     const hash = createHash('sha1').update([q, JSON.stringify(args)].join()).digest('base64');
     const keyCache = `pg:${hash}:${crudInc}`;
 
-    const cacheData = await rclient.get(keyCache);
+    const cacheData = config.redis ? await rclient.get(keyCache) : null;
 
     if (cacheData && !config.local) {
       // console.log('from cache', table, query);
@@ -98,7 +98,7 @@ async function init(client) {
 
     const data = await query(q, args || []);
 
-    if (seconds > 0) {
+    if (seconds > 0 && config.redis) {
       rclient.set(keyCache, JSON.stringify(data), 'EX', seconds);
     }
 

package/server/plugins/policy/funcs/checkPolicy.js

@@ -75,12 +75,12 @@ export default function checkPolicy(req, reply) {
   }
 
   /* === policy: public === */
-  if (policy.includes('public') || skipCheckPolicy(path)) {
+  if (policy.includes('public') || skipCheckPolicy(path) || !config.pg || config.auth?.disable || config.local || config.debug || unittest) {
     return null;
   }
 
   /* === 0. policy: unauthorized access from admin URL === */
-  if (!validToken && !user?.uid && !config.auth?.disable && isAdmin && !policy.includes('public')) {
+  if (!validToken && !user?.uid && isAdmin && !policy.includes('public')) {
     logger.file('policy/unauthorized', {
       path, method, params, query, body, token: headers?.token, userId: headers?.uid, ip: req.ip, headers, message: 'unauthorized',
     });
@@ -88,7 +88,7 @@ export default function checkPolicy(req, reply) {
   }
 
   /* === 3. policy: user === */
-  if (!validToken && !user && policy.includes('user') && config.pg && !config.auth?.disable && !skipCheckPolicy(path)) {
+  if (!validToken && !user && policy.includes('user') && !skipCheckPolicy(path)) {
     logger.file('policy/user', {
       path, method, params, query, body, message: 'access restricted: 3',
     });
@@ -96,7 +96,7 @@ export default function checkPolicy(req, reply) {
   }
 
   /* === 4. policy: referer === */
-  if (!validToken && !headers?.referer?.includes?.(hostname) && policy.includes('referer') && !config.local && !config.debug) {
+  if (!validToken && !headers?.referer?.includes?.(hostname) && policy.includes('referer')) {
     logger.file('policy/referer', {
       path, method, params, query, body, message: 'access restricted: 4', uid: user?.uid,
     });
@@ -104,7 +104,7 @@ export default function checkPolicy(req, reply) {
   }
 
   /* === 5. policy: site auth === */
-  if (!validToken && !policy.includes('site') && !isAdmin && !config.local && !config.debug && !unittest) {
+  if (!validToken && !policy.includes('site') && !isAdmin) {
     logger.file('policy/site', {
       path, method, params, query, body, message: 'access restricted: 5', uid: user?.uid,
     });
@@ -112,7 +112,7 @@ export default function checkPolicy(req, reply) {
   }
 
   /* === 6. base policy: block non-public api w/ out authorization  === */
-  if (!validToken && isAdmin && !isUser && isServer && !config.local && !config.debug) {
+  if (!validToken && isAdmin && !isUser && isServer) {
     logger.file('policy/api', {
       path, method, params, query, body, message: 'access restricted: 6', uid: user?.uid,
     });

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

@@ -1,13 +1,14 @@
 import getSelect from '../getSelect.js';
 import pgClients from '../../../pg/pgClients.js';
-import redis from '../../../redis/client.js';
+import rclient from '../../../redis/client.js';
+import config from '../../../../../config.js';
 
 const selectIds = {};
 export default async function getSelectVal({
   pg = pgClients.client, name, values: valuesOrigin, ar = false,
 }) {
   if (!valuesOrigin?.length) return null;
-  const values = valuesOrigin.filter(el => typeof el === 'boolean' ? true : el).map(el => el.toString());
+  const values = valuesOrigin.filter(el => (typeof el === 'boolean' ? true : el)).map(el => el.toString());
   const cls = await getSelect(name, pg);
 
   // === array  ===
@@ -26,7 +27,7 @@ export default async function getSelectVal({
 
   // cache
   const key = `select:${name}`;
-  const cache = values?.length ? (await redis.hmget(key, values)).reduce((p, el, i) => ({ ...p, [values[i]]: el }), {}) : {};
+  const cache = values?.length && config.redis ? (await rclient.hmget(key, values)).reduce((p, el, i) => ({ ...p, [values[i]]: el }), {}) : {};
   const filteredValues = values.filter(el => !cache[el]);
 
   // query select
@@ -37,8 +38,8 @@ export default async function getSelectVal({
 
   const clsObj = { ...cache, ...data.reduce((p, el) => ({ ...p, [el.id.toString()]: el.color ? el : el.text }), {}) };
 
-  if (data?.length) {
-    redis.hmset(key, clsObj);
+  if (data?.length && config.redis) {
+    rclient.hmset(key, clsObj);
   }
 
   if (ar) {

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

@@ -75,7 +75,7 @@ export default async function tableAPI(req) {
   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 (data[key] && !Array.isArray(data[key])) { data[key] = null; }
   });
 
   if (extraKeys?.length) {
@@ -93,7 +93,7 @@ export default async function tableAPI(req) {
       ids: [JSON.stringify({ id, table: tableName, form: loadTable.form })],
       uid: user.uid,
       array: 1,
-    })[0];
+    })?.[0];
   }
 
   await extraDataGet({ rows: [data], table: tableName, form: hookData?.form || tokenData?.form || loadTable.form }, pg);

package/server/routes/dblist/controllers/readItems.js

@@ -1,4 +1,4 @@
-import { dblist, getRedis } from '../../../../utils.js';
+import { config, dblist, getRedis } from '../../../../utils.js';
 
 import formatData from '../utils/formatData.js';
 
@@ -12,10 +12,17 @@ export default async function readItemList(req) {
     || '2';
 
   const key = `current-db:${uid}`;
-  const ttl = await rclient.ttl(key);
-  const currentId = await rclient.get(key);
+  const ttl = config.redis ? await rclient.ttl(key) : null;
+  const currentId = config.redis ? await rclient.get(key) : null;
   rclient.setex(key, 60 * 60 * 10000, currentId);
 
   const { originalMaxAge, expires } = req.session?.cookie || {};
-  return { ttl, current: currentId || rows[0]?.id, rows, user: { ...req.user, originalMaxAge, expires, uid }, };
+  return {
+    ttl,
+    current: currentId || rows[0]?.id,
+    rows,
+    user: {
+      ...req.user, originalMaxAge, expires, uid,
+    },
+  };
 }

package/server/routes/dblist/controllers/setItem.js

@@ -1,4 +1,4 @@
-import { dblist, getRedis } from '../../../../utils.js';
+import { config, dblist, getRedis } from '../../../../utils.js';
 
 const rclient = getRedis();
 
@@ -19,7 +19,7 @@ export default async function setItem(req) {
     || req.session?.passport?.user?.username // login passwd
     || '2';
 
-  await rclient.setex(`current-db:${uid}`, 60 * 60 * 10000, id);
+  if (config.redis) { await rclient.setex(`current-db:${uid}`, 60 * 60 * 10000, id); }
 
   return { current: id };
 }

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

@@ -9,8 +9,8 @@ import locales from './utils/locales.js';
 import conditions from './utils/conditions.js';
 
 const components = {
-  'vs-widget-file': `select 'vs-widget-file' as component, count(*) from crm.files where entity_id=$1 and file_status<>3`,
-  'vs-widget-comments': `select 'vs-widget-comments' as component, count(*) from crm.communications where entity_id=$1`
+  'vs-widget-file': 'select \'vs-widget-file\' as component, count(*) from crm.files where entity_id=$1 and file_status<>3',
+  'vs-widget-comments': 'select \'vs-widget-comments\' as component, count(*) from crm.communications where entity_id=$1',
 };
 
 const checkInline = {};
@@ -42,40 +42,38 @@ export default async function dataAPI(req, reply, called) {
   if (!checkInline[params?.table] && loadTable?.sql?.length && loadTable.table) {
     const filterSql = loadTable.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 ${loadTable.table})t ${sqlTable} limit 0`).then(el => el.fields)))
+    const d = await Promise.all(filterSql.map((el, i) => pg.query(`select  ${el.name || `t${i}`}.* from(select * from ${loadTable.table})t ${sqlTable} limit 0`).then(item => item.fields)));
     d.forEach((el, i) => {
-      filterSql[i].inline = el.length == 1 ? true : false;
+      filterSql[i].inline = el.length === 1;
       filterSql[i].fields = el.map(f => f.name);
     });
     checkInline[params?.table] = loadTable.sql;
-  } else if (checkInline[params?.table]) {
-    loadTable.sql = checkInline[params?.table]
+  }
+  else if (checkInline[params?.table]) {
+    loadTable.sql = checkInline[params?.table];
   }
 
   if (query.sql === '0') return loadTable;
 
+  if (!config.pg) { return reply.status(500).send('empty pg'); }
+
   if (!loadTable && !(tokenData?.table && pg.pk?.[tokenData?.table]) && !(called && pg.pk?.[params?.table])) {
-    return { message: 'template not found', status: 404 };
+    return reply.status(404).send('template not found');
   }
 
   const id = tokenData?.id || hookData?.id || params?.id;
   const { actions = [], query: accessQuery } = await getAccess({ table: tokenData?.table || hookData?.table || params.table, id, user }, pg) || {};
 
   if (!actions.includes('view') && !config?.local && !called) {
-    return { message: 'access restricted', status: 403 };
+    return reply.status(403).send('access restricted');
   }
 
   const {
     table, columns = [], sql, cardSql, filters, form, meta, sqlColumns, public: ispublic, editable = false,
   } = loadTable || tokenData || params;
 
-  const columns1 = columns || dbColumns.map(({ name, title, dataTypeID }) => ({ name, title, type: pg.pgType[dataTypeID] }));
-  columns1.forEach(col => {
-    Object.assign(col, locales[`${table || params.table}.${col.name}`] || {});
-  });
-
   const tableMeta = await getMeta({ pg, table });
-  timeArr.push(Date.now())
+  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 });
@@ -83,7 +81,14 @@ export default async function dataAPI(req, reply, called) {
 
   const { pk, columns: dbColumns = [] } = tableMeta || {};
 
-  if (!pk) return { message: `table not found: ${table}`, status: 404 };
+  const columns1 = columns || dbColumns.map(({ name, title, dataTypeID }) => ({ name, title, type: pg.pgType[dataTypeID] }));
+  columns1.forEach(col => {
+    Object.assign(col, locales[`${table || params.table}.${col.name}`] || {});
+  });
+
+  if (!pk) {
+    return reply.status(404).send(`table not found: ${table}`);
+  }
 
   const columnList = dbColumns.map((el) => el.name || el).join(',');
   const sqlTable = sql?.filter?.((el) => !el?.disabled && !el.inline && el?.sql?.replace && (!el.sql.includes('{{uid}}') || uid)).map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
@@ -179,7 +184,7 @@ export default async function dataAPI(req, reply, called) {
     throw new Error(err.toString());
   });
 
-  timeArr.push(Date.now())
+  timeArr.push(Date.now());
 
   if (uid && rows.length && editable) {
     rows.forEach(row => {
@@ -187,7 +192,7 @@ export default async function dataAPI(req, reply, called) {
         ids: [JSON.stringify({ id: row.id, table: tokenData?.table || hookData?.table || params.table, form: loadTable?.form })],
         uid,
         array: 1,
-      })[0];
+      })?.[0];
     });
   }
 
@@ -209,14 +214,14 @@ export default async function dataAPI(req, reply, called) {
     ? { total: rows.length, filtered: rows.length }
     : await pg.queryCache?.(qCount, { table: loadTable?.table || tokenData?.table, time: 5 }).then(el => el?.rows[0] || {});
 
-  timeArr.push(Date.now())
+  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, sufix }, pg);
-  timeArr.push(Date.now())
+  timeArr.push(Date.now());
   const status = [];
   if (loadTable?.meta?.status) {
     const statusColumn = loadTable.meta?.cls?.[loadTable.meta?.status]
@@ -237,19 +242,19 @@ export default async function dataAPI(req, reply, called) {
 
   const tokens = {};
   if (template && objectId) {
-
     // tokens result
     if (index?.tokens && typeof index?.tokens === 'object' && !Array.isArray(index?.tokens)) {
       Object.keys(index.tokens || {})
         .filter(key => index?.tokens[key]?.public
           || actions?.includes?.('edit')
           || actions?.includes?.('add')
-          || !index?.tokens[key]?.table
-        )
+          || !index?.tokens[key]?.table)
         .forEach(key => {
           const item = index?.tokens[key];
           Object.keys(item).filter(el => item[el]?.includes?.('{{')).forEach(el => {
-            item[el] = handlebarsSync.compile(item[el])({ user, uid: user?.uid, id, data: rows[0] });
+            item[el] = handlebarsSync.compile(item[el])({
+              user, uid: user?.uid, id, data: rows[0],
+            });
           });
 
           const token = item.form && item.table ? setToken({
@@ -261,43 +266,47 @@ export default async function dataAPI(req, reply, called) {
         });
     }
 
-    // conditions 
+    // conditions
     panels?.filter(el => el.items).forEach(el => {
-      el.items = el.items?.filter(el => conditions(el.conditions, rows[0]));
+      el.items = el.items?.filter(item => conditions(item.conditions, rows[0]));
     });
 
     // title, count
     panels?.filter(el => el.items).forEach(async el => {
-      const filtered = el.items.filter(el => el.count?.toLowerCase?.().includes('select'));
-      const data = await Promise.all(filtered.map(el => pg.query(el.count).then(el => el.rows[0] || {})))
-      filtered.forEach((el, i) => {
-        Object.assign(el, data[i] || {}, data[i].count ? {} : { count: undefined })
+      const filtered1 = el.items.filter(item => item.count?.toLowerCase?.().includes('select'));
+      const data = await Promise.all(filtered1.map(item => pg.query(item.count).then(item1 => item1.rows[0] || {})));
+      filtered1.forEach((el1, i) => {
+        Object.assign(el1, data[i] || {}, data[i].count ? {} : { count: undefined });
       });
-      const q = el.items.map((el) => el.component ? components[el.component] : null).filter(el => el).join(' union all ');
-      const counts = q && id
+      const q1 = el.items.map((item) => (item.component ? components[item.component] : null)).filter(item => item).join(' union all ');
+      const counts1 = q1 && id
         ? await pg.query(q, [id])
           .then(e => e.rows.reduce((acc, curr) => Object.assign(acc, { [curr.component]: curr.count }), {}))
         : {};
-      el.items?.filter?.(item => item.component)?.forEach(item => Object.assign(item, { count: counts?.[item.component] }));
+      el.items?.filter?.(item => item.component)?.forEach(item => Object.assign(item, { count: counts1?.[item.component] }));
     });
 
     // data result
     const data = {};
-    const route = pg.pk?.['admin.routes'] ? await pg.query(`select route_id as path, title from admin.routes where enabled and alias=$1 limit 1`, [table])
+    const route = pg.pk?.['admin.routes'] ? await pg.query('select route_id as path, title from admin.routes where enabled and alias=$1 limit 1', [table])
       .then(el => el.rows?.[0] || {}) : {};
     Object.assign(route, { tableTitle: loadTable?.title });
     if (index?.data && index?.data?.[0]?.name) {
       await Promise.all(index.data.filter((el) => el?.name && el?.sql).map(async (el) => {
-        const q = handlebarsSync.compile(el.sql)({ data: rows[0], user, uid: user?.uid, id });
-        const { rows: sqlData } = await pg.query(q);
+        const q2 = handlebarsSync.compile(el.sql)({
+          data: rows[0], user, uid: user?.uid, id,
+        });
+        const { rows: sqlData } = await pg.query(q2);
         data[el.name] = sqlData;
       }));
     }
 
     // html
     await Promise.all(template.filter(el => el[0].includes('.hbs')).map(async (el) => {
-      const htmlContent = await handlebars.compile(el[1])({ ...rows[0], user, data, tokens });
-      const name = el[0].substring(0, el[0].lastIndexOf('.'))
+      const htmlContent = await handlebars.compile(el[1])({
+        ...rows[0], user, data, tokens,
+      });
+      const name = el[0].substring(0, el[0].lastIndexOf('.'));
       html[name] = htmlContent;
     }));
   }
@@ -338,7 +347,11 @@ export default async function dataAPI(req, reply, called) {
   // console.log({ add: loadTable.table, form: loadTable.form });
   if (uid && actions.includes('add')) {
     const addTokens = setToken({
-      ids: [JSON.stringify({ table: tokenData?.table || hookData?.table || params.table, form: loadTable?.form })],
+      ids: [
+        JSON.stringify({
+          table: tokenData?.table || hookData?.table || params.table,
+          form: loadTable?.form,
+        })],
       uid,
       array: 1,
     });
@@ -346,7 +359,12 @@ export default async function dataAPI(req, reply, called) {
   }
 
   const result = await applyHook('afterData', {
-    pg, table: loadTable?.table || tokenData?.table, id: tokenData?.id || hookData?.id || params.id, template: tokenData?.table || hookData?.table || params.table, payload: res, user,
+    pg,
+    table: loadTable?.table || tokenData?.table,
+    id: tokenData?.id || hookData?.id || params.id,
+    template: tokenData?.table || hookData?.table || params.table,
+    payload: res,
+    user,
   });
 
   return result || res;