dbgate-api-premium 6.1.6 → 6.2.1

package/src/shell/dropAllDbObjects.js

@@ -1,6 +1,6 @@
 const executeQuery = require('./executeQuery');
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 const { getLogger, extendDatabaseInfo } = require('dbgate-tools');
 
 const logger = getLogger('dropAllDbObjects');

package/src/shell/dumpDatabase.js

@@ -1,5 +1,5 @@
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 const { getLogger } = require('dbgate-tools');
 
 const logger = getLogger('dumpDb');

package/src/shell/executeQuery.js

@@ -1,6 +1,6 @@
 const fs = require('fs-extra');
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 const { getLogger, getLimitedQuery } = require('dbgate-tools');
 
 const logger = getLogger('execQuery');

package/src/shell/generateDeploySql.js

@@ -13,7 +13,7 @@ const {
 } = require('dbgate-tools');
 const importDbModel = require('../utility/importDbModel');
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 
 /**
  * Generates query for deploying model into database

package/src/shell/importDatabase.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 const { splitQueryStream } = require('dbgate-query-splitter/lib/splitQueryStream');
 const download = require('./download');
 const stream = require('stream');

package/src/shell/importDbFromFolder.js

@@ -0,0 +1,110 @@
+const path = require('path');
+const fs = require('fs-extra');
+const executeQuery = require('./executeQuery');
+const { connectUtility } = require('../utility/connectUtility');
+const requireEngineDriver = require('../utility/requireEngineDriver');
+const { getAlterDatabaseScript, DatabaseAnalyser, runCommandOnDriver } = require('dbgate-tools');
+const importDbModel = require('../utility/importDbModel');
+const jsonLinesReader = require('./jsonLinesReader');
+const tableWriter = require('./tableWriter');
+const copyStream = require('./copyStream');
+
+/**
+ * Deploys database model stored in modelFolder (table as yamls) to database
+ * @param {object} options
+ * @param {connectionType} options.connection - connection object
+ * @param {object} options.systemConnection - system connection (result of driver.connect). If not provided, new connection will be created
+ * @param {object} options.driver - driver object. If not provided, it will be loaded from connection
+ * @param {string} options.folder - folder with model files (YAML files for tables, SQL files for views, procedures, ...)
+ * @param {function[]} options.modelTransforms - array of functions for transforming model
+ */
+async function importDbFromFolder({ connection, systemConnection, driver, folder, modelTransforms }) {
+  if (!driver) driver = requireEngineDriver(connection);
+  const dbhan = systemConnection || (await connectUtility(driver, connection, 'read'));
+
+  try {
+    const model = await importDbModel(folder);
+
+    let modelAdapted = {
+      ...model,
+      tables: model.tables.map(table => driver.adaptTableInfo(table)),
+    };
+    for (const transform of modelTransforms || []) {
+      modelAdapted = transform(modelAdapted);
+    }
+
+    const modelNoFk = {
+      ...modelAdapted,
+      tables: modelAdapted.tables.map(table => ({
+        ...table,
+        foreignKeys: [],
+      })),
+    };
+
+    // const plan = createAlterDatabasePlan(
+    //   DatabaseAnalyser.createEmptyStructure(),
+    //   driver.dialect.enableAllForeignKeys ? modelAdapted : modelNoFk,
+    //   {},
+    //   DatabaseAnalyser.createEmptyStructure(),
+    //   driver.dialect.enableAllForeignKeys ? modelAdapted : modelNoFk,
+    //   driver
+    // );
+    // const dmp1 = driver.createDumper({ useHardSeparator: true });
+    // if (driver.dialect.enableAllForeignKeys) {
+    //   dmp1.enableAllForeignKeys(false);
+    // }
+    // plan.run(dmp1);
+    // if (driver.dialect.enableAllForeignKeys) {
+    //   dmp1.enableAllForeignKeys(true);
+    // }
+
+    const { sql } = getAlterDatabaseScript(
+      DatabaseAnalyser.createEmptyStructure(),
+      driver.dialect.enableAllForeignKeys ? modelAdapted : modelNoFk,
+      {},
+      DatabaseAnalyser.createEmptyStructure(),
+      driver.dialect.enableAllForeignKeys ? modelAdapted : modelNoFk,
+      driver
+    );
+    // console.log('CREATING STRUCTURE:', sql);
+    await executeQuery({ connection, systemConnection: dbhan, driver, sql, logScriptItems: true });
+
+    if (driver.dialect.enableAllForeignKeys) {
+      await runCommandOnDriver(dbhan, driver, dmp => dmp.enableAllForeignKeys(false));
+    }
+
+    for (const table of modelAdapted.tables) {
+      const fileName = path.join(folder, `${table.pureName}.jsonl`);
+      if (await fs.exists(fileName)) {
+        const src = await jsonLinesReader({ fileName });
+        const dst = await tableWriter({
+          systemConnection: dbhan,
+          pureName: table.pureName,
+          driver,
+          targetTableStructure: table,
+        });
+        await copyStream(src, dst);
+      }
+    }
+
+    if (driver.dialect.enableAllForeignKeys) {
+      await runCommandOnDriver(dbhan, driver, dmp => dmp.enableAllForeignKeys(true));
+    } else if (driver.dialect.createForeignKey) {
+      const dmp = driver.createDumper();
+      for (const table of modelAdapted.tables) {
+        for (const fk of table.foreignKeys) {
+          dmp.createForeignKey(fk);
+        }
+      }
+
+      // create foreign keys
+      await executeQuery({ connection, systemConnection: dbhan, driver, sql: dmp.s, logScriptItems: true });
+    }
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
+  }
+}
+
+module.exports = importDbFromFolder;

package/src/shell/index.js

@@ -35,6 +35,7 @@ const sqlTextReplacementTransform = require('./sqlTextReplacementTransform');
 const autoIndexForeignKeysTransform = require('./autoIndexForeignKeysTransform');
 const generateDeploySql = require('./generateDeploySql');
 const dropAllDbObjects = require('./dropAllDbObjects');
+const importDbFromFolder = require('./importDbFromFolder');
 
 const dbgateApi = {
   queryReader,
@@ -73,6 +74,7 @@ const dbgateApi = {
   autoIndexForeignKeysTransform,
   generateDeploySql,
   dropAllDbObjects,
+  importDbFromFolder,
 };
 
 requirePlugin.initializeDbgateApi(dbgateApi);

package/src/shell/loadDatabase.js

@@ -1,5 +1,5 @@
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 const { getLogger } = require('dbgate-tools');
 const exportDbModel = require('../utility/exportDbModel');
 

package/src/shell/queryReader.js

@@ -1,5 +1,5 @@
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 const { getLogger } = require('dbgate-tools');
 const logger = getLogger('queryReader');
 

package/src/shell/tableReader.js

@@ -1,6 +1,6 @@
 const { quoteFullName, fullNameToString, getLogger } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 const logger = getLogger('tableReader');
 
 /**

package/src/shell/tableWriter.js

@@ -1,6 +1,6 @@
 const { fullNameToString, getLogger } = require('dbgate-tools');
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const connectUtility = require('../utility/connectUtility');
+const { connectUtility } = require('../utility/connectUtility');
 const logger = getLogger('tableWriter');
 
 /**
@@ -15,6 +15,7 @@ const logger = getLogger('tableWriter');
  * @param {boolean} options.truncate - truncate table before insert
  * @param {boolean} options.createIfNotExists - create table if not exists
  * @param {boolean} options.commitAfterInsert - commit transaction after insert
+ * @param {any} options.targetTableStructure - target table structure (don't analyse if given)
  * @returns {Promise<writerType>} - writer object
  */
 async function tableWriter({ connection, schemaName, pureName, driver, systemConnection, ...options }) {

package/src/utility/authProxy.js

@@ -2,11 +2,24 @@ const axios = require('axios');
 const { Signer } = require('@aws-sdk/rds-signer');
 const jwt = require('jsonwebtoken');
 const { getLogger, extractErrorLogData } = require('dbgate-tools');
+const stableStringify = require('json-stable-stringify');
+const crypto = require('crypto');
+const _ = require('lodash');
+const processArgs = require('./processArgs');
 
 const logger = getLogger('authProxy');
 
-const AUTH_PROXY_URL = process.env.DEVWEB || process.env.DEVMODE ? 'https://auth-proxy.dbgate.udolni.net' : 'https://auth.dbgate.eu';
-// const AUTH_PROXY_URL = 'https://auth-proxy.dbgate.udolni.net';
+const AUTH_PROXY_URL = process.env.LOCAL_AUTH_PROXY
+  ? 'http://localhost:3109'
+  : process.env.DEVWEB || process.env.DEVMODE
+  ? 'https://auth-proxy.dbgate.udolni.net'
+  : 'https://auth.dbgate.eu';
+
+const AI_GATEWAY_URL = process.env.LOCAL_AI_GATEWAY
+  ? 'http://localhost:3110'
+  : process.env.DEVWEB || process.env.DEVMODE
+  ? 'https://aigw.dbgate.udolni.net'
+  : 'https://aigw.dbgate.io';
 
 let licenseKey = null;
 
@@ -18,6 +31,16 @@ function isAuthProxySupported() {
   return true;
 }
 
+function getAxiosParamsWithLicense() {
+  return {
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${licenseKey ?? process.env.DBGATE_LICENSE}`,
+      'x-api-key': processArgs.runE2eTests ? 'bcf6e1a0-5763-4060-9391-18fda005722d' : null,
+    },
+  };
+}
+
 async function authProxyGetRedirectUrl({ client, type, state, redirectUri }) {
   const respSession = await axios.default.post(
     `${AUTH_PROXY_URL}/create-session`,
@@ -25,12 +48,7 @@ async function authProxyGetRedirectUrl({ client, type, state, redirectUri }) {
       client,
       type,
     },
-    {
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${licenseKey ?? process.env.DBGATE_LICENSE}`,
-      },
-    }
+    getAxiosParamsWithLicense()
   );
 
   const { sid } = respSession.data;
@@ -55,12 +73,7 @@ async function authProxyGetTokenFromCode({ sid, code }) {
         sid,
         code,
       },
-      {
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${licenseKey ?? process.env.DBGATE_LICENSE}`,
-        },
-      }
+      getAxiosParamsWithLicense()
     );
     return respToken.data.token;
   } catch (err) {
@@ -82,12 +95,7 @@ function startTokenChecking(sid, callback) {
         {
           sid,
         },
-        {
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${licenseKey ?? process.env.DBGATE_LICENSE}`,
-          },
-        }
+        getAxiosParamsWithLicense()
       );
 
       if (resp.data.status == 'ok') {
@@ -156,6 +164,110 @@ async function obtainRefreshedLicense() {
   }
 }
 
+/**
+ * @param {import('dbgate-types').DatabaseInfo} structure
+ * @returns {import('dbgate-types').DatabaseInfoTiny}
+ */
+
+function extractTinyStructure(structure) {
+  return {
+    t: _.sortBy(structure.tables, x => x.pureName).map(table => ({
+      n: table.pureName,
+      o: table.objectComment,
+      c: table.columns.map(column => ({ n: column.columnName, t: column.dataType })),
+      p: table.primaryKey
+        ? {
+            c: table.primaryKey?.columns?.map(column => ({ n: column.columnName })),
+          }
+        : undefined,
+      f: _.sortBy(table.foreignKeys, x => x.constraintName).map(fk => ({
+        r: fk.refTableName,
+        c: fk.columns.map(column => ({ n: column.columnName, r: column.refColumnName })),
+      })),
+    })),
+  };
+}
+
+function getSha256Hash(data) {
+  return crypto
+    .createHash('sha256') // volba hashovací funkce
+    .update(data, 'utf8') // aktualizace hashe o data (ve formátu UTF-8)
+    .digest('hex'); // získáme výsledek v hexadecimální reprezentaci
+}
+
+async function findModelOnProxy(hash) {
+  const resp = await axios.default.post(
+    `${AI_GATEWAY_URL}/find-db-model`,
+    {
+      hash,
+    },
+    getAxiosParamsWithLicense()
+  );
+  return resp.data.status == 'ok';
+}
+
+async function callTextToSqlApi(text, structure, dialect) {
+  const tinyStructure = extractTinyStructure(structure);
+  const json = stableStringify(tinyStructure);
+  const modelHash = getSha256Hash(json);
+  const isModelOnProxy = await findModelOnProxy(modelHash);
+
+  const resp = await axios.default.post(
+    `${AI_GATEWAY_URL}/text-to-sql`,
+    {
+      text,
+      modelHash,
+      model: isModelOnProxy ? null : tinyStructure,
+      dialect,
+    },
+    getAxiosParamsWithLicense()
+  );
+
+  return resp.data;
+}
+
+async function callCompleteOnCursorApi(text, structure, dialect, line) {
+  const tinyStructure = extractTinyStructure(structure);
+  const json = stableStringify(tinyStructure);
+  const modelHash = getSha256Hash(json);
+  const isModelOnProxy = await findModelOnProxy(modelHash);
+
+  const resp = await axios.default.post(
+    `${AI_GATEWAY_URL}/complete-on-cursor`,
+    {
+      text,
+      modelHash,
+      model: isModelOnProxy ? null : tinyStructure,
+      dialect,
+      line,
+    },
+    getAxiosParamsWithLicense()
+  );
+
+  return resp.data;
+}
+
+async function callRefactorSqlQueryApi(query, task, structure, dialect) {
+  const tinyStructure = extractTinyStructure(structure);
+  const json = stableStringify(tinyStructure);
+  const modelHash = getSha256Hash(json);
+  const isModelOnProxy = await findModelOnProxy(modelHash);
+
+  const resp = await axios.default.post(
+    `${AI_GATEWAY_URL}/refactor-sql-query`,
+    {
+      query,
+      task,
+      modelHash,
+      model: isModelOnProxy ? null : tinyStructure,
+      dialect,
+    },
+    getAxiosParamsWithLicense()
+  );
+
+  return resp.data;
+}
+
 module.exports = {
   isAuthProxySupported,
   authProxyGetRedirectUrl,
@@ -166,4 +278,7 @@ module.exports = {
   supportsAwsIam,
   getAwsIamToken,
   obtainRefreshedLicense,
+  callTextToSqlApi,
+  callCompleteOnCursorApi,
+  callRefactorSqlQueryApi,
 };

package/src/utility/checkLicense.js

@@ -9,6 +9,7 @@ const { setAuthProxyLicense } = require('./authProxy');
 const axios = require('axios');
 const crypto = require('crypto');
 const platformInfo = require('./platformInfo');
+const processArgs = require('./processArgs');
 
 const logger = getLogger('checkLicense');
 
@@ -107,6 +108,13 @@ async function getAwsMetadata() {
 }
 
 function checkLicenseKey(licenseKey) {
+  if (processArgs.runE2eTests) {
+    return {
+      status: 'ok',
+      type: 'premium',
+    };
+  }
+
   try {
     const decoded = jwt.verify(licenseKey, publicKey, {
       algorithms: ['RS256'],
@@ -157,11 +165,11 @@ function checkLicenseKey(licenseKey) {
   }
 }
 
-let awsTokenLoaded = false;
-let awsTokenHash = null;
-function getAwsToken() {
-  if (awsTokenLoaded) {
-    return awsTokenHash;
+let cloudTokenLoaded = false;
+let cloudTokenHash = null;
+function getCloudToken() {
+  if (cloudTokenLoaded) {
+    return cloudTokenHash;
   }
   try {
     const token = fs
@@ -169,18 +177,25 @@ function getAwsToken() {
         encoding: 'utf-8',
       })
       .trim();
-    awsTokenHash = crypto.createHash('md5').update(token).digest('hex');
+    cloudTokenHash = crypto.createHash('md5').update(token).digest('hex');
   } catch (err) {}
-  awsTokenLoaded = true;
-  return awsTokenHash;
+  cloudTokenLoaded = true;
+  return cloudTokenHash;
 }
 
 async function checkLicense() {
+  if (processArgs.runE2eTests) {
+    return {
+      status: 'ok',
+      type: 'premium',
+    };
+  }
+
   if (process.env.DBGATE_LICENSE) {
     return checkLicenseKey(process.env.DBGATE_LICENSE);
   }
 
-  if (platformInfo.isAwsUbuntuLayout && getAwsToken() == 'b93c7491890460063003a02de06ec84a') {
+  if (platformInfo.isAwsUbuntuLayout && getCloudToken() == 'b93c7491890460063003a02de06ec84a') {
     const metadata = await getAwsMetadata();
     if (metadata?.amiId) {
       return {
@@ -190,6 +205,13 @@ async function checkLicense() {
     }
   }
 
+  if (platformInfo.isAzureUbuntuLayout && getCloudToken() == 'b93c7491890460063003a02de06ec84a') {
+    return {
+      status: 'ok',
+      type: 'premium',
+    };
+  }
+
   if (process.env.STORAGE_DATABASE) {
     const licenseConfig = await storageReadConfig('license');
     const key = licenseConfig?.licenseKey;

package/src/utility/connectUtility.js

@@ -47,50 +47,32 @@ async function loadConnection(driver, storedConnection, connectionMode) {
   return storedConnection;
 }
 
-async function connectUtility(driver, storedConnection, connectionMode, additionalOptions = null) {
-  const connectionLoaded = await loadConnection(driver, storedConnection, connectionMode);
-
-  const connection = {
-    database: connectionLoaded.defaultDatabase,
-    ...decryptConnection(connectionLoaded),
-  };
-
-  if (!connection.port && driver.defaultPort) connection.port = driver.defaultPort.toString();
-
-  if (connection.useSshTunnel) {
-    const tunnel = await getSshTunnelProxy(connection);
-    if (tunnel.state == 'error') {
-      throw new Error(tunnel.message);
-    }
-
-    connection.server = tunnel.localHost;
-    connection.port = tunnel.localPort;
-  }
-
-  // SSL functionality - copied from https://github.com/beekeeper-studio/beekeeper-studio
+async function extractConnectionSslParams(connection) {
+  /** @type {any} */
+  let ssl = undefined;
   if (connection.useSsl) {
-    connection.ssl = {};
+    ssl = {};
 
     if (connection.sslCaFile) {
-      connection.ssl.ca = await fs.readFile(connection.sslCaFile);
-      connection.ssl.sslCaFile = connection.sslCaFile;
+      ssl.ca = await fs.readFile(connection.sslCaFile);
+      ssl.sslCaFile = connection.sslCaFile;
     }
 
     if (connection.sslCertFile) {
-      connection.ssl.cert = await fs.readFile(connection.sslCertFile);
-      connection.ssl.sslCertFile = connection.sslCertFile;
+      ssl.cert = await fs.readFile(connection.sslCertFile);
+      ssl.sslCertFile = connection.sslCertFile;
     }
 
     if (connection.sslKeyFile) {
-      connection.ssl.key = await fs.readFile(connection.sslKeyFile);
-      connection.ssl.sslKeyFile = connection.sslKeyFile;
+      ssl.key = await fs.readFile(connection.sslKeyFile);
+      ssl.sslKeyFile = connection.sslKeyFile;
     }
 
     if (connection.sslCertFilePassword) {
-      connection.ssl.password = connection.sslCertFilePassword;
+      ssl.password = connection.sslCertFilePassword;
     }
 
-    if (!connection.ssl.key && !connection.ssl.ca && !connection.ssl.cert) {
+    if (!ssl.key && !ssl.ca && !ssl.cert) {
       // TODO: provide this as an option in settings
       // or per-connection as 'reject self-signed certs'
       // How it works:
@@ -98,14 +80,41 @@ async function connectUtility(driver, storedConnection, connectionMode, addition
       // if true, has to be from a public CA
       // Heroku certs are self-signed.
       // if you provide ca/cert/key files, it overrides this
-      connection.ssl.rejectUnauthorized = false;
+      ssl.rejectUnauthorized = false;
     } else {
-      connection.ssl.rejectUnauthorized = connection.sslRejectUnauthorized;
+      ssl.rejectUnauthorized = connection.sslRejectUnauthorized;
+    }
+  }
+  return ssl;
+}
+
+async function connectUtility(driver, storedConnection, connectionMode, additionalOptions = null) {
+  const connectionLoaded = await loadConnection(driver, storedConnection, connectionMode);
+
+  const connection = {
+    database: connectionLoaded.defaultDatabase,
+    ...decryptConnection(connectionLoaded),
+  };
+
+  if (!connection.port && driver.defaultPort) connection.port = driver.defaultPort.toString();
+
+  if (connection.useSshTunnel) {
+    const tunnel = await getSshTunnelProxy(connection);
+    if (tunnel.state == 'error') {
+      throw new Error(tunnel.message);
     }
+
+    connection.server = tunnel.localHost;
+    connection.port = tunnel.localPort;
   }
 
+  connection.ssl = await extractConnectionSslParams(connection);
+
   const conn = await driver.connect({ ...connection, ...additionalOptions });
   return conn;
 }
 
-module.exports = connectUtility;
+module.exports = {
+  extractConnectionSslParams,
+  connectUtility,
+};

package/src/utility/directories.js

@@ -58,9 +58,11 @@ const jsldir = dirFunc('jsl', true);
 const rundir = dirFunc('run', true);
 const uploadsdir = dirFunc('uploads', true);
 const pluginsdir = dirFunc('plugins');
-const archivedir = dirFunc('archive', false, ['default']);
+const archivedir = processArgs.runE2eTests
+  ? dirFunc('archive-e2etests', false, ['default'])
+  : dirFunc('archive', false, ['default']);
 const appdir = dirFunc('apps');
-const filesdir = dirFunc('files');
+const filesdir = processArgs.runE2eTests ? dirFunc('files-e2etests') : dirFunc('files');
 const logsdir = dirFunc('logs', 3600 * 24 * 7);
 
 function packagedPluginsDir() {
@@ -80,6 +82,9 @@ function packagedPluginsDir() {
   if (platformInfo.isAwsUbuntuLayout) {
     return '/home/ubuntu/build/plugins';
   }
+  if (platformInfo.isAzureUbuntuLayout) {
+    return '/home/azureuser/build/plugins';
+  }
   if (platformInfo.isNpmDist) {
     // node_modules
     return global['PLUGINS_DIR'];

package/src/utility/hardwareFingerprint.js

@@ -73,6 +73,7 @@ async function getPublicHardwareFingerprint() {
       region: fingerprint.region,
       isDocker: platformInfo.isDocker,
       isAwsUbuntuLayout: platformInfo.isAwsUbuntuLayout,
+      isAzureUbuntuLayout: platformInfo.isAzureUbuntuLayout,
       isElectron: platformInfo.isElectron,
     },
   };

package/src/utility/platformInfo.js

@@ -15,6 +15,7 @@ const isNpmDist = !!global['IS_NPM_DIST'];
 const isDbModel = !!global['IS_DB_MODEL'];
 const isForkedApi = processArgs.isForkedApi;
 const isAwsUbuntuLayout = fs.existsSync('/home/ubuntu/build/public');
+const isAzureUbuntuLayout = fs.existsSync('/home/azureuser/build/public');
 
 // function moduleAvailable(name) {
 //   try {
@@ -57,6 +58,7 @@ const platformInfo = {
   allowConnectionFromEnvVariables: !!isDbModel,
   defaultKeyfile: path.join(os.homedir(), '.ssh/id_rsa'),
   isAwsUbuntuLayout,
+  isAzureUbuntuLayout,
 };
 
 module.exports = platformInfo;

package/src/utility/processArgs.js

@@ -28,9 +28,9 @@ function getPassArgs() {
   if (listenApiChild) {
     res.push('listen-api-child');
   }
-  // if (runE2eTests) {
-  //   res.push('--run-e2e-tests');
-  // }
+  if (runE2eTests) {
+    res.push('--run-e2e-tests');
+  }
   return res;
 }
 

package/src/utility/useController.js

@@ -86,7 +86,7 @@ module.exports = function useController(app, electron, route, controller) {
               detail: err.detail,
             });
           } else {
-            res.status(500).json({ apiErrorMessage: err.message });
+            res.status(500).json({ apiErrorMessage: (_.isString(err) ? err : err.message) ?? 'Unknown error' });
           }
         }
       });