dbgate-api 7.2.0 → 7.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api",
   "main": "src/index.js",
-  "version": "7.2.0",
+  "version": "7.2.1",
   "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.2.0",
+    "dbgate-datalib": "7.2.1",
     "dbgate-query-splitter": "^4.12.0",
-    "dbgate-rest": "7.2.0",
-    "dbgate-sqltree": "7.2.0",
-    "dbgate-tools": "7.2.0",
+    "dbgate-rest": "7.2.1",
+    "dbgate-sqltree": "7.2.1",
+    "dbgate-tools": "7.2.1",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -96,7 +96,7 @@
     "@types/fs-extra": "^9.0.11",
     "@types/jest": "^30.0.0",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "7.2.0",
+    "dbgate-types": "7.2.1",
     "env-cmd": "^10.1.0",
     "jest": "^30.4.2",
     "jsdoc-to-markdown": "^9.0.5",

package/src/controllers/config.js

@@ -16,6 +16,7 @@ const connections = require('../controllers/connections');
 const { getAuthProviderFromReq } = require('../auth/authProvider');
 const { checkLicense, checkLicenseKey } = require('../utility/checkLicense');
 const storage = require('./storage');
+const dbgateApi = require('../shell');
 const { getAuthProxyUrl, tryToGetRefreshedLicense } = require('../utility/authProxy');
 const { getPublicHardwareFingerprint } = require('../utility/hardwareFingerprint');
 const { extractErrorMessage } = require('dbgate-tools');
@@ -438,4 +439,20 @@ module.exports = {
 
     return true;
   },
+
+  createConnectionsAndSettingsZip_meta: true,
+  async createConnectionsAndSettingsZip({ db, filePath }, req) {
+    const loadedPermissions = await loadPermissionsFromRequest(req);
+    if (!hasPermission(`admin/config`, loadedPermissions)) {
+      throw new Error('Permission denied: admin/config');
+    }
+
+    if (connections.portalConnections) {
+      throw new Error('Not allowed');
+    }
+
+    const exportDb = process.env.STORAGE_DATABASE ? await storage.fillTeamFileContentForExport(db) : db;
+    await dbgateApi.zipJsonLinesData(exportDb, filePath);
+    return true;
+  },
 };

package/src/controllers/databaseConnections.js

@@ -157,8 +157,15 @@ module.exports = {
 
   handle_copyStreamError(conid, database, { copyStreamError }) {
     const { progressName } = copyStreamError;
-    const { runid } = progressName;
-    logger.error(`DBGM-00103 Error in database connection ${conid}, database ${database}: ${copyStreamError}`);
+    const runid = progressName?.runid;
+    logger.error({ conid, database, copyStreamError }, 'DBGM-00000 Error in database connection copy stream');
+    if (!runid) return;
+    if (copyStreamError.dbgateCopyStreamErrorReported) return;
+    socket.emit(`runner-progress-${runid}`, {
+      progressName: progressName?.name,
+      status: 'error',
+      errorMessage: copyStreamError.message,
+    });
     socket.emit(`runner-done-${runid}`);
   },
 

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '7.2.0',
-  buildTime: '2026-06-08T11:53:36.651Z'
+  version: '7.2.1',
+  buildTime: '2026-06-19T10:21:38.466Z'
 };

package/src/proc/databaseConnectionProcess.js

@@ -623,13 +623,50 @@ async function handleEvalJsonScript({ script, runid }) {
   const directory = path.join(rundir(), runid);
   fs.mkdirSync(directory);
   const originalCwd = process.cwd();
+  let scriptError = null;
+  let finalizerError = null;
 
   try {
     process.chdir(directory);
 
-    const evalWriter = new ScriptWriterEval(dbgateApi, requirePlugin, dbhan, runid);
-    await playJsonScriptWriter(script, evalWriter);
-    process.send({ msgtype: 'runnerDone', runid });
+    try {
+      const evalWriter = new ScriptWriterEval(dbgateApi, requirePlugin, dbhan, runid);
+      await playJsonScriptWriter(script, evalWriter);
+    } catch (err) {
+      scriptError = err;
+    } finally {
+      try {
+        await dbgateApi.finalizer.run();
+      } catch (err) {
+        finalizerError = err;
+      }
+    }
+
+    const shouldReportScriptError = scriptError && !scriptError.dbgateCopyStreamErrorReported;
+
+    if (shouldReportScriptError || finalizerError) {
+      if (shouldReportScriptError) {
+        logger.error(extractErrorLogData(scriptError), 'DBGM-00000 Error running JSON script on database connection');
+      }
+      if (finalizerError) {
+        logger.error(extractErrorLogData(finalizerError), 'DBGM-00000 Error running JSON script finalizers');
+      }
+
+      process.send({
+        msgtype: 'copyStreamError',
+        copyStreamError: {
+          message: [
+            shouldReportScriptError && extractErrorMessage(scriptError),
+            finalizerError && `Finalizer failed: ${extractErrorMessage(finalizerError)}`,
+          ]
+            .filter(Boolean)
+            .join('\n'),
+          progressName: { name: 'script', runid },
+        },
+      });
+    } else {
+      process.send({ msgtype: 'runnerDone', runid });
+    }
   } finally {
     process.chdir(originalCwd);
   }

package/src/proc/sessionProcess.js

@@ -290,14 +290,31 @@ async function handleExecuteReader({ jslid, sql, fileName }) {
 
   const reader = await driver.readQuery(dbhan, sql);
 
+  let isFinished = false;
+  const finishReader = () => {
+    if (isFinished) return;
+    isFinished = true;
+    writer.close().then(() => {
+      process.send({ msgtype: 'done' });
+    });
+  };
+
   reader.on('data', data => {
+    if (isFinished) return;
     writer.rowFromReader(data);
   });
-  reader.on('end', () => {
-    writer.close(() => {
-      process.send({ msgtype: 'done' });
+  reader.on('error', err => {
+    process.send({
+      msgtype: 'info',
+      info: {
+        message: extractErrorMessage(err),
+        severity: 'error',
+        time: new Date(),
+      },
     });
+    finishReader();
   });
+  reader.on('end', finishReader);
 }
 
 function handlePing() {

package/src/shell/copyStream.js

@@ -66,6 +66,7 @@ async function copyStream(input, output, options) {
     }
   } catch (err) {
     logger.error(extractErrorLogData(err, { progressName }), 'DBGM-00157 Import/export job failed');
+    err.dbgateCopyStreamErrorReported = true;
 
     process.send({
       msgtype: 'copyStreamError',
@@ -84,7 +85,7 @@ async function copyStream(input, output, options) {
         errorMessage: extractErrorMessage(err),
       });
     }
-    // throw err;
+    throw err;
   }
 }
 

package/src/utility/healthStatus.js

@@ -4,6 +4,7 @@ const databaseConnections = require('../controllers/databaseConnections');
 const serverConnections = require('../controllers/serverConnections');
 const sessions = require('../controllers/sessions');
 const runners = require('../controllers/runners');
+const { getLoggedUserCount } = require('./loginchecker');
 
 async function getHealthStatus() {
   const memory = process.memoryUsage();
@@ -13,7 +14,8 @@ async function getHealthStatus() {
     status: 'ok',
     databaseConnectionCount: databaseConnections.opened.length,
     serverConnectionCount: serverConnections.opened.length,
-    sessionCount: sessions.opened.length,
+    querySessionCount: sessions.opened.length,
+    loggedUserCount: getLoggedUserCount(),
     runProcessCount: runners.opened.length,
     memory,
     cpuUsage,

package/src/utility/loginchecker.js

@@ -10,9 +10,14 @@ function markLoginAsLoggedOut(licenseUid) {}
 
 const LOGIN_LIMIT_ERROR = '';
 
+function getLoggedUserCount() {
+  return 0;
+}
+
 module.exports = {
   markUserAsActive,
   isLoginLicensed,
   markLoginAsLoggedOut,
+  getLoggedUserCount,
   LOGIN_LIMIT_ERROR,
 };

package/src/utility/queryResultMetadata.js

@@ -20,6 +20,268 @@ function getColumnMetadata(columnMetadata, columnName) {
   return matchingKeys.length == 1 ? columnMetadata[matchingKeys[0]] : null;
 }
 
+function namesEqual(left, right) {
+  return left != null && right != null && left.toLowerCase() == right.toLowerCase();
+}
+
+function findTable(dbinfo, schemaName, pureName) {
+  if (!dbinfo?.tables?.length || !pureName) return null;
+  const schemaMatches = table => !schemaName || namesEqual(table.schemaName, schemaName);
+  const exactTables = dbinfo.tables.filter(table => schemaMatches(table) && table.pureName == pureName);
+  if (exactTables.length == 1) return exactTables[0];
+  const matchingTables = dbinfo.tables.filter(table => schemaMatches(table) && namesEqual(table.pureName, pureName));
+  if (matchingTables.length == 1) return matchingTables[0];
+  const uniqueNameTables = dbinfo.tables.filter(table => namesEqual(table.pureName, pureName));
+  return uniqueNameTables.length == 1 ? uniqueNameTables[0] : null;
+}
+
+function findView(dbinfo, schemaName, pureName) {
+  const views = [...(dbinfo?.views || []), ...(dbinfo?.matviews || [])];
+  if (!views.length || !pureName) return null;
+  if (schemaName) {
+    const exactView = views.find(view => view.schemaName == schemaName && view.pureName == pureName);
+    if (exactView) return exactView;
+    const schemaViews = views.filter(view => namesEqual(view.schemaName, schemaName) && namesEqual(view.pureName, pureName));
+    if (schemaViews.length == 1) return schemaViews[0];
+    const schemaLessViews = views.filter(view => !view.schemaName && namesEqual(view.pureName, pureName));
+    return schemaLessViews.length == 1 ? schemaLessViews[0] : null;
+  }
+  const matchingViews = views.filter(view => namesEqual(view.pureName, pureName));
+  return matchingViews.length == 1 ? matchingViews[0] : null;
+}
+
+function extractSelectFromCreateView(createSql) {
+  if (!createSql) return null;
+  const match = createSql.match(/\bas\s+(select\b[\s\S]*)/i);
+  return match ? match[1] : createSql;
+}
+
+function unquoteIdentifier(identifier) {
+  const trimmed = identifier?.trim();
+  if (!trimmed) return null;
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith('`') && trimmed.endsWith('`')) ||
+    (trimmed.startsWith('[') && trimmed.endsWith(']'))
+  ) {
+    return trimmed.slice(1, -1).replace(/""/g, '"').replace(/``/g, '`').replace(/]]/g, ']');
+  }
+  return trimmed;
+}
+
+function extractCreateViewColumnNames(createSql) {
+  if (!createSql) return null;
+  const asMatch = createSql.match(/\bas\b/i);
+  if (!asMatch) return null;
+  const prefix = createSql.substring(0, asMatch.index);
+  const match = prefix.match(/\(([^()]*)\)\s*$/);
+  if (!match) return null;
+  const columns = match[1]
+    .split(',')
+    .map(column => unquoteIdentifier(column))
+    .filter(Boolean);
+  return columns.length > 0 ? columns : null;
+}
+
+function getViewColumnNames(view) {
+  const analysedColumns = view?.columns?.map(column => column.columnName).filter(Boolean);
+  if (analysedColumns?.length) return analysedColumns;
+  return extractCreateViewColumnNames(view?.createSql);
+}
+
+function isSelectStarFromSingleTable(selectSql) {
+  return /^\s*select\s+\*\s+from\b/i.test(selectSql || '');
+}
+
+function getSelectListItemCount(selectSql) {
+  const selectMatch = selectSql?.match(/^\s*select\s+([\s\S]+?)\s+from\s/i);
+  return selectMatch ? splitTopLevelCommaList(selectMatch[1]).length : null;
+}
+
+const identifierPattern = '`(?:``|[^`])+`|"(?:""|[^"])+"|\\[[^\\]]+\\]|[A-Za-z_@$#][A-Za-z0-9_@$#]*';
+const qualifiedIdentifierPattern = `(?:${identifierPattern})(?:\\s*\\.\\s*(?:${identifierPattern}))*`;
+const qualifiedIdentifierOnlyRegex = new RegExp(`^\\s*${qualifiedIdentifierPattern}\\s*$`, 'i');
+const aliasStopWordPattern =
+  'on|where|join|inner|left|right|full|outer|cross|straight_join|group|order|having|limit|union';
+
+function splitTopLevelCommaList(text) {
+  const result = [];
+  let current = '';
+  let quote = null;
+  let depth = 0;
+
+  for (let index = 0; index < text.length; index++) {
+    const ch = text[index];
+    const next = text[index + 1];
+
+    if (quote) {
+      current += ch;
+      if (ch == quote) {
+        if ((quote == '"' || quote == '`') && next == quote) {
+          current += next;
+          index++;
+        } else {
+          quote = null;
+        }
+      }
+      continue;
+    }
+
+    if (ch == '"' || ch == '`' || ch == '[') {
+      quote = ch == '[' ? ']' : ch;
+      current += ch;
+      continue;
+    }
+    if (ch == '(') depth++;
+    if (ch == ')' && depth > 0) depth--;
+    if (ch == ',' && depth == 0) {
+      result.push(current.trim());
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+
+  if (current.trim()) result.push(current.trim());
+  return result;
+}
+
+function extractIdentifierParts(text) {
+  const identifierRegex = new RegExp(identifierPattern, 'g');
+  return (text.match(identifierRegex) || []).map(identifier => unquoteIdentifier(identifier));
+}
+
+function extractMySqlStyleViewColumnMetadata(selectSql, dbinfo) {
+  if (!selectSql) return null;
+  const selectMatch = selectSql.match(/^\s*select\s+([\s\S]+?)\s+from\s/i);
+  if (!selectMatch) return null;
+
+  const tableByAlias = {};
+  const tableRegex = new RegExp(
+    `\\b(?:from|join)\\s+\\(*\\s*(${qualifiedIdentifierPattern})(?:\\s+(?:as\\s+)?(?!\\b(?:${aliasStopWordPattern})\\b)(${identifierPattern}))?`,
+    'gi'
+  );
+  let tableMatch;
+  while ((tableMatch = tableRegex.exec(selectSql))) {
+    const tableParts = extractIdentifierParts(tableMatch[1]);
+    const alias = unquoteIdentifier(tableMatch[2]);
+    if (!tableParts.length) continue;
+    const metadata = {
+      schemaName: tableParts.length >= 2 ? tableParts[tableParts.length - 2] : undefined,
+      tableName: tableParts[tableParts.length - 1],
+    };
+    if (alias) tableByAlias[alias.toLowerCase()] = metadata;
+    tableByAlias[metadata.tableName.toLowerCase()] = metadata;
+  }
+  if (Object.keys(tableByAlias).length == 0) return null;
+
+  const result = {};
+  for (const item of splitTopLevelCommaList(selectMatch[1])) {
+    const [sourceText, aliasText] = item.split(/\s+\bas\b\s+/i);
+    if (!qualifiedIdentifierOnlyRegex.test(sourceText)) continue;
+    const sourceParts = extractIdentifierParts(sourceText);
+    if (sourceParts.length < 2) continue;
+    const sourceColumnName = sourceParts[sourceParts.length - 1];
+    const qualifier = sourceParts[sourceParts.length - 2];
+    const table = tableByAlias[qualifier.toLowerCase()];
+    if (!table) continue;
+    const aliasParts = aliasText ? extractIdentifierParts(aliasText) : [];
+    const resultColumnName = aliasParts[0] || sourceColumnName;
+    result[resultColumnName] = resolveMetadataTable(
+      {
+        ...table,
+        sourceColumnName,
+      },
+      dbinfo
+    );
+  }
+
+  return Object.keys(result).length == 0 ? null : result;
+}
+
+function resolveMetadataTable(metadata, dbinfo) {
+  if (!metadata?.tableName) return metadata;
+  const table = findTable(dbinfo, metadata.schemaName, metadata.tableName);
+  if (!table) return metadata;
+  return {
+    ...metadata,
+    tableName: table.pureName,
+    schemaName: table.schemaName,
+  };
+}
+
+function createViewColumnMetadata(view, dbinfo) {
+  const selectSql = extractSelectFromCreateView(view?.createSql);
+  if (!selectSql) return null;
+  const viewColumnNames = getViewColumnNames(view);
+  const columnMetadata = extractColumnMetadataFromSql(selectSql) || extractMySqlStyleViewColumnMetadata(selectSql, dbinfo);
+
+  if (columnMetadata && Object.keys(columnMetadata).length > 0) {
+    if (!viewColumnNames?.length) {
+      return Object.fromEntries(
+        Object.entries(columnMetadata).map(([columnName, metadata]) => [
+          columnName,
+          resolveMetadataTable(metadata, dbinfo),
+        ])
+      );
+    }
+
+    const metadataValues = Object.values(columnMetadata).map(metadata => resolveMetadataTable(metadata, dbinfo));
+    const allowPositionalFallback =
+      metadataValues.length == viewColumnNames.length && metadataValues.length == getSelectListItemCount(selectSql);
+    const result = {};
+    for (let index = 0; index < viewColumnNames.length; index++) {
+      const columnName = viewColumnNames[index];
+      const metadata = getColumnMetadata(columnMetadata, columnName);
+      const resolvedMetadata = metadata
+        ? resolveMetadataTable(metadata, dbinfo)
+        : allowPositionalFallback
+          ? metadataValues[index]
+          : null;
+      if (resolvedMetadata) result[columnName] = resolvedMetadata;
+    }
+    return result;
+  }
+
+  if (!viewColumnNames?.length || !isSelectStarFromSingleTable(selectSql)) return columnMetadata;
+  const sourceTable = extractSingleTableFromSql(selectSql);
+  const table = findTable(dbinfo, sourceTable?.schemaName, sourceTable?.tableName);
+  if (!table?.columns?.length) return columnMetadata;
+
+  const result = {};
+  for (let index = 0; index < viewColumnNames.length; index++) {
+    const sourceColumn = table.columns[index];
+    if (!sourceColumn?.columnName) continue;
+    result[viewColumnNames[index]] = {
+      tableName: table.pureName,
+      schemaName: table.schemaName,
+      sourceColumnName: sourceColumn.columnName,
+    };
+  }
+  return result;
+}
+
+function resolveViewResultColumns(columns, dbinfo) {
+  if (!columns?.length) return columns;
+  if (!dbinfo?.views?.length && !dbinfo?.matviews?.length) return columns;
+
+  return columns.map(column => {
+    const view = findView(dbinfo, column.tableSchema, column.tableName);
+    if (!view?.createSql) return column;
+
+    const columnMetadata = createViewColumnMetadata(view, dbinfo);
+    const metadata = getColumnMetadata(columnMetadata, column.columnName);
+    if (!metadata) return column;
+
+    return {
+      ...column,
+      tableName: metadata.tableName,
+      tableSchema: metadata.schemaName,
+      sourceColumnName: metadata.sourceColumnName,
+    };
+  });
+}
+
 async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, onNativeMetadataError, onFallbackMetadataError }) {
   if (!columns?.length || !driver?.databaseEngineTypes?.includes('sql') || !driver?.supportsEditableQueryResults) {
     return columns;
@@ -27,7 +289,7 @@ async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, o
 
   if (driver.enrichColumnMetadata) {
     try {
-      const enriched = await driver.enrichColumnMetadata(dbhan, sql, columns, dbinfo);
+      const enriched = resolveViewResultColumns(await driver.enrichColumnMetadata(dbhan, sql, columns, dbinfo), dbinfo);
       if (enriched?.every(column => column.tableName && column.sourceColumnName)) return enriched;
       if (enriched?.length == columns.length) columns = enriched;
     } catch (err) {
@@ -38,7 +300,7 @@ async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, o
   try {
     const columnMetadata = extractColumnMetadataFromSql(sql);
     if (columnMetadata) {
-      return columns.map(column => {
+      return resolveViewResultColumns(columns.map(column => {
         const metadata = getColumnMetadata(columnMetadata, column.columnName);
         return {
           ...column,
@@ -46,19 +308,19 @@ async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, o
           tableSchema: column.tableSchema || metadata?.schemaName,
           sourceColumnName: column.sourceColumnName || metadata?.sourceColumnName,
         };
-      });
+      }), dbinfo);
     }
 
     const table = extractSingleTableFromSql(sql);
     if (!table) return columns;
     const columnSources = extractColumnSourcesFromSql(sql);
 
-    return columns.map(column => ({
+    return resolveViewResultColumns(columns.map(column => ({
       ...column,
       tableName: column.tableName || table.tableName,
       tableSchema: column.tableSchema || table.schemaName,
       sourceColumnName: column.sourceColumnName || getColumnSourceName(columnSources, column.columnName) || column.columnName,
-    }));
+    })), dbinfo);
   } catch (err) {
     onFallbackMetadataError?.(err);
     return columns;
@@ -67,4 +329,5 @@ async function enrichQueryResultColumns({ columns, sql, driver, dbhan, dbinfo, o
 
 module.exports = {
   enrichQueryResultColumns,
+  resolveViewResultColumns,
 };