dbgate-api-premium 7.0.0 → 7.0.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api-premium",
   "main": "src/index.js",
-  "version": "7.0.0",
+  "version": "7.0.2",
   "homepage": "https://dbgate.org/",
   "repository": {
     "type": "git",
@@ -24,16 +24,16 @@
     "activedirectory2": "^2.1.0",
     "archiver": "^7.0.1",
     "async-lock": "^1.2.6",
-    "axios": "^0.21.1",
+    "axios": "^1.13.2",
     "body-parser": "^1.19.0",
     "byline": "^5.0.0",
     "compare-versions": "^3.6.0",
     "cors": "^2.8.5",
     "cross-env": "^6.0.3",
-    "dbgate-datalib": "^7.0.0",
+    "dbgate-datalib": "^7.0.2",
     "dbgate-query-splitter": "^4.11.9",
-    "dbgate-sqltree": "^7.0.0",
-    "dbgate-tools": "^7.0.0",
+    "dbgate-sqltree": "^7.0.2",
+    "dbgate-tools": "^7.0.2",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -87,7 +87,7 @@
   "devDependencies": {
     "@types/fs-extra": "^9.0.11",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "^7.0.0",
+    "dbgate-types": "^7.0.2",
     "env-cmd": "^10.1.0",
     "jsdoc-to-markdown": "^9.0.5",
     "node-loader": "^1.0.2",

package/src/controllers/connections.js

@@ -24,10 +24,12 @@ const requireEngineDriver = require('../utility/requireEngineDriver');
 const { getAuthProviderById } = require('../auth/authProvider');
 const { startTokenChecking } = require('../utility/authProxy');
 const { extractConnectionsFromEnv } = require('../utility/envtools');
+const { MissingCredentialsError } = require('../utility/exceptions');
 
 const logger = getLogger('connections');
 
 let volatileConnections = {};
+let pendingTestSubprocesses = {}; // Map of conid -> subprocess for MS Entra auth flows
 
 function getNamedArgs() {
   const res = {};
@@ -239,14 +241,60 @@ module.exports = {
     );
     pipeForkLogs(subprocess);
     subprocess.send({ ...connection, requestDbList });
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
+      let isWaitingForVolatile = false;
+      
+      const cleanup = () => {
+        if (connection._id && pendingTestSubprocesses[connection._id]) {
+          delete pendingTestSubprocesses[connection._id];
+        }
+      };
+      
       subprocess.on('message', resp => {
         if (handleProcessCommunication(resp, subprocess)) return;
         // @ts-ignore
-        const { msgtype } = resp;
+        const { msgtype, missingCredentialsDetail } = resp;
         if (msgtype == 'connected' || msgtype == 'error') {
+          cleanup();
           resolve(resp);
         }
+        if (msgtype == 'missingCredentials') {
+          if (missingCredentialsDetail?.redirectToDbLogin) {
+            // Store the subprocess for later when volatile connection is ready
+            isWaitingForVolatile = true;
+            pendingTestSubprocesses[connection._id] = {
+              subprocess,
+              requestDbList,
+            };
+            // Return immediately with redirectToDbLogin status in the old format
+            resolve({
+              missingCredentials: true,
+              detail: {
+                ...missingCredentialsDetail,
+                keepErrorResponseFromApi: true,
+              },
+            });
+            return;
+          }
+          reject(new MissingCredentialsError(missingCredentialsDetail));
+        }
+      });
+      
+      subprocess.on('exit', (code) => {
+        // If exit happens while waiting for volatile, that's expected
+        if (isWaitingForVolatile && code === 0) {
+          cleanup();
+          return;
+        }
+        cleanup();
+        if (code !== 0) {
+          reject(new Error(`Test subprocess exited with code ${code}`));
+        }
+      });
+      
+      subprocess.on('error', (err) => {
+        cleanup();
+        reject(err);
       });
     });
   },
@@ -279,6 +327,38 @@ module.exports = {
       return testRes;
     } else {
       volatileConnections[res._id] = res;
+      
+      // Check if there's a pending test subprocess waiting for this volatile connection
+      const pendingTest = pendingTestSubprocesses[conid];
+      if (pendingTest) {
+        const { subprocess, requestDbList } = pendingTest;
+        try {
+          // Send the volatile connection to the waiting subprocess
+          subprocess.send({ ...res, requestDbList, isVolatileResolved: true });
+          
+          // Wait for the test result and emit it as an event
+          subprocess.once('message', resp => {
+            if (handleProcessCommunication(resp, subprocess)) return;
+            const { msgtype } = resp;
+            if (msgtype == 'connected' || msgtype == 'error') {
+              // Emit SSE event with test result
+              socket.emit(`connection-test-result-${conid}`, {
+                ...resp,
+                volatileConId: res._id,
+              });
+              delete pendingTestSubprocesses[conid];
+            }
+          });
+        } catch (err) {
+          logger.error(extractErrorLogData(err), 'DBGM-00118 Error sending volatile connection to test subprocess');
+          socket.emit(`connection-test-result-${conid}`, {
+            msgtype: 'error',
+            error: err.message,
+          });
+          delete pendingTestSubprocesses[conid];
+        }
+      }
+      
       return res;
     }
   },

package/src/controllers/storageDb.js

@@ -957,12 +957,20 @@ async function storageUpdateTeamFile({ teamFileId, data, name, metadata }) {
   return true;
 }
 
-async function storageUpdateTeamFileAdmin({ teamFileId, name }) {
+async function storageUpdateTeamFileAdmin({ teamFileId, name, teamFolderId, changedContent }) {
   const [conn, driver] = await getStorageConnection();
   if (!conn) {
     return null;
   }
-  await storageSqlCommandFmt('update ~team_files set ~file_name = %v where ~id = %v', name, teamFileId);
+  await storageSqlCommandFmt(
+    'update ~team_files set ~file_name = %v, ~team_folder_id = %v where ~id = %v',
+    name,
+    teamFolderId,
+    teamFileId
+  );
+  if (changedContent != null) {
+    await storageSqlCommandFmt('update ~team_files set ~file_content = %v where ~id = %v', changedContent, teamFileId);
+  }
   return true;
 }
 
@@ -991,7 +999,7 @@ async function storageListAllAdminFolders() {
 
   const resp = await storageSelectFmt(`select ~team_folders.~id, ~team_folders.~folder_name, 
       (select count(*) from ~team_files where ~team_files.~team_folder_id = ~team_folders.~id) as ~file_count
-      from ~team_folders`);
+      from ~team_folders order by ~team_folders.~folder_name, ~team_folders.~id`);
   return resp;
 }
 
@@ -1020,6 +1028,7 @@ async function storageListAllAdminFiles() {
     from ~team_files 
     inner join ~team_file_types on ~team_files.~file_type_id = ~team_file_types.~id
     inner join ~team_folders on ~team_files.~team_folder_id = ~team_folders.~id
+    order by ~team_files.~file_name, ~team_files.~id
     `);
   return resp;
 }

package/src/controllers/teamFiles.js

@@ -375,6 +375,7 @@ module.exports = {
       ownerEmail: item.owner_email,
       typeName: item.type_name,
       folderName: item.folder_name,
+      teamFolderId: item.team_folder_id,
     }));
   },
 
@@ -392,14 +393,15 @@ module.exports = {
       ownerName: existingFile.owner_login,
       ownerEmail: existingFile.owner_email,
       typeName: existingFile.type_name,
+      teamFolderId: existingFile.team_folder_id?.toString(),
     };
   },
 
   setAdminFile_meta: true,
-  async setAdminFile({ id, name }, req) {
+  async setAdminFile({ id, name, teamFolderId, changedContent }, req) {
     const loadedPermissions = await loadPermissionsFromRequest(req);
     if (!hasPermission(`admin/team-files`, loadedPermissions)) return false;
-    await storageUpdateTeamFileAdmin({ teamFileId: id, name });
+    await storageUpdateTeamFileAdmin({ teamFileId: id, name, teamFolderId, changedContent });
     socket.emitChanged('team-files-changed');
     return true;
   },

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '7.0.0',
-  buildTime: '2026-01-22T09:09:52.304Z'
+  version: '7.0.2',
+  buildTime: '2026-02-05T12:05:51.104Z'
 };

package/src/proc/connectProcess.js

@@ -18,13 +18,36 @@ Platform: ${process.platform}
 
 function start() {
   childProcessChecker();
-  process.on('message', async connection => {
+
+  let isWaitingForVolatile = false;
+
+  const handleConnection = async connection => {
     // @ts-ignore
     const { requestDbList } = connection;
     if (handleProcessCommunication(connection)) return;
+
     try {
       const driver = requireEngineDriver(connection);
-      const dbhan = await connectUtility(driver, connection, 'app');
+      const connectionChanged = driver?.beforeConnectionSave ? driver.beforeConnectionSave(connection) : connection;
+
+      if (!connection.isVolatileResolved) {
+        if (connectionChanged.useRedirectDbLogin) {
+          process.send({
+            msgtype: 'missingCredentials',
+            missingCredentialsDetail: {
+              // @ts-ignore
+              conid: connection._id,
+              redirectToDbLogin: true,
+              keepErrorResponseFromApi: true,
+            },
+          });
+          // Don't exit - wait for volatile connection to be sent
+          isWaitingForVolatile = true;
+          return;
+        }
+      }
+
+      const dbhan = await connectUtility(driver, connectionChanged, 'app');
       let version = {
         version: 'Unknown',
       };
@@ -45,6 +68,16 @@ function start() {
     }
 
     process.exit(0);
+  };
+
+  process.on('message', async connection => {
+    // If we're waiting for volatile and receive a new connection, use it
+    if (isWaitingForVolatile) {
+      isWaitingForVolatile = false;
+      await handleConnection(connection);
+    } else {
+      await handleConnection(connection);
+    }
   });
 }