dbgate-api 5.3.3 → 5.4.0

package/src/controllers/config.js

@@ -3,7 +3,7 @@ const os = require('os');
 const path = require('path');
 const axios = require('axios');
 const { datadir, getLogsFilePath } = require('../utility/directories');
-const { hasPermission, getLogins } = require('../utility/hasPermission');
+const { hasPermission } = require('../utility/hasPermission');
 const socket = require('../utility/socket');
 const _ = require('lodash');
 const AsyncLock = require('async-lock');
@@ -11,6 +11,9 @@ const AsyncLock = require('async-lock');
 const currentVersion = require('../currentVersion');
 const platformInfo = require('../utility/platformInfo');
 const connections = require('../controllers/connections');
+const { getAuthProviderFromReq } = require('../auth/authProvider');
+const { checkLicense, checkLicenseKey } = require('../utility/checkLicense');
+const storage = require('./storage');
 
 const lock = new AsyncLock();
 
@@ -27,27 +30,51 @@ module.exports = {
 
   get_meta: true,
   async get(_params, req) {
-    const logins = getLogins();
-    const loginName =
-      req && req.user && req.user.login ? req.user.login : req && req.auth && req.auth.user ? req.auth.user : null;
-    const login = logins && loginName ? logins.find(x => x.login == loginName) : null;
-    const permissions = login ? login.permissions : process.env.PERMISSIONS;
+    const authProvider = getAuthProviderFromReq(req);
+    const login = authProvider.getCurrentLogin(req);
+    const permissions = authProvider.getCurrentPermissions(req);
+    const isUserLoggedIn = authProvider.isUserLoggedIn(req);
+
+    const singleConid = authProvider.getSingleConnectionId(req);
+
+    const singleConnection = singleConid
+      ? await connections.getCore({ conid: singleConid })
+      : connections.singleConnection;
+
+    let configurationError = null;
+    if (process.env.STORAGE_DATABASE && process.env.BASIC_AUTH) {
+      configurationError =
+        'Basic authentization is not allowed, when using storage. Cannot use both STORAGE_DATABASE and BASIC_AUTH';
+    }
+
+    const checkedLicense = await checkLicense();
+    const isLicenseValid = checkedLicense?.status == 'ok';
 
     return {
       runAsPortal: !!connections.portalConnections,
       singleDbConnection: connections.singleDbConnection,
-      singleConnection: connections.singleConnection,
+      singleConnection: singleConnection,
+      isUserLoggedIn,
       // hideAppEditor: !!process.env.HIDE_APP_EDITOR,
       allowShellConnection: platformInfo.allowShellConnection,
       allowShellScripting: platformInfo.allowShellScripting,
       isDocker: platformInfo.isDocker,
+      isElectron: platformInfo.isElectron,
+      isLicenseValid,
+      checkedLicense,
+      configurationError,
+      logoutUrl: await authProvider.getLogoutUrl(),
       permissions,
       login,
-      oauth: process.env.OAUTH_AUTH,
-      oauthClient: process.env.OAUTH_CLIENT_ID,
-      oauthScope: process.env.OAUTH_SCOPE,
-      oauthLogout: process.env.OAUTH_LOGOUT,
-      isLoginForm: !!process.env.AD_URL || (!!logins && !process.env.BASIC_AUTH),
+      // ...additionalConfigProps,
+      isBasicAuth: !!process.env.BASIC_AUTH,
+      isAdminLoginForm: !!(
+        process.env.STORAGE_DATABASE &&
+        process.env.ADMIN_PASSWORD &&
+        !process.env.BASIC_AUTH &&
+        checkedLicense?.type == 'premium'
+      ),
+      storageDatabase: process.env.STORAGE_DATABASE,
       logsFilePath: getLogsFilePath(),
       connectionsFilePath: path.join(datadir(), 'connections.jsonl'),
       ...currentVersion,
@@ -75,6 +102,12 @@ module.exports = {
     return res;
   },
 
+  deleteSettings_meta: true,
+  async deleteSettings() {
+    await fs.unlink(path.join(datadir(), 'settings.json'));
+    return true;
+  },
+
   fillMissingSettings(value) {
     const res = {
       ...value,
@@ -97,12 +130,39 @@ module.exports = {
   async loadSettings() {
     try {
       const settingsText = await fs.readFile(path.join(datadir(), 'settings.json'), { encoding: 'utf-8' });
-      return this.fillMissingSettings(JSON.parse(settingsText));
+      return {
+        ...this.fillMissingSettings(JSON.parse(settingsText)),
+        'other.licenseKey': platformInfo.isElectron ? await this.loadLicenseKey() : undefined,
+      };
     } catch (err) {
       return this.fillMissingSettings({});
     }
   },
 
+  async loadLicenseKey() {
+    try {
+      const licenseKey = await fs.readFile(path.join(datadir(), 'license.key'), { encoding: 'utf-8' });
+      return licenseKey;
+    } catch (err) {
+      return null;
+    }
+  },
+
+  saveLicenseKey_meta: true,
+  async saveLicenseKey({ licenseKey }) {
+    try {
+      if (process.env.STORAGE_DATABASE) {
+        await storage.writeConfig({ group: 'license', config: { licenseKey } });
+        // await storageWriteConfig('license', { licenseKey });
+      } else {
+        await fs.writeFile(path.join(datadir(), 'license.key'), licenseKey);
+      }
+      socket.emitChanged(`config-changed`);
+    } catch (err) {
+      return null;
+    }
+  },
+
   updateSettings_meta: true,
   async updateSettings(values, req) {
     if (!hasPermission(`settings/change`, req)) return false;
@@ -112,10 +172,16 @@ module.exports = {
       try {
         const updated = {
           ...currentValue,
-          ...values,
+          ..._.omit(values, ['other.licenseKey']),
         };
         await fs.writeFile(path.join(datadir(), 'settings.json'), JSON.stringify(updated, undefined, 2));
         // this.settingsValue = updated;
+
+        if (currentValue['other.licenseKey'] != values['other.licenseKey']) {
+          await this.saveLicenseKey({ licenseKey: values['other.licenseKey'] });
+          socket.emitChanged(`config-changed`);
+        }
+
         socket.emitChanged(`settings-changed`);
         return updated;
       } catch (err) {
@@ -130,4 +196,10 @@ module.exports = {
     const resp = await axios.default.get('https://raw.githubusercontent.com/dbgate/dbgate/master/CHANGELOG.md');
     return resp.data;
   },
+
+  checkLicense_meta: true,
+  async checkLicense({ licenseKey }) {
+    const resp = await checkLicenseKey(licenseKey);
+    return resp;
+  },
 };

package/src/controllers/connections.js

@@ -16,6 +16,9 @@ const { safeJsonParse, getLogger } = require('dbgate-tools');
 const platformInfo = require('../utility/platformInfo');
 const { connectionHasPermission, testConnectionPermission } = require('../utility/hasPermission');
 const pipeForkLogs = require('../utility/pipeForkLogs');
+const requireEngineDriver = require('../utility/requireEngineDriver');
+const { getAuthProviderById } = require('../auth/authProvider');
+const { startTokenChecking } = require('../utility/authProxy');
 
 const logger = getLogger('connections');
 
@@ -70,6 +73,8 @@ function getPortalCollections() {
       displayName: process.env[`LABEL_${id}`],
       isReadOnly: process.env[`READONLY_${id}`],
       databases: process.env[`DBCONFIG_${id}`] ? safeJsonParse(process.env[`DBCONFIG_${id}`]) : null,
+      allowedDatabases: process.env[`ALLOWED_DATABASES_${id}`]?.replace(/\|/g, '\n'),
+      allowedDatabasesRegex: process.env[`ALLOWED_DATABASES_REGEX_${id}`],
       parent: process.env[`PARENT_${id}`] || undefined,
 
       // SSH tunnel
@@ -199,6 +204,12 @@ module.exports = {
 
   list_meta: true,
   async list(_params, req) {
+    const storage = require('./storage');
+
+    const storageConnections = await storage.connections(req);
+    if (storageConnections) {
+      return storageConnections;
+    }
     if (portalConnections) {
       if (platformInfo.allowShellConnection) return portalConnections;
       return portalConnections.map(maskConnection).filter(x => connectionHasPermission(x, req));
@@ -236,14 +247,16 @@ module.exports = {
   },
 
   saveVolatile_meta: true,
-  async saveVolatile({ conid, user, password, test }) {
+  async saveVolatile({ conid, user = undefined, password = undefined, accessToken = undefined, test = false }) {
     const old = await this.getCore({ conid });
     const res = {
       ...old,
       _id: crypto.randomUUID(),
       password,
+      accessToken,
       passwordMode: undefined,
       unsaved: true,
+      useRedirectDbLogin: false,
     };
     if (old.passwordMode == 'askUser') {
       res.user = user;
@@ -336,6 +349,14 @@ module.exports = {
     if (volatile) {
       return volatile;
     }
+
+    const storage = require('./storage');
+
+    const storageConnection = await storage.getConnection({ conid });
+    if (storageConnection) {
+      return storageConnection;
+    }
+
     if (portalConnections) {
       const res = portalConnections.find(x => x._id == conid) || null;
       return mask && !platformInfo.allowShellConnection ? maskConnection(res) : res;
@@ -365,4 +386,95 @@ module.exports = {
     });
     return res;
   },
+
+  dbloginWeb_meta: {
+    raw: true,
+    method: 'get',
+  },
+  async dbloginWeb(req, res) {
+    const { conid, state, redirectUri } = req.query;
+    const connection = await this.getCore({ conid });
+    const driver = requireEngineDriver(connection);
+    const authResp = await driver.getRedirectAuthUrl(connection, {
+      redirectUri,
+      state,
+      client: 'web',
+    });
+    res.redirect(authResp.url);
+  },
+
+  dbloginApp_meta: true,
+  async dbloginApp({ conid, state }) {
+    const connection = await this.getCore({ conid });
+    const driver = requireEngineDriver(connection);
+    const resp = await driver.getRedirectAuthUrl(connection, {
+      state,
+      client: 'app',
+    });
+    startTokenChecking(resp.sid, async token => {
+      const volatile = await this.saveVolatile({ conid, accessToken: token });
+      socket.emit('got-volatile-token', { savedConId: conid, volatileConId: volatile._id });
+    });
+    return resp;
+  },
+
+  dbloginToken_meta: true,
+  async dbloginToken({ code, conid, strmid, redirectUri, sid }) {
+    try {
+      const connection = await this.getCore({ conid });
+      const driver = requireEngineDriver(connection);
+      const accessToken = await driver.getAuthTokenFromCode(connection, { sid, code, redirectUri });
+      const volatile = await this.saveVolatile({ conid, accessToken });
+      // console.log('******************************** WE HAVE ACCESS TOKEN', accessToken);
+      socket.emit('got-volatile-token', { strmid, savedConId: conid, volatileConId: volatile._id });
+      return { success: true };
+    } catch (err) {
+      logger.error({ err }, 'Error getting DB token');
+      return { error: err.message };
+    }
+  },
+
+  dbloginAuthToken_meta: true,
+  async dbloginAuthToken({ amoid, code, conid, redirectUri, sid }) {
+    try {
+      const connection = await this.getCore({ conid });
+      const driver = requireEngineDriver(connection);
+      const accessToken = await driver.getAuthTokenFromCode(connection, { code, redirectUri, sid });
+      const volatile = await this.saveVolatile({ conid, accessToken });
+      const authProvider = getAuthProviderById(amoid);
+      const resp = await authProvider.login(null, null, { conid: volatile._id });
+      return resp;
+    } catch (err) {
+      logger.error({ err }, 'Error getting DB token');
+      return { error: err.message };
+    }
+  },
+
+  dbloginAuth_meta: true,
+  async dbloginAuth({ amoid, conid, user, password }) {
+    if (user || password) {
+      const saveResp = await this.saveVolatile({ conid, user, password, test: true });
+      if (saveResp.msgtype == 'connected') {
+        const loginResp = await getAuthProviderById(amoid).login(user, password, { conid: saveResp._id });
+        return loginResp;
+      }
+      return saveResp;
+    }
+
+    // user and password is stored in connection, volatile connection is not needed
+    const loginResp = await getAuthProviderById(amoid).login(null, null, { conid });
+    return loginResp;
+  },
+
+  volatileDbloginFromAuth_meta: true,
+  async volatileDbloginFromAuth({ conid }, req) {
+    const connection = await this.getCore({ conid });
+    const driver = requireEngineDriver(connection);
+    const accessToken = await driver.getAccessTokenFromAuth(connection, req);
+    if (accessToken) {
+      const volatile = await this.saveVolatile({ conid, accessToken });
+      return volatile;
+    }
+    return null;
+  },
 };

package/src/controllers/databaseConnections.js

@@ -89,6 +89,9 @@ module.exports = {
     if (connection.passwordMode == 'askPassword' || connection.passwordMode == 'askUser') {
       throw new MissingCredentialsError({ conid, passwordMode: connection.passwordMode });
     }
+    if (connection.useRedirectDbLogin) {
+      throw new MissingCredentialsError({ conid, redirectToDbLogin: true });
+    }
     const subprocess = fork(
       global['API_PACKAGE'] || process.argv[1],
       [
@@ -179,6 +182,15 @@ module.exports = {
     return res;
   },
 
+  runOperation_meta: true,
+  async runOperation({ conid, database, operation, useTransaction }, req) {
+    testConnectionPermission(conid, req);
+    logger.info({ conid, database, operation }, 'Processing operation');
+    const opened = await this.ensureOpened(conid, database);
+    const res = await this.sendRequest(opened, { msgtype: 'runOperation', operation, useTransaction });
+    return res;
+  },
+
   collectionData_meta: true,
   async collectionData({ conid, database, options }, req) {
     testConnectionPermission(conid, req);

package/src/controllers/plugins.js

@@ -42,13 +42,14 @@ module.exports = {
 
   info_meta: true,
   async info({ packageName }) {
+    // @ts-ignore
+    const isPackaged = await fs.exists(path.join(packagedPluginsDir(), packageName));
+
     try {
       const infoResp = await axios.default.get(`https://registry.npmjs.org/${packageName}`);
       const { latest } = infoResp.data['dist-tags'];
       const manifest = infoResp.data.versions[latest];
       const { readme } = infoResp.data;
-      // @ts-ignore
-      const isPackaged = await fs.exists(path.join(packagedPluginsDir(), packageName));
 
       return {
         readme,
@@ -57,6 +58,7 @@ module.exports = {
       };
     } catch (err) {
       return {
+        isPackaged,
         state: 'error',
         error: err.message,
       };

package/src/controllers/serverConnections.js

@@ -1,3 +1,4 @@
+const crypto = require('crypto');
 const connections = require('./connections');
 const socket = require('../utility/socket');
 const { fork } = require('child_process');
@@ -56,6 +57,9 @@ module.exports = {
       if (connection.passwordMode == 'askPassword' || connection.passwordMode == 'askUser') {
         throw new MissingCredentialsError({ conid, passwordMode: connection.passwordMode });
       }
+      if (connection.useRedirectDbLogin) {
+        throw new MissingCredentialsError({ conid, redirectToDbLogin: true });
+      }
       const subprocess = fork(
         global['API_PACKAGE'] || process.argv[1],
         [
@@ -181,22 +185,29 @@ module.exports = {
     return { status: 'ok' };
   },
 
-  createDatabase_meta: true,
-  async createDatabase({ conid, name }, req) {
+  async sendDatabaseOp({ conid, msgtype, name }, req) {
     testConnectionPermission(conid, req);
     const opened = await this.ensureOpened(conid);
     if (opened.connection.isReadOnly) return false;
-    opened.subprocess.send({ msgtype: 'createDatabase', name });
-    return { status: 'ok' };
+    const res = await this.sendRequest(opened, { msgtype, name });
+    if (res.errorMessage) {
+      console.error(res.errorMessage);
+
+      return {
+        apiErrorMessage: res.errorMessage,
+      };
+    }
+    return res.result || null;
+  },
+
+  createDatabase_meta: true,
+  async createDatabase({ conid, name }, req) {
+    return this.sendDatabaseOp({ conid, msgtype: 'createDatabase', name }, req);
   },
 
   dropDatabase_meta: true,
   async dropDatabase({ conid, name }, req) {
-    testConnectionPermission(conid, req);
-    const opened = await this.ensureOpened(conid);
-    if (opened.connection.isReadOnly) return false;
-    opened.subprocess.send({ msgtype: 'dropDatabase', name });
-    return { status: 'ok' };
+    return this.sendDatabaseOp({ conid, msgtype: 'dropDatabase', name }, req);
   },
 
   sendRequest(conn, message) {

package/src/controllers/storage.js

@@ -0,0 +1,20 @@
+module.exports = {
+  connections_meta: true,
+  async connections(req) {
+    return null;
+  },
+
+  getConnection_meta: true,
+  async getConnection({ conid }) {
+    return null;
+  },
+
+  async loadSuperadminPermissions() {
+    return [];
+  },
+
+  getConnectionsForLoginPage_meta: true,
+  async getConnectionsForLoginPage() {
+    return null;
+  },
+};

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '5.3.3',
-  buildTime: '2024-08-01T06:28:34.974Z'
+  version: '5.4.0',
+  buildTime: '2024-09-03T13:07:02.765Z'
 };

package/src/index.js

@@ -97,9 +97,12 @@ if (processArgs.listenApi) {
 }
 
 const shell = require('./shell/index');
-const dbgateTools = require('dbgate-tools');
+const currentVersion = require('./currentVersion');
 
-global['DBGATE_TOOLS'] = dbgateTools;
+global.DBGATE_PACKAGES = {
+  'dbgate-tools': require('dbgate-tools'),
+  'dbgate-sqltree': require('dbgate-sqltree'),
+};
 
 if (processArgs.startProcess) {
   const proc = require('./proc');
@@ -116,6 +119,7 @@ module.exports = {
   ...shell,
   getLogger,
   configureLogger,
+  currentVersion,
   // loadLogsContent,
   getMainModule: () => require('./main'),
 };

package/src/main.js

@@ -18,6 +18,7 @@ const sessions = require('./controllers/sessions');
 const runners = require('./controllers/runners');
 const jsldata = require('./controllers/jsldata');
 const config = require('./controllers/config');
+const storage = require('./controllers/storage');
 const archive = require('./controllers/archive');
 const apps = require('./controllers/apps');
 const auth = require('./controllers/auth');
@@ -31,9 +32,9 @@ const onFinished = require('on-finished');
 const { rundir } = require('./utility/directories');
 const platformInfo = require('./utility/platformInfo');
 const getExpressPath = require('./utility/getExpressPath');
-const { getLogins } = require('./utility/hasPermission');
 const _ = require('lodash');
 const { getLogger } = require('dbgate-tools');
+const { getDefaultAuthProvider } = require('./auth/authProvider');
 
 const logger = getLogger('main');
 
@@ -44,11 +45,23 @@ function start() {
 
   const server = http.createServer(app);
 
-  const logins = getLogins();
-  if (logins && process.env.BASIC_AUTH) {
+  if (process.env.BASIC_AUTH && !process.env.STORAGE_DATABASE) {
+    async function authorizer(username, password, cb) {
+      try {
+        const resp = await getDefaultAuthProvider().login(username, password);
+        if (resp.accessToken) {
+          cb(null, true);
+        } else {
+          cb(null, false);
+        }
+      } catch (err) {
+        cb(err, false);
+      }
+    }
     app.use(
       basicAuth({
-        users: _.fromPairs(logins.filter(x => x.password).map(x => [x.login, x.password])),
+        authorizer,
+        authorizeAsync: true,
         challenge: true,
         realm: 'DbGate Web App',
       })
@@ -72,9 +85,7 @@ function start() {
     });
   }
 
-  if (auth.shouldAuthorizeApi()) {
-    app.use(auth.authMiddleware);
-  }
+  app.use(auth.authMiddleware);
 
   app.get(getExpressPath('/stream'), async function (req, res) {
     const strmid = req.query.strmid;
@@ -162,6 +173,7 @@ function useAllControllers(app, electron) {
   useController(app, electron, '/runners', runners);
   useController(app, electron, '/jsldata', jsldata);
   useController(app, electron, '/config', config);
+  useController(app, electron, '/storage', storage);
   useController(app, electron, '/archive', archive);
   useController(app, electron, '/uploads', uploads);
   useController(app, electron, '/plugins', plugins);

package/src/nativeModulesContent.js

@@ -3,5 +3,7 @@
 const content = {};
 
 content['better-sqlite3'] = () => require('better-sqlite3');
+content['oracledb'] = () => require('oracledb');
+
 
 module.exports = content;

package/src/proc/databaseConnectionProcess.js

@@ -170,6 +170,18 @@ async function handleRunScript({ msgid, sql, useTransaction }, skipReadonlyCheck
   }
 }
 
+async function handleRunOperation({ msgid, operation, useTransaction }, skipReadonlyCheck = false) {
+  await waitConnected();
+  const driver = requireEngineDriver(storedConnection);
+  try {
+    if (!skipReadonlyCheck) ensureExecuteCustomScript(driver);
+    await driver.operation(systemConnection, operation, { useTransaction });
+    process.send({ msgtype: 'response', msgid });
+  } catch (err) {
+    process.send({ msgtype: 'response', msgid, errorMessage: err.message });
+  }
+}
+
 async function handleQueryData({ msgid, sql }, skipReadonlyCheck = false) {
   await waitConnected();
   const driver = requireEngineDriver(storedConnection);
@@ -311,6 +323,7 @@ const messageHandlers = {
   connect: handleConnect,
   queryData: handleQueryData,
   runScript: handleRunScript,
+  runOperation: handleRunOperation,
   updateCollection: handleUpdateCollection,
   collectionData: handleCollectionData,
   loadKeys: handleLoadKeys,

package/src/proc/serverConnectionProcess.js

@@ -16,7 +16,18 @@ let afterConnectCallbacks = [];
 async function handleRefresh() {
   const driver = requireEngineDriver(storedConnection);
   try {
-    const databases = await driver.listDatabases(systemConnection);
+    let databases = await driver.listDatabases(systemConnection);
+    if (storedConnection?.allowedDatabases?.trim()) {
+      const allowedDatabaseList = storedConnection.allowedDatabases
+        .split('\n')
+        .map(x => x.trim().toLowerCase())
+        .filter(x => x);
+      databases = databases.filter(x => allowedDatabaseList.includes(x.name.toLocaleLowerCase()));
+    }
+    if (storedConnection?.allowedDatabasesRegex?.trim()) {
+      const regex = new RegExp(storedConnection.allowedDatabasesRegex, 'i');
+      databases = databases.filter(x => regex.test(x.name));
+    }
     setStatusName('ok');
     const databasesString = stableStringify(databases);
     if (lastDatabases != databasesString) {
@@ -94,18 +105,24 @@ function handlePing() {
   lastPing = new Date().getTime();
 }
 
-async function handleDatabaseOp(op, { name }) {
-  const driver = requireEngineDriver(storedConnection);
-  systemConnection = await connectUtility(driver, storedConnection, 'app');
-  if (driver[op]) {
-    await driver[op](systemConnection, name);
-  } else {
-    const dmp = driver.createDumper();
-    dmp[op](name);
-    logger.info({ sql: dmp.s }, 'Running script');
-    await driver.query(systemConnection, dmp.s);
+async function handleDatabaseOp(op, { msgid, name }) {
+  try {
+    const driver = requireEngineDriver(storedConnection);
+    systemConnection = await connectUtility(driver, storedConnection, 'app');
+    if (driver[op]) {
+      await driver[op](systemConnection, name);
+    } else {
+      const dmp = driver.createDumper();
+      dmp[op](name);
+      logger.info({ sql: dmp.s }, 'Running script');
+      await driver.query(systemConnection, dmp.s);
+    }
+    await handleRefresh();
+
+    process.send({ msgtype: 'response', msgid, status: 'ok' });
+  } catch (err) {
+    process.send({ msgtype: 'response', msgid, errorMessage: err.message });
   }
-  await handleRefresh();
 }
 
 async function handleDriverDataCore(msgid, callMethod) {

package/src/proc/sshForwardProcess.js

@@ -15,10 +15,12 @@ async function getSshConnection(connection) {
     agentForward: connection.sshMode == 'agent',
     passphrase: connection.sshMode == 'keyFile' ? connection.sshKeyfilePassword : undefined,
     username: connection.sshLogin,
-    password: connection.sshMode == 'userPassword' ? connection.sshPassword : undefined,
+    password: (connection.sshMode || 'userPassword') == 'userPassword' ? connection.sshPassword : undefined,
     agentSocket: connection.sshMode == 'agent' ? platformInfo.sshAuthSock : undefined,
     privateKey:
-      connection.sshMode == 'keyFile' && connection.sshKeyfile ? await fs.readFile(connection.sshKeyfile) : undefined,
+      connection.sshMode == 'keyFile' && (connection.sshKeyfile || platformInfo?.defaultKeyfile)
+        ? await fs.readFile(connection.sshKeyfile || platformInfo?.defaultKeyfile)
+        : undefined,
     skipAutoPrivateKey: true,
     noReadline: true,
   };

package/src/shell/dbModelToJson.js

@@ -0,0 +1,16 @@
+const importDbModel = require('../utility/importDbModel');
+const fs = require('fs');
+
+async function dbModelToJson({ modelFolder, outputFile, commonjs }) {
+  const dbInfo = await importDbModel(modelFolder);
+
+  const json = JSON.stringify(dbInfo, null, 2);
+  if (commonjs) {
+    fs.writeFileSync(outputFile, `module.exports = ${json};`);
+    return;
+  } else {
+    fs.writeFileSync(outputFile, json);
+  }
+}
+
+module.exports = dbModelToJson;