dbgate-api 7.1.13 → 7.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api",
   "main": "src/index.js",
-  "version": "7.1.13",
+  "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.1.13",
+    "dbgate-datalib": "7.2.1",
     "dbgate-query-splitter": "^4.12.0",
-    "dbgate-rest": "7.1.13",
-    "dbgate-sqltree": "7.1.13",
-    "dbgate-tools": "7.1.13",
+    "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.1.13",
+    "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}`);
   },
 
@@ -517,6 +524,21 @@ module.exports = {
     return res.result || null;
   },
 
+  saveQueryResultData_meta: true,
+  async saveQueryResultData({ conid, database, changeSet, sql }, req) {
+    await testConnectionPermission(conid, req);
+    await testDatabaseRolePermission(conid, database, 'run_script', req);
+
+    const opened = await this.ensureOpened(conid, database);
+    const res = await this.sendRequest(opened, { msgtype: 'saveQueryResultData', changeSet, sql });
+    if (res.errorMessage) {
+      return {
+        errorMessage: res.errorMessage,
+      };
+    }
+    return res.result || { state: 'ok' };
+  },
+
   multiCallMethod_meta: true,
   async multiCallMethod({ conid, database, callList }, req) {
     await testConnectionPermission(conid, req);

package/src/controllers/sessions.js

@@ -21,6 +21,7 @@ const logger = getLogger('sessions');
 module.exports = {
   /** @type {import('dbgate-types').OpenedSession[]} */
   opened: [],
+  requests: {},
 
   // handle_error(sesid, props) {
   //   const { error } = props;
@@ -115,6 +116,44 @@ module.exports = {
 
   handle_ping() {},
 
+  handle_response(sesid, props) {
+    const { msgid } = props;
+    const request = this.requests[msgid];
+    if (!request) return;
+    delete this.requests[msgid];
+    request.resolve(_.omit(props, ['msgtype', 'msgid', 'sesid']));
+  },
+
+  sendRequest(session, message) {
+    const msgid = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        session.subprocess.off('exit', handleExit);
+        delete this.requests[msgid];
+      };
+      const handleExit = () => {
+        cleanup();
+        reject(new Error('DBGM-00000 Session process exited before response was received'));
+      };
+      this.requests[msgid] = {
+        resolve: value => {
+          cleanup();
+          resolve(value);
+        },
+        reject: error => {
+          cleanup();
+          reject(error);
+        },
+      };
+      session.subprocess.once('exit', handleExit);
+      session.subprocess.send({ ...message, msgid }, err => {
+        if (err && this.requests[msgid]) {
+          this.requests[msgid].reject(err);
+        }
+      });
+    });
+  },
+
   create_meta: true,
   async create({ conid, database }) {
     const sesid = crypto.randomUUID();
@@ -202,6 +241,12 @@ module.exports = {
       message: 'Query execution started',
       sql,
     });
+    let dbinfo = null;
+    try {
+      dbinfo = (await require('./databaseConnections').ensureOpened(session.conid, session.database))?.structure;
+    } catch (err) {
+      logger.warn(extractErrorLogData(err), 'DBGM-00000 Error loading structure for query result metadata');
+    }
     session.subprocess.send({
       msgtype: 'executeQuery',
       sql,
@@ -209,6 +254,7 @@ module.exports = {
       autoDetectCharts: autoDetectCharts || !!frontMatter?.['selected-chart'],
       limitRows,
       frontMatter,
+      dbinfo,
     });
 
     return { state: 'ok' };
@@ -228,6 +274,24 @@ module.exports = {
     return { state: 'ok' };
   },
 
+  saveQueryResultData_meta: true,
+  async saveQueryResultData({ sesid, changeSet, sql, autoCommit }, req) {
+    await testStandardPermission('dbops/query', req);
+    const session = this.opened.find(x => x.sesid == sesid);
+    if (!session) {
+      throw new Error('Invalid session');
+    }
+    await testDatabaseRolePermission(session.conid, session.database, 'run_script', req);
+
+    const res = await this.sendRequest(session, { msgtype: 'saveQueryResultData', changeSet, sql, autoCommit });
+    if (res.errorMessage) {
+      return {
+        errorMessage: res.errorMessage,
+      };
+    }
+    return res.result || { state: 'ok' };
+  },
+
   setIsolationLevel_meta: true,
   async setIsolationLevel({ sesid, level }) {
     const session = this.opened.find(x => x.sesid == sesid);

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '7.1.13',
-  buildTime: '2026-05-27T11:35:48.071Z'
+  version: '7.2.1',
+  buildTime: '2026-06-19T10:21:38.466Z'
 };

package/src/proc/databaseConnectionProcess.js

@@ -19,12 +19,14 @@ const { handleProcessCommunication } = require('../utility/processComm');
 const generateDeploySql = require('../shell/generateDeploySql');
 const { dumpSqlSelect, scriptToSql } = require('dbgate-sqltree');
 const { allowExecuteCustomScript, handleQueryStream } = require('../utility/handleQueryStream');
+const { enrichQueryResultColumns } = require('../utility/queryResultMetadata');
 const dbgateApi = require('../shell');
 const requirePlugin = require('../shell/requirePlugin');
 const path = require('path');
 const { rundir } = require('../utility/directories');
 const fs = require('fs-extra');
 const { changeSetToSql } = require('dbgate-datalib');
+const _ = require('lodash');
 
 const logger = getLogger('dbconnProcess');
 
@@ -253,6 +255,9 @@ async function handleQueryData({ msgid, sql, range, commandTimeout }, skipReadon
   try {
     if (!skipReadonlyCheck) ensureExecuteCustomScript(driver);
     const res = await driver.query(dbhan, sql, { range, commandTimeout });
+    if (res?.columns) {
+      res.columns = await enrichQueryResultColumns({ dbhan, driver, sql, columns: res.columns, dbinfo: analysedStructure });
+    }
     process.send({ msgtype: 'response', msgid, ...serializeJsTypesForJsonStringify(res) });
   } catch (err) {
     process.send({
@@ -381,6 +386,55 @@ async function handleSaveTableData({ msgid, changeSet }) {
   }
 }
 
+function validateQueryResultChangeSet(driver, changeSet) {
+  if (!driver.databaseEngineTypes?.includes('sql') || !driver.supportsEditableQueryResults) {
+    throw new Error('DBGM-00000 Editable query results are not supported by this driver');
+  }
+  if (changeSet?.inserts?.length > 0 || changeSet?.deletes?.length > 0) {
+    throw new Error('DBGM-00000 Query result saving supports UPDATE operations only');
+  }
+  for (const update of changeSet?.updates || []) {
+    if (!update.pureName) {
+      throw new Error('DBGM-00000 Query result update is missing target table');
+    }
+    if (_.isEmpty(update.fields)) {
+      throw new Error('DBGM-00000 Query result update is missing changed fields');
+    }
+    if (_.isEmpty(update.condition)) {
+      throw new Error('DBGM-00000 Query result update is missing row condition');
+    }
+    if (Object.values(update.condition).some(value => value === null || value === undefined)) {
+      throw new Error('DBGM-00000 Query result update has incomplete row condition');
+    }
+  }
+}
+
+async function handleSaveQueryResultData({ msgid, changeSet, sql }) {
+  await waitConnected();
+  const driver = requireEngineDriver(storedConnection);
+  try {
+    ensureExecuteCustomScript(driver);
+    validateQueryResultChangeSet(driver, changeSet);
+    if (!sql) {
+      const script = changeSetToSql({ ...changeSet, inserts: [], deletes: [] }, null, driver.dialect);
+      if (script.some(command => command.commandType != 'update')) {
+        throw new Error('DBGM-00000 Query result saving supports UPDATE operations only');
+      }
+      sql = scriptToSql(driver, script);
+    }
+    if (sql) {
+      await driver.script(dbhan, sql, { useTransaction: false });
+    }
+    process.send({ msgtype: 'response', msgid, result: { state: 'ok' } });
+  } catch (err) {
+    process.send({
+      msgtype: 'response',
+      msgid,
+      errorMessage: extractErrorMessage(err, 'DBGM-00000 Error saving query result data'),
+    });
+  }
+}
+
 async function handleMultiCallMethod({ msgid, callList }) {
   try {
     const driver = requireEngineDriver(storedConnection);
@@ -557,7 +611,7 @@ async function handleExecuteSessionQuery({ sesid, sql }) {
     ...driver.getQuerySplitterOptions('stream'),
     returnRichInfo: true,
   })) {
-    await handleQueryStream(dbhan, driver, queryStreamInfoHolder, sqlItem, sesid);
+    await handleQueryStream(dbhan, driver, queryStreamInfoHolder, sqlItem, sesid, undefined, undefined, false, analysedStructure);
     if (queryStreamInfoHolder.canceled) {
       break;
     }
@@ -569,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);
   }
@@ -599,6 +690,7 @@ const messageHandlers = {
   runOperation: handleRunOperation,
   updateCollection: handleUpdateCollection,
   saveTableData: handleSaveTableData,
+  saveQueryResultData: handleSaveQueryResultData,
   collectionData: handleCollectionData,
   loadKeys: handleLoadKeys,
   scanKeys: handleScanKeys,

package/src/proc/sessionProcess.js

@@ -10,7 +10,9 @@ const requireEngineDriver = require('../utility/requireEngineDriver');
 const { decryptConnection } = require('../utility/crypting');
 const { connectUtility } = require('../utility/connectUtility');
 const { handleProcessCommunication } = require('../utility/processComm');
-const { getLogger, extractIntSettingsValue, extractBoolSettingsValue } = require('dbgate-tools');
+const { getLogger, extractIntSettingsValue, extractBoolSettingsValue, extractErrorMessage } = require('dbgate-tools');
+const { changeSetToSql } = require('dbgate-datalib');
+const { scriptToSql } = require('dbgate-sqltree');
 const { handleQueryStream, QueryStreamTableWriter, allowExecuteCustomScript } = require('../utility/handleQueryStream');
 
 const logger = getLogger('sessionProcess');
@@ -119,7 +121,7 @@ async function handleExecuteControlCommand({ command }) {
     process.send({
       msgtype: 'info',
       info: {
-        message: 'Connection without read-only sessions is read only',
+        message: 'Connection is read-only',
         severity: 'error',
       },
     });
@@ -149,7 +151,7 @@ async function handleExecuteControlCommand({ command }) {
   }
 }
 
-async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows, frontMatter }) {
+async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows, frontMatter, dbinfo }) {
   lastActivity = new Date().getTime();
 
   await waitConnected();
@@ -159,7 +161,7 @@ async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows
     process.send({
       msgtype: 'info',
       info: {
-        message: 'Connection without read-only sessions is read only',
+        message: 'Connection is read-only',
         severity: 'error',
       },
     });
@@ -186,7 +188,8 @@ async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows
         undefined,
         limitRows,
         frontMatter,
-        autoDetectCharts
+        autoDetectCharts,
+        dbinfo
       );
       // const handler = new StreamHandler(resultIndex);
       // const stream = await driver.stream(systemConnection, sqlItem, handler);
@@ -203,6 +206,69 @@ async function handleExecuteQuery({ sql, autoCommit, autoDetectCharts, limitRows
   }
 }
 
+function validateQueryResultChangeSet(driver, changeSet) {
+  if (!driver.databaseEngineTypes?.includes('sql') || !driver.supportsEditableQueryResults) {
+    throw new Error('DBGM-00000 Editable query results are not supported by this driver');
+  }
+  if (changeSet?.inserts?.length > 0 || changeSet?.deletes?.length > 0) {
+    throw new Error('DBGM-00000 Query result saving supports UPDATE operations only');
+  }
+  for (const update of changeSet?.updates || []) {
+    if (!update.pureName) {
+      throw new Error('DBGM-00000 Query result update is missing target table');
+    }
+    if (_.isEmpty(update.fields)) {
+      throw new Error('DBGM-00000 Query result update is missing changed fields');
+    }
+    if (_.isEmpty(update.condition)) {
+      throw new Error('DBGM-00000 Query result update is missing row condition');
+    }
+    if (Object.values(update.condition).some(value => value === null || value === undefined)) {
+      throw new Error('DBGM-00000 Query result update has incomplete row condition');
+    }
+  }
+}
+
+async function handleSaveQueryResultData({ msgid, changeSet, sql, autoCommit }) {
+  lastActivity = new Date().getTime();
+
+  await waitConnected();
+  const driver = requireEngineDriver(storedConnection);
+  try {
+    if (!allowExecuteCustomScript(storedConnection, driver)) {
+      throw new Error('DBGM-00000 Connection is read-only');
+    }
+    validateQueryResultChangeSet(driver, changeSet);
+    if (!sql) {
+      const script = changeSetToSql({ ...changeSet, inserts: [], deletes: [] }, null, driver.dialect);
+      if (script.some(command => command.commandType != 'update')) {
+        throw new Error('DBGM-00000 Query result saving supports UPDATE operations only');
+      }
+      sql = scriptToSql(driver, script);
+    }
+    if (sql) {
+      executingScripts++;
+      try {
+        await driver.script(dbhan, sql, { useTransaction: false });
+        if (autoCommit) {
+          const dmp = driver.createDumper();
+          dmp.commitTransaction();
+          await driver.query(dbhan, dmp.s, { discardResult: true });
+        }
+      } finally {
+        executingScripts--;
+      }
+    }
+    process.send({ msgtype: 'response', msgid, result: { state: 'ok' } });
+  } catch (err) {
+    process.send({
+      msgtype: 'response',
+      msgid,
+      errorMessage: extractErrorMessage(err, 'DBGM-00000 Error saving query result data'),
+    });
+  }
+}
+
 async function handleExecuteReader({ jslid, sql, fileName }) {
   lastActivity = new Date().getTime();
 
@@ -224,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() {
@@ -244,6 +327,7 @@ const messageHandlers = {
   executeControlCommand: handleExecuteControlCommand,
   setIsolationLevel: handleSetIsolationLevel,
   executeReader: handleExecuteReader,
+  saveQueryResultData: handleSaveQueryResultData,
   startProfiler: handleStartProfiler,
   stopProfiler: handleStopProfiler,
   ping: 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/handleQueryStream.js

@@ -4,9 +4,12 @@ const fs = require('fs');
 const _ = require('lodash');
 
 const { jsldir } = require('../utility/directories');
-const { serializeJsTypesReplacer } = require('dbgate-tools');
+const { serializeJsTypesReplacer, getLogger } = require('dbgate-tools');
 const { ChartProcessor } = require('dbgate-datalib');
 const { isProApp } = require('./checkLicense');
+const { enrichQueryResultColumns } = require('./queryResultMetadata');
+
+const logger = getLogger('handleQueryStream');
 
 class QueryStreamTableWriter {
   constructor(sesid = undefined) {
@@ -144,13 +147,21 @@ class StreamHandler {
     sesid = undefined,
     limitRows = undefined,
     frontMatter = undefined,
-    autoDetectCharts = false
+    autoDetectCharts = false,
+    supportsEditableQueryResults = false,
+    dbhan = null,
+    driver = null,
+    dbinfo = null
   ) {
     this.recordset = this.recordset.bind(this);
     this.startLine = startLine;
     this.sesid = sesid;
     this.frontMatter = frontMatter;
     this.autoDetectCharts = autoDetectCharts;
+    this.supportsEditableQueryResults = supportsEditableQueryResults;
+    this.dbhan = dbhan;
+    this.driver = driver;
+    this.dbinfo = dbinfo;
     this.limitRows = limitRows;
     this.rowsLimitOverflow = false;
     this.row = this.row.bind(this);
@@ -165,7 +176,8 @@ class StreamHandler {
     this.plannedStats = false;
     this.queryStreamInfoHolder = queryStreamInfoHolder;
     this.resolve = resolve;
-    this.rowCounter = 0;
+    this.currentRecordset = null;
+    this.recordsetQueuePromise = Promise.resolve();
     // currentHandlers = [...currentHandlers, this];
   }
 
@@ -180,21 +192,37 @@ class StreamHandler {
     process.send({ msgtype: 'changedCurrentDatabase', database, sesid: this.sesid });
   }
 
-  recordset(columns, options) {
+  async prepareRecordset(recordsetContext, columns, options) {
     if (this.rowsLimitOverflow) {
       return;
     }
     this.closeCurrentWriter();
-    this.currentWriter = new QueryStreamTableWriter(this.sesid);
-    this.currentWriter.initializeFromQuery(
-      Array.isArray(columns) ? { columns } : columns,
-      this.queryStreamInfoHolder.resultIndex,
-      this.frontMatter?.[`chart-${this.queryStreamInfoHolder.resultIndex + 1}`],
+    const writer = new QueryStreamTableWriter(this.sesid);
+    const structure = Array.isArray(columns) ? { columns } : columns;
+    const enrichedColumns = await enrichQueryStreamColumns(
+      structure?.columns,
+      this.sql,
+      this.supportsEditableQueryResults,
+      this.driver,
+      this.dbhan,
+      this.dbinfo
+    );
+    writer.initializeFromQuery(
+      {
+        ...structure,
+        columns: enrichedColumns,
+      },
+      recordsetContext.resultIndex,
+      this.frontMatter?.[`chart-${recordsetContext.resultIndex + 1}`],
       this.autoDetectCharts,
       options
     );
-    this.queryStreamInfoHolder.resultIndex += 1;
-    this.rowCounter = 0;
+    recordsetContext.writer = writer;
+    this.currentWriter = writer;
+    for (const row of recordsetContext.pendingRows) {
+      this.writeRow(recordsetContext, row, false);
+    }
+    recordsetContext.pendingRows = [];
 
     // this.writeCurrentStats();
 
@@ -204,15 +232,50 @@ class StreamHandler {
     //   }
     // }, 500);
   }
+
+  recordset(columns, options) {
+    const recordsetContext = {
+      pendingRows: [],
+      resultIndex: this.queryStreamInfoHolder.resultIndex,
+      rowCounter: 0,
+      writer: null,
+    };
+    this.queryStreamInfoHolder.resultIndex += 1;
+    this.currentRecordset = recordsetContext;
+
+    const recordsetReadyPromise = this.recordsetQueuePromise
+      .then(() => this.prepareRecordset(recordsetContext, columns, options))
+      .catch(err => {
+        recordsetContext.pendingRows = [];
+        this.info({
+          message: err?.message || `${err}`,
+          severity: 'error',
+        });
+      })
+      .finally(() => {
+        if (this.recordsetReadyPromise == recordsetReadyPromise) {
+          this.recordsetReadyPromise = null;
+        }
+      });
+    this.recordsetReadyPromise = recordsetReadyPromise;
+    this.recordsetQueuePromise = recordsetReadyPromise;
+  }
+
+  writeRow(recordsetContext, row, incrementCounter = true) {
+    recordsetContext.writer.row(row);
+    if (incrementCounter) recordsetContext.rowCounter += 1;
+  }
+
   row(row) {
     if (this.rowsLimitOverflow) {
       return;
     }
 
-    if (this.limitRows && this.rowCounter >= this.limitRows) {
+    const recordsetContext = this.currentRecordset;
+    if (this.limitRows && recordsetContext?.rowCounter >= this.limitRows) {
       process.send({
         msgtype: 'info',
-        info: { message: `Rows limit overflow, loaded ${this.rowCounter} rows, canceling query`, severity: 'error' },
+        info: { message: `Rows limit overflow, loaded ${recordsetContext.rowCounter} rows, canceling query`, severity: 'error' },
         sesid: this.sesid,
       });
       this.rowsLimitOverflow = true;
@@ -229,9 +292,11 @@ class StreamHandler {
       return;
     }
 
-    if (this.currentWriter) {
-      this.currentWriter.row(row);
-      this.rowCounter += 1;
+    if (recordsetContext?.writer) {
+      this.writeRow(recordsetContext, row);
+    } else if (recordsetContext) {
+      recordsetContext.pendingRows.push(row);
+      recordsetContext.rowCounter += 1;
     } else if (row.message) {
       process.send({ msgtype: 'info', info: { message: row.message }, sesid: this.sesid });
     }
@@ -241,9 +306,12 @@ class StreamHandler {
   //   process.send({ msgtype: 'error', error });
   // }
   done(result) {
-    this.closeCurrentWriter();
-    // currentHandlers = currentHandlers.filter((x) => x != this);
-    this.resolve();
+    const finish = () => {
+      this.closeCurrentWriter();
+      // currentHandlers = currentHandlers.filter((x) => x != this);
+      this.resolve();
+    };
+    this.recordsetQueuePromise.then(finish);
   }
   info(info) {
     if (info && info.line != null) {
@@ -259,6 +327,19 @@ class StreamHandler {
   }
 }
 
+async function enrichQueryStreamColumns(columns, sql, supportsEditableQueryResults, driver, dbhan, dbinfo) {
+  if (!supportsEditableQueryResults) return columns;
+  return enrichQueryResultColumns({
+    columns,
+    sql,
+    driver,
+    dbhan,
+    dbinfo,
+    onNativeMetadataError: err => logger.warn('Error enriching query stream columns', err),
+    onFallbackMetadataError: err => logger.warn('Error parsing query stream column metadata', err),
+  });
+}
+
 function handleQueryStream(
   dbhan,
   driver,
@@ -267,7 +348,8 @@ function handleQueryStream(
   sesid = undefined,
   limitRows = undefined,
   frontMatter = undefined,
-  autoDetectCharts = false
+  autoDetectCharts = false,
+  dbinfo = null
 ) {
   return new Promise((resolve, reject) => {
     const start = sqlItem.trimStart || sqlItem.start;
@@ -278,8 +360,13 @@ function handleQueryStream(
       sesid,
       limitRows,
       frontMatter,
-      autoDetectCharts
+      autoDetectCharts,
+      driver.databaseEngineTypes?.includes('sql') && driver.supportsEditableQueryResults,
+      dbhan,
+      driver,
+      dbinfo
     );
+    handler.sql = sqlItem.text;
     driver.stream(dbhan, sqlItem.text, handler);
   });
 }

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

@@ -0,0 +1,333 @@
+const {
+  extractSingleTableFromSql,
+  extractColumnSourcesFromSql,
+  extractColumnMetadataFromSql,
+} = require('dbgate-tools');
+
+function getColumnSourceName(columnSources, columnName) {
+  if (!columnSources || !columnName) return null;
+  if (columnSources[columnName]) return columnSources[columnName];
+
+  const matchingKeys = Object.keys(columnSources).filter(key => key.toLowerCase() == columnName.toLowerCase());
+  return matchingKeys.length == 1 ? columnSources[matchingKeys[0]] : null;
+}
+
+function getColumnMetadata(columnMetadata, columnName) {
+  if (!columnMetadata || !columnName) return null;
+  if (columnMetadata[columnName]) return columnMetadata[columnName];
+
+  const matchingKeys = Object.keys(columnMetadata).filter(key => key.toLowerCase() == columnName.toLowerCase());
+  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;
+  }
+
+  if (driver.enrichColumnMetadata) {
+    try {
+      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) {
+      onNativeMetadataError?.(err);
+    }
+  }
+
+  try {
+    const columnMetadata = extractColumnMetadataFromSql(sql);
+    if (columnMetadata) {
+      return resolveViewResultColumns(columns.map(column => {
+        const metadata = getColumnMetadata(columnMetadata, column.columnName);
+        return {
+          ...column,
+          tableName: column.tableName || metadata?.tableName,
+          tableSchema: column.tableSchema || metadata?.schemaName,
+          sourceColumnName: column.sourceColumnName || metadata?.sourceColumnName,
+        };
+      }), dbinfo);
+    }
+
+    const table = extractSingleTableFromSql(sql);
+    if (!table) return columns;
+    const columnSources = extractColumnSourcesFromSql(sql);
+
+    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;
+  }
+}
+
+module.exports = {
+  enrichQueryResultColumns,
+  resolveViewResultColumns,
+};