dbgate-api-premium 7.1.3-alpha.3 → 7.1.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api-premium",
   "main": "src/index.js",
-  "version": "7.1.3-alpha.3",
+  "version": "7.1.3",
   "homepage": "https://www.dbgate.io/",
   "repository": {
     "type": "git",
@@ -30,11 +30,11 @@
     "compare-versions": "^3.6.0",
     "cors": "^2.8.5",
     "cross-env": "^6.0.3",
-    "dbgate-datalib": "7.1.3-alpha.3",
+    "dbgate-datalib": "7.1.3",
     "dbgate-query-splitter": "^4.12.0",
-    "dbgate-rest": "7.1.3-alpha.3",
-    "dbgate-sqltree": "7.1.3-alpha.3",
-    "dbgate-tools": "7.1.3-alpha.3",
+    "dbgate-rest": "7.1.3",
+    "dbgate-sqltree": "7.1.3",
+    "dbgate-tools": "7.1.3",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -88,7 +88,7 @@
   "devDependencies": {
     "@types/fs-extra": "^9.0.11",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "7.1.3-alpha.3",
+    "dbgate-types": "7.1.3",
     "env-cmd": "^10.1.0",
     "jsdoc-to-markdown": "^9.0.5",
     "node-loader": "^1.0.2",

package/src/auth/storageAuthProvider.js

@@ -34,7 +34,16 @@ async function loadPermissionsForUserId(userId) {
   const rolePermissions = sortPermissionsFromTheSameLevel(await storageReadUserRolePermissions(userId));
   const userPermissions = await storageReadUserPermissions(userId);
   const loggedUserPermissions = await storageReadRolePermissions(-2);
-  return [...getPredefinedPermissions('logged-user'), ...loggedUserPermissions, ...rolePermissions, ...userPermissions];
+  const resp = [
+    ...getPredefinedPermissions('logged-user'),
+    ...loggedUserPermissions,
+    ...rolePermissions,
+    ...userPermissions,
+  ];
+  if (resp.some(p => p?.startsWith('admin/'))) {
+    resp.push('widgets/admin');
+  }
+  return resp;
 }
 
 function getBuiltinRoleIdFromRequest(req) {
@@ -390,10 +399,11 @@ class OauthProvider extends StorageProviderBase {
     const scopeParam = this.config.oauthScope ? `&scope=${this.config.oauthScope}` : '';
     return {
       status: 'ok',
-      uri: `${this.config.oauthAuth}?client_id=${this.config.oauthClient
-        }&response_type=code&redirect_uri=${encodeURIComponent(redirectUri)}&state=${encodeURIComponent(
-          state
-        )}${scopeParam}`,
+      uri: `${this.config.oauthAuth}?client_id=${
+        this.config.oauthClient
+      }&response_type=code&redirect_uri=${encodeURIComponent(redirectUri)}&state=${encodeURIComponent(
+        state
+      )}${scopeParam}`,
     };
   }
 
@@ -714,5 +724,5 @@ function createStorageAuthProvider(config) {
 module.exports = {
   createStorageAuthProvider,
   SuperadminAuthProvider,
-  getBuiltinRoleIdFromRequest
+  getBuiltinRoleIdFromRequest,
 };

package/src/controllers/databaseConnections.js

@@ -95,10 +95,12 @@ module.exports = {
     }
   },
   handle_response(conid, database, { msgid, ...response }) {
-    const [resolve, reject, additionalData] = this.requests[msgid];
-    resolve(response);
-    if (additionalData?.auditLogger) {
-      additionalData?.auditLogger(response);
+    const [resolve, reject, additionalData] = this.requests[msgid] || [];
+    if (resolve) {
+      resolve(response);
+      if (additionalData?.auditLogger) {
+        additionalData?.auditLogger(response);
+      }
     }
     delete this.requests[msgid];
   },
@@ -239,7 +241,7 @@ module.exports = {
   sendRequest(conn, message, additionalData = {}) {
     const msgid = crypto.randomUUID();
     const promise = new Promise((resolve, reject) => {
-      this.requests[msgid] = [resolve, reject, additionalData];
+      this.requests[msgid] = [resolve, reject, additionalData, conn.conid, conn.database];
       try {
         const serializedMessage = serializeJsTypesForJsonStringify({ msgid, ...message });
         conn.subprocess.send(serializedMessage);
@@ -264,12 +266,12 @@ module.exports = {
   },
 
   sqlSelect_meta: true,
-  async sqlSelect({ conid, database, select, auditLogSessionGroup }, req) {
+  async sqlSelect({ conid, database, select, commandTimeout, auditLogSessionGroup }, req) {
     await testConnectionPermission(conid, req);
     const opened = await this.ensureOpened(conid, database);
     const res = await this.sendRequest(
       opened,
-      { msgtype: 'sqlSelect', select },
+      { msgtype: 'sqlSelect', select, commandTimeout },
       {
         auditLogger:
           auditLogSessionGroup && select?.from?.name?.pureName
@@ -344,9 +346,12 @@ module.exports = {
   },
 
   collectionData_meta: true,
-  async collectionData({ conid, database, options, auditLogSessionGroup }, req) {
+  async collectionData({ conid, database, options, commandTimeout, auditLogSessionGroup }, req) {
     await testConnectionPermission(conid, req);
     const opened = await this.ensureOpened(conid, database);
+    if (commandTimeout && options) {
+      options.commandTimeout = commandTimeout;
+    }
     const res = await this.sendRequest(
       opened,
       { msgtype: 'collectionData', options },
@@ -580,6 +585,24 @@ module.exports = {
     };
   },
 
+  pingDatabases_meta: true,
+  async pingDatabases({ databases }, req) {
+    if (!databases || !Array.isArray(databases)) return { status: 'ok' };
+    for (const { conid, database } of databases) {
+      if (!conid || !database) continue;
+      const existing = this.opened.find(x => x.conid == conid && x.database == database);
+      if (existing) {
+        try {
+          existing.subprocess.send({ msgtype: 'ping' });
+        } catch (err) {
+          logger.error(extractErrorLogData(err), 'DBGM-00308 Error pinging DB connection');
+          this.close(conid, database);
+        }
+      }
+    }
+    return { status: 'ok' };
+  },
+
   refresh_meta: true,
   async refresh({ conid, database, keepOpen }, req) {
     await testConnectionPermission(conid, req);
@@ -622,6 +645,15 @@ module.exports = {
         structure: existing.structure,
       };
       socket.emitChanged(`database-status-changed`, { conid, database });
+
+      // Reject all pending requests for this connection
+      for (const [msgid, entry] of Object.entries(this.requests)) {
+        const [resolve, reject, additionalData, reqConid, reqDatabase] = entry;
+        if (reqConid === conid && reqDatabase === database) {
+          reject('DBGM-00309 Database connection closed');
+          delete this.requests[msgid];
+        }
+      }
     }
   },
 

package/src/controllers/files.js

@@ -15,7 +15,8 @@ const getDiagramExport = require('../utility/getDiagramExport');
 const apps = require('./apps');
 const getMapExport = require('../utility/getMapExport');
 const dbgateApi = require('../shell');
-const { getLogger } = require('dbgate-tools');
+const { getLogger, getSqlFrontMatter } = require('dbgate-tools');
+const yaml = require('js-yaml');
 const platformInfo = require('../utility/platformInfo');
 const { checkSecureFilePathsWithoutDirectory, checkSecureDirectories } = require('../utility/security');
 const { copyAppLogsIntoFile, getRecentAppLogRecords } = require('../utility/appLogStore');
@@ -35,13 +36,46 @@ function deserialize(format, text) {
 
 module.exports = {
   list_meta: true,
-  async list({ folder }, req) {
+  async list({ folder, parseFrontMatter }, req) {
     const loadedPermissions = await loadPermissionsFromRequest(req);
     if (!hasPermission(`files/${folder}/read`, loadedPermissions)) return [];
     const dir = path.join(filesdir(), folder);
     if (!(await fs.exists(dir))) return [];
-    const files = (await fs.readdir(dir)).map(file => ({ folder, file }));
-    return files;
+    const fileNames = await fs.readdir(dir);
+    if (!parseFrontMatter) {
+      return fileNames.map(file => ({ folder, file }));
+    }
+    const result = [];
+    for (const file of fileNames) {
+      const item = { folder, file };
+      let fh;
+      try {
+        fh = await require('fs').promises.open(path.join(dir, file), 'r');
+        const buf = new Uint8Array(512);
+        const { bytesRead } = await fh.read(buf, 0, 512, 0);
+        let text = Buffer.from(buf.buffer, 0, bytesRead).toString('utf-8');
+
+        if (text.includes('-- >>>') && !text.includes('-- <<<')) {
+          const stat = await fh.stat();
+          const fullSize = Math.min(stat.size, 4096);
+          if (fullSize > 512) {
+            const fullBuf = new Uint8Array(fullSize);
+            const { bytesRead: fullBytesRead } = await fh.read(fullBuf, 0, fullSize, 0);
+            text = Buffer.from(fullBuf.buffer, 0, fullBytesRead).toString('utf-8');
+          }
+        }
+
+        const fm = getSqlFrontMatter(text, yaml);
+        if (fm?.connectionId) item.connectionId = fm.connectionId;
+        if (fm?.databaseName) item.databaseName = fm.databaseName;
+      } catch (e) {
+        // ignore read errors for individual files
+      } finally {
+        if (fh) await fh.close().catch(() => {});
+      }
+      result.push(item);
+    }
+    return result;
   },
 
   listAll_meta: true,

package/src/controllers/sessions.js

@@ -228,6 +228,19 @@ module.exports = {
     return { state: 'ok' };
   },
 
+  setIsolationLevel_meta: true,
+  async setIsolationLevel({ sesid, level }) {
+    const session = this.opened.find(x => x.sesid == sesid);
+    if (!session) {
+      throw new Error('Invalid session');
+    }
+
+    logger.info({ sesid, level }, 'DBGM-00315 Setting transaction isolation level');
+    session.subprocess.send({ msgtype: 'setIsolationLevel', level });
+
+    return { state: 'ok' };
+  },
+
   executeReader_meta: true,
   async executeReader({ conid, database, sql, queryName, appFolder }) {
     const { sesid } = await this.create({ conid, database });

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '7.1.3-alpha.3',
-  buildTime: '2026-03-09T09:23:09.614Z'
+  version: '7.1.3',
+  buildTime: '2026-03-18T14:33:55.882Z'
 };

package/src/proc/databaseConnectionProcess.js

@@ -234,12 +234,12 @@ async function handleRunOperation({ msgid, operation, useTransaction }, skipRead
   }
 }
 
-async function handleQueryData({ msgid, sql, range }, skipReadonlyCheck = false) {
+async function handleQueryData({ msgid, sql, range, commandTimeout }, skipReadonlyCheck = false) {
   await waitConnected();
   const driver = requireEngineDriver(storedConnection);
   try {
     if (!skipReadonlyCheck) ensureExecuteCustomScript(driver);
-    const res = await driver.query(dbhan, sql, { range });
+    const res = await driver.query(dbhan, sql, { range, commandTimeout });
     process.send({ msgtype: 'response', msgid, ...serializeJsTypesForJsonStringify(res) });
   } catch (err) {
     process.send({
@@ -250,11 +250,11 @@ async function handleQueryData({ msgid, sql, range }, skipReadonlyCheck = false)
   }
 }
 
-async function handleSqlSelect({ msgid, select }) {
+async function handleSqlSelect({ msgid, select, commandTimeout }) {
   const driver = requireEngineDriver(storedConnection);
   const dmp = driver.createDumper();
   dumpSqlSelect(dmp, select);
-  return handleQueryData({ msgid, sql: dmp.s, range: select.range }, true);
+  return handleQueryData({ msgid, sql: dmp.s, range: select.range, commandTimeout }, true);
 }
 
 async function handleDriverDataCore(msgid, callMethod, { logName }) {

package/src/proc/restConnectionProcess.js

@@ -11,6 +11,7 @@ const fs = require('fs');
 const { Readable, Transform } = require('stream');
 const { pipeline } = require('stream/promises');
 const getJslFileName = require('../utility/getJslFileName');
+const { decryptPasswordString } = require('../utility/crypting');
 const {
   analyseOpenApiDefinition,
   analyseODataDefinition,
@@ -23,8 +24,37 @@ const {
 
 const logger = getLogger('restconnProcess');
 
+function buildProxyConfig(proxyUrl, proxyUser, proxyPassword) {
+  const url = String(proxyUrl ?? '').trim();
+  const user = String(proxyUser ?? '').trim();
+  const pass = String(proxyPassword ?? '').trim();
+  if (!url && (user || pass)) {
+    throw new Error('DBGM-00327 Proxy user or password is set but proxy URL is missing');
+  }
+  if (!url) return undefined;
+  try {
+    const parsed = new URL(url.includes('://') ? url : `http://${url}`);
+    const config = {
+      protocol: parsed.protocol.replace(':', ''),
+      host: parsed.hostname,
+      port: parsed.port ? parseInt(parsed.port, 10) : (parsed.protocol === 'https:' ? 443 : 80),
+    };
+
+    const username = proxyUser ?? parsed.username;
+    const rawPassword = proxyPassword ?? parsed.password;
+    const password = decryptPasswordString(rawPassword);
+    if (username) {
+      config.auth = { username, password: password ?? '' };
+    }
+    return config;
+  } catch (err) {
+    throw new Error(`DBGM-00328 Invalid proxy URL "${url}": ${err && err.message ? err.message : err}`);
+  }
+}
+
 let restInfo = null;
 let storedConnection = null;
+let axiosInstance = axios.default;
 let lastSwaggerUrl = null;
 let lastApiInfo = null;
 let lastConnectError = null;
@@ -79,7 +109,7 @@ async function fetchOpenApiStructure() {
 
   let swaggerData = null;
   try {
-    const response = await axios.default.get(url, {
+    const response = await axiosInstance.get(url, {
       timeout: 10000,
       headers,
     });
@@ -101,7 +131,7 @@ async function fetchOpenApiStructure() {
 
 async function fetchODataStructure() {
   if (!storedConnection.apiServerUrl1) {
-    throw new Error('DBGM-00000 OData service URL is not configured');
+    throw new Error('DBGM-00316 OData service URL is not configured');
   }
 
   const url = storedConnection.apiServerUrl1;
@@ -112,25 +142,27 @@ async function fetchODataStructure() {
     'OData-Version': '4.0',
   };
 
+  const proxyConfig = buildProxyConfig(storedConnection?.httpProxyUrl, storedConnection?.httpProxyUser, storedConnection?.httpProxyPassword);
   let serviceDocument = null;
   try {
-    const response = await axios.default.get(url, {
+    const response = await axiosInstance.get(url, {
       timeout: 10000,
       headers: odataHeaders,
+      ...(proxyConfig && { proxy: proxyConfig }),
     });
     serviceDocument = parseStructuredContent(response.data);
   } catch (err) {
-    throw new Error(`DBGM-00000 Could not fetch OData service document: ${err.message}`);
+    throw new Error(`DBGM-00317 Could not fetch OData service document: ${err.message}`);
   }
 
   if (!serviceDocument || typeof serviceDocument !== 'object') {
-    throw new Error('DBGM-00000 OData service document is empty or invalid');
+    throw new Error('DBGM-00318 OData service document is empty or invalid');
   }
 
   const metadataUrl = resolveODataMetadataUrl(serviceDocument['@odata.context'], url);
   let metadataXml = '';
   try {
-    const response = await axios.default.get(metadataUrl, {
+    const response = await axiosInstance.get(metadataUrl, {
       timeout: 10000,
       headers: {
         ...authHeaders,
@@ -138,14 +170,15 @@ async function fetchODataStructure() {
         'OData-Version': '4.0',
       },
       transformResponse: value => value,
+      ...(proxyConfig && { proxy: proxyConfig }),
     });
     metadataXml = typeof response.data === 'string' ? response.data : String(response.data ?? '');
   } catch (err) {
-    throw new Error(`DBGM-00000 Could not fetch OData metadata document: ${err.message}`);
+    throw new Error(`DBGM-00319 Could not fetch OData metadata document: ${err.message}`);
   }
 
   if (!metadataXml.trim()) {
-    throw new Error('DBGM-00000 OData metadata document is empty');
+    throw new Error('DBGM-00320 OData metadata document is empty');
   }
 
   const apiInfo = analyseODataDefinition(serviceDocument, url, metadataXml);
@@ -184,7 +217,7 @@ async function fetchGraphQLSchemaViaIntrospection() {
       storedConnection.apiServerUrl1,
       // @ts-ignore
       buildRestAuthHeaders(storedConnection.restAuth),
-      axios.default
+      axiosInstance
     );
 
     return {
@@ -275,6 +308,9 @@ async function handleConnect(connection) {
   setStatusName('pending');
 
   try {
+    const proxyConfig = buildProxyConfig(connection?.httpProxyUrl, connection?.httpProxyUser, connection?.httpProxyPassword);
+    axiosInstance = proxyConfig ? axios.default.create({ proxy: proxyConfig }) : axios.default;
+
     const isGraphQL = connection.engine === 'graphql@rest';
     const structure = await loadStructureWithProgress('loadStructure', isGraphQL);
 
@@ -287,7 +323,7 @@ async function handleConnect(connection) {
     const apiType = isGraphQL ? 'GraphQL' : connection.engine === 'odata@rest' ? 'OData' : 'REST';
     logger.info(
       { url: storedConnection.apiServerUrl1 },
-      `DBGM-00000 Connected to ${apiType} API`
+      `DBGM-00321 Connected to ${apiType} API`
     );
     resolveAfterConnect();
   } catch (err) {
@@ -354,7 +390,7 @@ async function handleExecuteOpenapi({ msgid, endpoint, method, parameters, serve
       parameters,
       server,
       auth,
-      axios.default
+      axiosInstance
     );
 
     process.send({
@@ -389,7 +425,7 @@ async function handleExecuteOdata({ msgid, endpoint, method, parameters, server,
       parameters,
       server,
       auth,
-      axios.default
+      axiosInstance
     );
 
     process.send({
@@ -428,7 +464,7 @@ async function handleApiQuery({ msgid, server, query, variables, auth }) {
       ...buildRestAuthHeaders(auth),
     };
 
-    const response = await axios.default.post(url, { query, variables }, { headers });
+    const response = await axiosInstance.post(url, { query, variables }, { headers });
 
     process.send({
       msgtype: 'response',
@@ -520,7 +556,7 @@ ${selectionBlock}
 function extractGraphQlRows({ body, operationName, projection }) {
   if (body?.errors?.length) {
     const message = body.errors.map(item => item?.message).filter(Boolean).join('; ') || 'GraphQL query error';
-    throw new Error(`DBGM-00000 ${message}`);
+    throw new Error(`DBGM-00322 ${message}`);
   }
 
   const operationData = body?.data?.[operationName];
@@ -581,7 +617,7 @@ async function* streamGraphQlRows({ url, headers, operationName, projection, que
       filterValue,
     });
 
-    const response = await axios.default.post(url, { query }, { headers });
+    const response = await axiosInstance.post(url, { query }, { headers });
     const { rows, hasNextPage, endCursor } = extractGraphQlRows({
       body: response?.data,
       operationName,
@@ -640,13 +676,13 @@ async function handleLoadGraphqlConnectionData({
 
     const url = server || storedConnection?.apiServerUrl1;
     if (!url) {
-      throw new Error('DBGM-00000 GraphQL endpoint URL is not configured');
+      throw new Error('DBGM-00323 GraphQL endpoint URL is not configured');
     }
     if (!operationName) {
-      throw new Error('DBGM-00000 GraphQL operation name is missing');
+      throw new Error('DBGM-00324 GraphQL operation name is missing');
     }
     if (!projection?.kind) {
-      throw new Error('DBGM-00000 GraphQL projection is missing');
+      throw new Error('DBGM-00325 GraphQL projection is missing');
     }
 
     const rowsPageSize = pageSize || 100;
@@ -711,7 +747,7 @@ async function handleLoadGraphqlConnectionData({
       }
     }
 
-    logger.error(extractErrorLogData(err), 'DBGM-00000 Error loading GraphQL connection data to JSL');
+    logger.error(extractErrorLogData(err), 'DBGM-00326 Error loading GraphQL connection data to JSL');
     process.send({
       msgtype: 'response',
       msgid,

package/src/proc/sessionProcess.js

@@ -77,6 +77,38 @@ async function handleStopProfiler({ jslid }) {
   currentProfiler = null;
 }
 
+async function handleSetIsolationLevel({ level }) {
+  lastActivity = new Date().getTime();
+
+  await waitConnected();
+  const driver = requireEngineDriver(storedConnection);
+
+  if (!driver.setTransactionIsolationLevel) {
+    process.send({ msgtype: 'done', skipFinishedMessage: true });
+    return;
+  }
+
+  if (driver.isolationLevels && level && !driver.isolationLevels.includes(level)) {
+    process.send({
+      msgtype: 'info',
+      info: {
+        message: `Isolation level "${level}" is not supported by this driver. Supported levels: ${driver.isolationLevels.join(', ')}`,
+        severity: 'error',
+      },
+    });
+    process.send({ msgtype: 'done', skipFinishedMessage: true });
+    return;
+  }
+
+  executingScripts++;
+  try {
+    await driver.setTransactionIsolationLevel(dbhan, level);
+    process.send({ msgtype: 'done', controlCommand: 'setIsolationLevel' });
+  } finally {
+    executingScripts--;
+  }
+}
+
 async function handleExecuteControlCommand({ command }) {
   lastActivity = new Date().getTime();
 
@@ -210,6 +242,7 @@ const messageHandlers = {
   connect: handleConnect,
   executeQuery: handleExecuteQuery,
   executeControlCommand: handleExecuteControlCommand,
+  setIsolationLevel: handleSetIsolationLevel,
   executeReader: handleExecuteReader,
   startProfiler: handleStartProfiler,
   stopProfiler: handleStopProfiler,

package/src/storageModel.js

@@ -698,6 +698,30 @@ module.exports = {
           "columnName": "id_original",
           "dataType": "varchar(250)",
           "notNull": false
+        },
+        {
+          "pureName": "connections",
+          "columnName": "httpProxyUrl",
+          "dataType": "varchar(250)",
+          "notNull": false
+        },
+        {
+          "pureName": "connections",
+          "columnName": "httpProxyUser",
+          "dataType": "varchar(250)",
+          "notNull": false
+        },
+        {
+          "pureName": "connections",
+          "columnName": "httpProxyPassword",
+          "dataType": "varchar(250)",
+          "notNull": false
+        },
+        {
+          "pureName": "connections",
+          "columnName": "defaultIsolationLevel",
+          "dataType": "varchar(250)",
+          "notNull": false
         }
       ],
       "foreignKeys": [

package/src/utility/connectUtility.js

@@ -132,7 +132,35 @@ async function connectUtility(driver, storedConnection, connectionMode, addition
   }
 
   connection.ssl = await extractConnectionSslParams(connection);
-  connection.axios = axios.default;
+
+  const proxyUrl = String(connection.httpProxyUrl ?? '').trim();
+  const proxyUser = String(connection.httpProxyUser ?? '').trim();
+  const proxyPassword = String(connection.httpProxyPassword ?? '').trim();
+  if (!proxyUrl && (proxyUser || proxyPassword)) {
+    throw new Error('DBGM-00329 Proxy user or password is set but proxy URL is missing');
+  }
+  if (proxyUrl) {
+    let parsedProxy;
+    try {
+      const parsed = new URL(proxyUrl.includes('://') ? proxyUrl : `http://${proxyUrl}`);
+      parsedProxy = {
+        protocol: parsed.protocol.replace(':', ''),
+        host: parsed.hostname,
+        port: parsed.port ? parseInt(parsed.port, 10) : (parsed.protocol === 'https:' ? 443 : 80),
+      };
+      const username = connection.httpProxyUser ?? parsed.username;
+      const rawPassword = connection.httpProxyPassword ?? parsed.password;
+      const password = decryptPasswordString(rawPassword);
+      if (username) {
+        parsedProxy.auth = { username, password: password ?? '' };
+      }
+    } catch (err) {
+      throw new Error(`DBGM-00334 Invalid proxy URL "${proxyUrl}": ${err && err.message ? err.message : err}`);
+    }
+    connection.axios = axios.default.create({ proxy: parsedProxy });
+  } else {
+    connection.axios = axios.default;
+  }
 
   const conn = await driver.connect({ conid: connectionLoaded?._id, ...connection, ...additionalOptions });
   return conn;

package/src/utility/crypting.js

@@ -101,7 +101,7 @@ function decryptObjectPasswordField(obj, field, encryptor = null) {
   return obj;
 }
 
-const fieldsToEncrypt = ['password', 'sshPassword', 'sshKeyfilePassword', 'connectionDefinition'];
+const fieldsToEncrypt = ['password', 'sshPassword', 'sshKeyfilePassword', 'connectionDefinition', 'httpProxyPassword'];
 const additionalFieldsToMask = [
   'databaseUrl',
   'server',