dbgate-api 5.5.4-alpha.2 → 5.5.4-alpha.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api",
   "main": "src/index.js",
-  "version": "5.5.4-alpha.2",
+  "version": "5.5.4-alpha.4",
   "homepage": "https://dbgate.org/",
   "repository": {
     "type": "git",
@@ -26,10 +26,10 @@
     "compare-versions": "^3.6.0",
     "cors": "^2.8.5",
     "cross-env": "^6.0.3",
-    "dbgate-datalib": "^5.5.4-alpha.2",
+    "dbgate-datalib": "^5.5.4-alpha.4",
     "dbgate-query-splitter": "^4.10.5",
-    "dbgate-sqltree": "^5.5.4-alpha.2",
-    "dbgate-tools": "^5.5.4-alpha.2",
+    "dbgate-sqltree": "^5.5.4-alpha.4",
+    "dbgate-tools": "^5.5.4-alpha.4",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -75,7 +75,7 @@
   "devDependencies": {
     "@types/fs-extra": "^9.0.11",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "^5.5.4-alpha.2",
+    "dbgate-types": "^5.5.4-alpha.4",
     "env-cmd": "^10.1.0",
     "node-loader": "^1.0.2",
     "nodemon": "^2.0.2",

package/src/controllers/archive.js

@@ -6,7 +6,7 @@ const { archivedir, clearArchiveLinksCache, resolveArchiveFolder } = require('..
 const socket = require('../utility/socket');
 const loadFilesRecursive = require('../utility/loadFilesRecursive');
 const getJslFileName = require('../utility/getJslFileName');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const dbgateApi = require('../shell');
 const jsldata = require('./jsldata');
 const platformInfo = require('../utility/platformInfo');
@@ -74,7 +74,7 @@ module.exports = {
         ...fileType('.matview.sql', 'matview.sql'),
       ];
     } catch (err) {
-      logger.error({ err }, 'Error reading archive files');
+      logger.error(extractErrorLogData(err), 'Error reading archive files');
       return [];
     }
   },

package/src/controllers/auth.js

@@ -1,7 +1,7 @@
 const axios = require('axios');
 const jwt = require('jsonwebtoken');
 const getExpressPath = require('../utility/getExpressPath');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const AD = require('activedirectory2').promiseWrapper;
 const crypto = require('crypto');
 const { getTokenSecret, getTokenLifetime } = require('../auth/authCommon');
@@ -71,7 +71,7 @@ function authMiddleware(req, res, next) {
       return next();
     }
 
-    logger.error({ err }, 'Sending invalid token error');
+    logger.error(extractErrorLogData(err), 'Sending invalid token error');
 
     return unauthorizedResponse(req, res, 'invalid token');
   }

package/src/controllers/connections.js

@@ -12,7 +12,7 @@ const { pickSafeConnectionInfo } = require('../utility/crypting');
 const JsonLinesDatabase = require('../utility/JsonLinesDatabase');
 
 const processArgs = require('../utility/processArgs');
-const { safeJsonParse, getLogger } = require('dbgate-tools');
+const { safeJsonParse, getLogger, extractErrorLogData } = require('dbgate-tools');
 const platformInfo = require('../utility/platformInfo');
 const { connectionHasPermission, testConnectionPermission } = require('../utility/hasPermission');
 const pipeForkLogs = require('../utility/pipeForkLogs');
@@ -430,7 +430,7 @@ module.exports = {
       socket.emit('got-volatile-token', { strmid, savedConId: conid, volatileConId: volatile._id });
       return { success: true };
     } catch (err) {
-      logger.error({ err }, 'Error getting DB token');
+      logger.error(extractErrorLogData(err), 'Error getting DB token');
       return { error: err.message };
     }
   },
@@ -446,7 +446,7 @@ module.exports = {
       const resp = await authProvider.login(null, null, { conid: volatile._id });
       return resp;
     } catch (err) {
-      logger.error({ err }, 'Error getting DB token');
+      logger.error(extractErrorLogData(err), 'Error getting DB token');
       return { error: err.message };
     }
   },

package/src/controllers/databaseConnections.js

@@ -12,6 +12,7 @@ const {
   extendDatabaseInfo,
   modelCompareDbDiffOptions,
   getLogger,
+  extractErrorLogData,
 } = require('dbgate-tools');
 const { html, parse } = require('diff2html');
 const { handleProcessCommunication } = require('../utility/processComm');
@@ -146,7 +147,7 @@ module.exports = {
       try {
         conn.subprocess.send({ msgid, ...message });
       } catch (err) {
-        logger.error({ err }, 'Error sending request do process');
+        logger.error(extractErrorLogData(err), 'Error sending request do process');
         this.close(conn.conid, conn.database);
       }
     });
@@ -318,7 +319,7 @@ module.exports = {
       try {
         existing.subprocess.send({ msgtype: 'ping' });
       } catch (err) {
-        logger.error({ err }, 'Error pinging DB connection');
+        logger.error(extractErrorLogData(err), 'Error pinging DB connection');
         this.close(conid, database);
 
         return {
@@ -362,7 +363,7 @@ module.exports = {
         try {
           existing.subprocess.kill();
         } catch (err) {
-          logger.error({ err }, 'Error killing subprocess');
+          logger.error(extractErrorLogData(err), 'Error killing subprocess');
         }
       }
       this.opened = this.opened.filter(x => x.conid != conid || x.database != database);

package/src/controllers/serverConnections.js

@@ -11,7 +11,7 @@ const processArgs = require('../utility/processArgs');
 const { testConnectionPermission } = require('../utility/hasPermission');
 const { MissingCredentialsError } = require('../utility/exceptions');
 const pipeForkLogs = require('../utility/pipeForkLogs');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 
 const logger = getLogger('serverConnection');
 
@@ -112,7 +112,7 @@ module.exports = {
         try {
           existing.subprocess.kill();
         } catch (err) {
-          logger.error({ err }, 'Error killing subprocess');
+          logger.error(extractErrorLogData(err), 'Error killing subprocess');
         }
       }
       this.opened = this.opened.filter(x => x.conid != conid);
@@ -167,7 +167,7 @@ module.exports = {
         try {
           opened.subprocess.send({ msgtype: 'ping' });
         } catch (err) {
-          logger.error({ err }, 'Error pinging server connection');
+          logger.error(extractErrorLogData(err), 'Error pinging server connection');
           this.close(conid);
         }
       })
@@ -217,7 +217,7 @@ module.exports = {
       try {
         conn.subprocess.send({ msgid, ...message });
       } catch (err) {
-        logger.error({ err }, 'Error sending request');
+        logger.error(extractErrorLogData(err), 'Error sending request');
         this.close(conn.conid);
       }
     });

package/src/controllers/sessions.js

@@ -8,7 +8,7 @@ const path = require('path');
 const { handleProcessCommunication } = require('../utility/processComm');
 const processArgs = require('../utility/processArgs');
 const { appdir } = require('../utility/directories');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const pipeForkLogs = require('../utility/pipeForkLogs');
 const config = require('./config');
 
@@ -222,7 +222,7 @@ module.exports = {
     try {
       session.subprocess.send({ msgtype: 'ping' });
     } catch (err) {
-      logger.error({ err }, 'Error pinging session');
+      logger.error(extractErrorLogData(err), 'Error pinging session');
 
       return {
         status: 'error',

package/src/controllers/uploads.js

@@ -1,7 +1,7 @@
 const crypto = require('crypto');
 const path = require('path');
 const { uploadsdir, getLogsFilePath } = require('../utility/directories');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const logger = getLogger('uploads');
 const axios = require('axios');
 const os = require('os');
@@ -110,7 +110,7 @@ module.exports = {
 
       return response.data;
     } catch (err) {
-      logger.error({ err }, 'Error uploading gist');
+      logger.error(extractErrorLogData(err), 'Error uploading gist');
 
       return {
         apiErrorMessage: err.message,

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '5.5.4-alpha.2',
-  buildTime: '2024-10-01T08:41:09.234Z'
+  version: '5.5.4-alpha.4',
+  buildTime: '2024-10-01T10:23:19.199Z'
 };

package/src/proc/databaseConnectionProcess.js

@@ -7,6 +7,8 @@ const {
   getLogger,
   isCompositeDbName,
   dbNameLogCategory,
+  extractErrorMessage,
+  extractErrorLogData,
 } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
@@ -34,25 +36,6 @@ function getStatusCounter() {
   return statusCounter;
 }
 
-function extractErrorMessage(err, defaultMessage) {
-  if (!err) {
-    return defaultMessage;
-  }
-  if (err.errors) {
-    try {
-      return err.errors.map(x => x.message).join('\n');
-    } catch (e2) {}
-  }
-  if (err.message) {
-    return err.message;
-  }
-  const s = `${err}`;
-  if (s && (!s.endsWith('Error') || s.includes(' '))) {
-    return s;
-  }
-  return defaultMessage;
-}
-
 async function checkedAsyncCall(promise) {
   try {
     const res = await promise;
@@ -261,7 +244,7 @@ async function handleDriverDataCore(msgid, callMethod, { logName }) {
     const result = await callMethod(driver);
     process.send({ msgtype: 'response', msgid, result });
   } catch (err) {
-    logger.error(err, `Error when handling message ${logName}`);
+    logger.error(extractErrorLogData(err, { logName }), `Error when handling message ${logName}`);
     process.send({ msgtype: 'response', msgid, errorMessage: extractErrorMessage(err, 'Error executing DB data') });
   }
 }
@@ -436,7 +419,7 @@ function start() {
     try {
       await handleMessage(message);
     } catch (err) {
-      logger.error({ err }, 'Error in DB connection');
+      logger.error(extractErrorLogData(err), 'Error in DB connection');
       process.send({ msgtype: 'error', error: extractErrorMessage(err, 'Error processing message') });
     }
   });

package/src/proc/sshForwardProcess.js

@@ -3,7 +3,7 @@ const platformInfo = require('../utility/platformInfo');
 const childProcessChecker = require('../utility/childProcessChecker');
 const { handleProcessCommunication } = require('../utility/processComm');
 const { SSHConnection } = require('../utility/SSHConnection');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 
 const logger = getLogger('sshProcess');
 
@@ -40,7 +40,7 @@ async function handleStart({ connection, tunnelConfig }) {
       tunnelConfig,
     });
   } catch (err) {
-    logger.error({ err }, 'Error creating SSH tunnel connection:');
+    logger.error(extractErrorLogData(err), 'Error creating SSH tunnel connection:');
 
     process.send({
       msgtype: 'error',

package/src/shell/dataDuplicator.js

@@ -19,32 +19,39 @@ async function dataDuplicator({
   systemConnection,
 }) {
   if (!driver) driver = requireEngineDriver(connection);
-  const pool = systemConnection || (await connectUtility(driver, connection, 'write'));
+  
+  const dbhan = systemConnection || (await connectUtility(driver, connection, 'write'));
 
-  logger.info(`Connected.`);
+  try {
+    logger.info(`Connected.`);
 
-  if (!analysedStructure) {
-    analysedStructure = await driver.analyseFull(pool);
-  }
+    if (!analysedStructure) {
+      analysedStructure = await driver.analyseFull(dbhan);
+    }
 
-  const dupl = new DataDuplicator(
-    pool,
-    driver,
-    analysedStructure,
-    items.map(item => ({
-      name: item.name,
-      operation: item.operation,
-      matchColumns: item.matchColumns,
-      openStream:
-        item.openStream ||
-        (() => jsonLinesReader({ fileName: path.join(resolveArchiveFolder(archive), `${item.name}.jsonl`) })),
-    })),
-    stream,
-    copyStream,
-    options
-  );
+    const dupl = new DataDuplicator(
+      dbhan,
+      driver,
+      analysedStructure,
+      items.map(item => ({
+        name: item.name,
+        operation: item.operation,
+        matchColumns: item.matchColumns,
+        openStream:
+          item.openStream ||
+          (() => jsonLinesReader({ fileName: path.join(resolveArchiveFolder(archive), `${item.name}.jsonl`) })),
+      })),
+      stream,
+      copyStream,
+      options
+    );
 
-  await dupl.run();
+    await dupl.run();
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
+  }
 }
 
 module.exports = dataDuplicator;

package/src/shell/dumpDatabase.js

@@ -27,15 +27,23 @@ async function dumpDatabase({
   logger.info(`Dumping database`);
 
   if (!driver) driver = requireEngineDriver(connection);
-  const pool = systemConnection || (await connectUtility(driver, connection, 'read', { forceRowsAsObjects: true }));
-  logger.info(`Connected.`);
 
-  const dumper = await driver.createBackupDumper(pool, {
-    outputFile,
-    databaseName,
-    schemaName,
-  });
-  await doDump(dumper);
+  const dbhan = systemConnection || (await connectUtility(driver, connection, 'read', { forceRowsAsObjects: true }));
+
+  try {
+    logger.info(`Connected.`);
+
+    const dumper = await driver.createBackupDumper(dbhan, {
+      outputFile,
+      databaseName,
+      schemaName,
+    });
+    await doDump(dumper);
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
+  }
 }
 
 module.exports = dumpDatabase;

package/src/shell/executeQuery.js

@@ -9,12 +9,15 @@ async function executeQuery({ connection = undefined, systemConnection = undefin
 
   if (!driver) driver = requireEngineDriver(connection);
   const dbhan = systemConnection || (await connectUtility(driver, connection, 'script'));
-  logger.info(`Connected.`);
 
-  await driver.script(dbhan, sql);
+  try {
+    logger.info(`Connected.`);
 
-  if (!systemConnection) {
-    await driver.close(dbhan);
+    await driver.script(dbhan, sql);
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
   }
 }
 

package/src/shell/generateDeploySql.js

@@ -22,44 +22,48 @@ async function generateDeploySql({
   if (!driver) driver = requireEngineDriver(connection);
 
   const dbhan = systemConnection || (await connectUtility(driver, connection, 'read'));
-  if (!analysedStructure) {
-    analysedStructure = await driver.analyseFull(dbhan);
-  }
 
-  const deployedModel = generateDbPairingId(
-    extendDatabaseInfo(loadedDbModel ? databaseInfoFromYamlModel(loadedDbModel) : await importDbModel(modelFolder))
-  );
-  const currentModel = generateDbPairingId(extendDatabaseInfo(analysedStructure));
-  const opts = {
-    ...modelCompareDbDiffOptions,
+  try {
+    if (!analysedStructure) {
+      analysedStructure = await driver.analyseFull(dbhan);
+    }
 
-    noDropTable: true,
-    noDropColumn: true,
-    noDropConstraint: true,
-    noDropSqlObject: true,
-    noRenameTable: true,
-    noRenameColumn: true,
-  };
-  const currentModelPaired = matchPairedObjects(deployedModel, currentModel, opts);
-  const currentModelPairedPreloaded = await enrichWithPreloadedRows(deployedModel, currentModelPaired, dbhan, driver);
+    const deployedModel = generateDbPairingId(
+      extendDatabaseInfo(loadedDbModel ? databaseInfoFromYamlModel(loadedDbModel) : await importDbModel(modelFolder))
+    );
+    const currentModel = generateDbPairingId(extendDatabaseInfo(analysedStructure));
+    const opts = {
+      ...modelCompareDbDiffOptions,
 
-  // console.log('currentModelPairedPreloaded', currentModelPairedPreloaded.tables[0]);
-  // console.log('deployedModel', deployedModel.tables[0]);
-  // console.log('currentModel', currentModel.tables[0]);
-  // console.log('currentModelPaired', currentModelPaired.tables[0]);
-  const res = getAlterDatabaseScript(
-    currentModelPairedPreloaded,
-    deployedModel,
-    opts,
-    currentModelPairedPreloaded,
-    deployedModel,
-    driver
-  );
+      noDropTable: true,
+      noDropColumn: true,
+      noDropConstraint: true,
+      noDropSqlObject: true,
+      noRenameTable: true,
+      noRenameColumn: true,
+    };
+    const currentModelPaired = matchPairedObjects(deployedModel, currentModel, opts);
+    const currentModelPairedPreloaded = await enrichWithPreloadedRows(deployedModel, currentModelPaired, dbhan, driver);
 
-  if (!systemConnection) {
-    await driver.close(dbhan);
+    // console.log('currentModelPairedPreloaded', currentModelPairedPreloaded.tables[0]);
+    // console.log('deployedModel', deployedModel.tables[0]);
+    // console.log('currentModel', currentModel.tables[0]);
+    // console.log('currentModelPaired', currentModelPaired.tables[0]);
+    const res = getAlterDatabaseScript(
+      currentModelPairedPreloaded,
+      deployedModel,
+      opts,
+      currentModelPairedPreloaded,
+      deployedModel,
+      driver
+    );
+    
+    return res;
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
   }
-  return res;
 }
 
 module.exports = generateDeploySql;

package/src/shell/importDatabase.js

@@ -59,21 +59,27 @@ async function importDatabase({ connection = undefined, systemConnection = undef
 
   if (!driver) driver = requireEngineDriver(connection);
   const dbhan = systemConnection || (await connectUtility(driver, connection, 'write'));
-  logger.info(`Connected.`);
+  try {
+    logger.info(`Connected.`);
 
-  logger.info(`Input file: ${inputFile}`);
-  const downloadedFile = await download(inputFile);
-  logger.info(`Downloaded file: ${downloadedFile}`);
+    logger.info(`Input file: ${inputFile}`);
+    const downloadedFile = await download(inputFile);
+    logger.info(`Downloaded file: ${downloadedFile}`);
 
-  const fileStream = fs.createReadStream(downloadedFile, 'utf-8');
-  const splittedStream = splitQueryStream(fileStream, {
-    ...driver.getQuerySplitterOptions('import'),
-    returnRichInfo: true,
-  });
-  const importStream = new ImportStream(dbhan, driver);
-  // @ts-ignore
-  splittedStream.pipe(importStream);
-  await awaitStreamEnd(importStream);
+    const fileStream = fs.createReadStream(downloadedFile, 'utf-8');
+    const splittedStream = splitQueryStream(fileStream, {
+      ...driver.getQuerySplitterOptions('import'),
+      returnRichInfo: true,
+    });
+    const importStream = new ImportStream(dbhan, driver);
+    // @ts-ignore
+    splittedStream.pipe(importStream);
+    await awaitStreamEnd(importStream);
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
+  }
 }
 
 module.exports = importDatabase;

package/src/shell/loadDatabase.js

@@ -9,13 +9,19 @@ async function loadDatabase({ connection = undefined, systemConnection = undefin
   logger.info(`Analysing database`);
 
   if (!driver) driver = requireEngineDriver(connection);
-  const pool = systemConnection || (await connectUtility(driver, connection, 'read', { forceRowsAsObjects: true }));
-  logger.info(`Connected.`);
+  const dbhan = systemConnection || (await connectUtility(driver, connection, 'read', { forceRowsAsObjects: true }));
+  try {
+    logger.info(`Connected.`);
 
-  const dbInfo = await driver.analyseFull(pool);
-  logger.info(`Analyse finished`);
+    const dbInfo = await driver.analyseFull(dbhan);
+    logger.info(`Analyse finished`);
 
-  await exportDbModel(dbInfo, outputDir);
+    await exportDbModel(dbInfo, outputDir);
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
+  }
 }
 
 module.exports = loadDatabase;

package/src/shell/runScript.js

@@ -1,4 +1,4 @@
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const childProcessChecker = require('../utility/childProcessChecker');
 const processArgs = require('../utility/processArgs');
 const logger = getLogger();
@@ -11,7 +11,7 @@ async function runScript(func) {
     await func();
     process.exit(0);
   } catch (err) {
-    logger.error({ err }, `Error running script: ${err.message || err}`);
+    logger.error(extractErrorLogData(err), `Error running script`);
     process.exit(1);
   }
 }

package/src/shell/tableReader.js

@@ -3,9 +3,9 @@ const requireEngineDriver = require('../utility/requireEngineDriver');
 const connectUtility = require('../utility/connectUtility');
 const logger = getLogger('tableReader');
 
-async function tableReader({ connection, pureName, schemaName }) {
+async function tableReader({ connection, systemConnection, pureName, schemaName }) {
   const driver = requireEngineDriver(connection);
-  const pool = await connectUtility(driver, connection, 'read');
+  const dbhan = systemConnection || (await connectUtility(driver, connection, 'read'));
   logger.info(`Connected.`);
 
   const fullName = { pureName, schemaName };
@@ -14,26 +14,26 @@ async function tableReader({ connection, pureName, schemaName }) {
     // @ts-ignore
     logger.info(`Reading collection ${fullNameToString(fullName)}`);
     // @ts-ignore
-    return await driver.readQuery(pool, JSON.stringify(fullName));
+    return await driver.readQuery(dbhan, JSON.stringify(fullName));
   }
 
-  const table = await driver.analyseSingleObject(pool, fullName, 'tables');
+  const table = await driver.analyseSingleObject(dbhan, fullName, 'tables');
   const query = `select * from ${quoteFullName(driver.dialect, fullName)}`;
   if (table) {
     // @ts-ignore
     logger.info(`Reading table ${fullNameToString(table)}`);
     // @ts-ignore
-    return await driver.readQuery(pool, query, table);
+    return await driver.readQuery(dbhan, query, table);
   }
-  const view = await driver.analyseSingleObject(pool, fullName, 'views');
+  const view = await driver.analyseSingleObject(dbhan, fullName, 'views');
   if (view) {
     // @ts-ignore
     logger.info(`Reading view ${fullNameToString(view)}`);
     // @ts-ignore
-    return await driver.readQuery(pool, query, view);
+    return await driver.readQuery(dbhan, query, view);
   }
 
-  return await driver.readQuery(pool, query);
+  return await driver.readQuery(dbhan, query);
 }
 
 module.exports = tableReader;

package/src/shell/tableWriter.js

@@ -9,10 +9,16 @@ async function tableWriter({ connection, schemaName, pureName, driver, systemCon
   if (!driver) {
     driver = requireEngineDriver(connection);
   }
-  const pool = systemConnection || (await connectUtility(driver, connection, 'write'));
+  const dbhan = systemConnection || (await connectUtility(driver, connection, 'write'));
 
-  logger.info(`Connected.`);
-  return await driver.writeTable(pool, { schemaName, pureName }, options);
+  try {
+    logger.info(`Connected.`);
+    return await driver.writeTable(dbhan, { schemaName, pureName }, options);
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
+  }
 }
 
 module.exports = tableWriter;

package/src/utility/DatastoreProxy.js

@@ -3,7 +3,7 @@ const { fork } = require('child_process');
 const { handleProcessCommunication } = require('./processComm');
 const processArgs = require('../utility/processArgs');
 const pipeForkLogs = require('./pipeForkLogs');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const logger = getLogger('DatastoreProxy');
 
 class DatastoreProxy {
@@ -73,7 +73,7 @@ class DatastoreProxy {
       try {
         this.subprocess.send({ msgtype: 'read', msgid, offset, limit });
       } catch (err) {
-        logger.error({ err }, 'Error getting rows');
+        logger.error(extractErrorLogData(err), 'Error getting rows');
         this.subprocess = null;
       }
     });
@@ -87,7 +87,7 @@ class DatastoreProxy {
       try {
         this.subprocess.send({ msgtype: 'notify', msgid });
       } catch (err) {
-        logger.error({ err }, 'Error notifying subprocess');
+        logger.error(extractErrorLogData(err), 'Error notifying subprocess');
         this.subprocess = null;
       }
     });

package/src/utility/childProcessChecker.js

@@ -1,4 +1,4 @@
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 
 const logger = getLogger('childProcessChecked');
 
@@ -12,7 +12,7 @@ function childProcessChecker() {
       // This will come once parent dies.
       // One way can be to check for error code ERR_IPC_CHANNEL_CLOSED
       //     and call process.exit()
-      logger.error({ err }, 'parent died');
+      logger.error(extractErrorLogData(err), 'parent died');
       process.exit(1);
     }
   }, 1000);

package/src/utility/connectUtility.js

@@ -3,9 +3,10 @@ const { decryptConnection } = require('./crypting');
 const { getSshTunnelProxy } = require('./sshTunnelProxy');
 const platformInfo = require('../utility/platformInfo');
 const connections = require('../controllers/connections');
+const _ = require('lodash');
 
 async function loadConnection(driver, storedConnection, connectionMode) {
-  const { allowShellConnection } = platformInfo;
+  const { allowShellConnection, allowConnectionFromEnvVariables } = platformInfo;
 
   if (connectionMode == 'app') {
     return storedConnection;
@@ -33,6 +34,16 @@ async function loadConnection(driver, storedConnection, connectionMode) {
     }
     return loadedWithDb;
   }
+
+  if (allowConnectionFromEnvVariables) {
+    return _.mapValues(storedConnection, (value, key) => {
+      if (_.isString(value) && value.startsWith('${') && value.endsWith('}')) {
+        return process.env[value.slice(2, -1)];
+      }
+      return value;
+    });
+  }
+
   return storedConnection;
 }
 

package/src/utility/platformInfo.js

@@ -44,6 +44,7 @@ const platformInfo = {
     (!processArgs.listenApiChild && !isNpmDist) || !!process.env.SHELL_CONNECTION || !!isElectron() || !!isDbModel,
   allowShellScripting:
     (!processArgs.listenApiChild && !isNpmDist) || !!process.env.SHELL_SCRIPTING || !!isElectron() || !!isDbModel,
+  allowConnectionFromEnvVariables: !!isDbModel,
   defaultKeyfile: path.join(os.homedir(), '.ssh/id_rsa'),
 };
 

package/src/utility/sshTunnel.js

@@ -5,7 +5,7 @@ const AsyncLock = require('async-lock');
 const lock = new AsyncLock();
 const { fork } = require('child_process');
 const processArgs = require('../utility/processArgs');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const pipeForkLogs = require('./pipeForkLogs');
 const logger = getLogger('sshTunnel');
 
@@ -40,7 +40,7 @@ function callForwardProcess(connection, tunnelConfig, tunnelCacheKey) {
       tunnelConfig,
     });
   } catch (err) {
-    logger.error({ err }, 'Error connecting SSH');
+    logger.error(extractErrorLogData(err), 'Error connecting SSH');
   }
   return new Promise((resolve, reject) => {
     subprocess.on('message', resp => {

package/src/utility/sshTunnelProxy.js

@@ -1,5 +1,5 @@
 const crypto = require('crypto');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const { getSshTunnel } = require('./sshTunnel');
 const logger = getLogger('sshTunnelProxy');
 
@@ -10,7 +10,7 @@ async function handleGetSshTunnelRequest({ msgid, connection }, subprocess) {
   try {
     subprocess.send({ msgtype: 'getsshtunnel-response', msgid, response });
   } catch (err) {
-    logger.error({ err }, 'Error sending to SSH tunnel');
+    logger.error(extractErrorLogData(err), 'Error sending to SSH tunnel');
   }
 }
 

package/src/utility/useController.js

@@ -2,7 +2,7 @@ const _ = require('lodash');
 const express = require('express');
 const getExpressPath = require('./getExpressPath');
 const { MissingCredentialsError } = require('./exceptions');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 
 const logger = getLogger('useController');
 /**
@@ -16,7 +16,7 @@ module.exports = function useController(app, electron, route, controller) {
     try {
       controller._init();
     } catch (err) {
-      logger.error({ err }, `Error initializing controller, exiting application`);
+      logger.error(extractErrorLogData(err), `Error initializing controller, exiting application`);
       process.exit(1);
     }
   }
@@ -78,7 +78,7 @@ module.exports = function useController(app, electron, route, controller) {
           const data = await controller[key]({ ...req.body, ...req.query }, req);
           res.json(data);
         } catch (err) {
-          logger.error({ err }, `Error when processing route ${route}/${key}`);
+          logger.error(extractErrorLogData(err), `Error when processing route ${route}/${key}`);
           if (err instanceof MissingCredentialsError) {
             res.json({
               missingCredentials: true,