dbgate-api 6.5.4 → 6.5.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api",
   "main": "src/index.js",
-  "version": "6.5.4",
+  "version": "6.5.5",
   "homepage": "https://dbgate.org/",
   "repository": {
     "type": "git",
@@ -30,10 +30,10 @@
     "compare-versions": "^3.6.0",
     "cors": "^2.8.5",
     "cross-env": "^6.0.3",
-    "dbgate-datalib": "^6.5.4",
+    "dbgate-datalib": "^6.5.5",
     "dbgate-query-splitter": "^4.11.5",
-    "dbgate-sqltree": "^6.5.4",
-    "dbgate-tools": "^6.5.4",
+    "dbgate-sqltree": "^6.5.5",
+    "dbgate-tools": "^6.5.5",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -85,7 +85,7 @@
   "devDependencies": {
     "@types/fs-extra": "^9.0.11",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "^6.5.4",
+    "dbgate-types": "^6.5.5",
     "env-cmd": "^10.1.0",
     "jsdoc-to-markdown": "^9.0.5",
     "node-loader": "^1.0.2",

package/src/auth/authProvider.js

@@ -11,7 +11,7 @@ const logger = getLogger('authProvider');
 class AuthProviderBase {
   amoid = 'none';
 
-  async login(login, password, options = undefined) {
+  async login(login, password, options = undefined, req = undefined) {
     return {
       accessToken: jwt.sign(
         {
@@ -23,7 +23,7 @@ class AuthProviderBase {
     };
   }
 
-  oauthToken(params) {
+  oauthToken(params, req) {
     return {};
   }
 

package/src/controllers/auth.js

@@ -13,8 +13,15 @@ const {
 } = require('../auth/authProvider');
 const storage = require('./storage');
 const { decryptPasswordString } = require('../utility/crypting');
-const { createDbGateIdentitySession, startCloudTokenChecking } = require('../utility/cloudIntf');
+const {
+  createDbGateIdentitySession,
+  startCloudTokenChecking,
+  readCloudTokenHolder,
+  readCloudTestTokenHolder,
+} = require('../utility/cloudIntf');
 const socket = require('../utility/socket');
+const { sendToAuditLog } = require('../utility/auditlog');
+const { isLoginLicensed, LOGIN_LIMIT_ERROR } = require('../utility/loginchecker');
 
 const logger = getLogger('auth');
 
@@ -72,6 +79,8 @@ function authMiddleware(req, res, next) {
   try {
     const decoded = jwt.verify(token, getTokenSecret());
     req.user = decoded;
+    storage.markUserAsActive(decoded.licenseUid);
+
     return next();
   } catch (err) {
     if (skipAuth) {
@@ -87,12 +96,12 @@ function authMiddleware(req, res, next) {
 
 module.exports = {
   oauthToken_meta: true,
-  async oauthToken(params) {
+  async oauthToken(params, req) {
     const { amoid } = params;
-    return getAuthProviderById(amoid).oauthToken(params);
+    return getAuthProviderById(amoid).oauthToken(params, req);
   },
   login_meta: true,
-  async login(params) {
+  async login(params, req) {
     const { amoid, login, password, isAdminPage } = params;
 
     if (isAdminPage) {
@@ -102,12 +111,26 @@ module.exports = {
         adminPassword = decryptPasswordString(adminConfig?.adminPassword);
       }
       if (adminPassword && adminPassword == password) {
+        if (!(await isLoginLicensed(req, `superadmin`))) {
+          return { error: LOGIN_LIMIT_ERROR };
+        }
+
+        sendToAuditLog(req, {
+          category: 'auth',
+          component: 'AuthController',
+          action: 'login',
+          event: 'login.admin',
+          severity: 'info',
+          message: 'Administration login successful',
+        });
+
         return {
           accessToken: jwt.sign(
             {
               login: 'superadmin',
               permissions: await storage.loadSuperadminPermissions(),
               roleId: -3,
+              licenseUid: `superadmin`,
             },
             getTokenSecret(),
             {
@@ -117,10 +140,19 @@ module.exports = {
         };
       }
 
+      sendToAuditLog(req, {
+        category: 'auth',
+        component: 'AuthController',
+        action: 'loginFail',
+        event: 'login.adminFailed',
+        severity: 'warn',
+        message: 'Administraton login failed',
+      });
+
       return { error: 'Login failed' };
     }
 
-    return getAuthProviderById(amoid).login(login, password);
+    return getAuthProviderById(amoid).login(login, password, undefined, req);
   },
 
   getProviders_meta: true,
@@ -138,8 +170,8 @@ module.exports = {
   },
 
   createCloudLoginSession_meta: true,
-  async createCloudLoginSession({ client }) {
-    const res = await createDbGateIdentitySession(client);
+  async createCloudLoginSession({ client, redirectUri }) {
+    const res = await createDbGateIdentitySession(client, redirectUri);
     startCloudTokenChecking(res.sid, tokenHolder => {
       socket.emit('got-cloud-token', tokenHolder);
       socket.emitChanged('cloud-content-changed');
@@ -148,5 +180,17 @@ module.exports = {
     return res;
   },
 
+  cloudLoginRedirected_meta: true,
+  async cloudLoginRedirected({ sid }) {
+    const tokenHolder = await readCloudTokenHolder(sid);
+    return tokenHolder;
+  },
+
+  cloudTestLogin_meta: true,
+  async cloudTestLogin({ email }) {
+    const tokenHolder = await readCloudTestTokenHolder(email);
+    return tokenHolder;
+  },
+
   authMiddleware,
 };

package/src/controllers/cloud.js

@@ -258,4 +258,22 @@ module.exports = {
     await fs.writeFile(filePath, content);
     return true;
   },
+
+  folderUsers_meta: true,
+  async folderUsers({ folid }) {
+    const resp = await callCloudApiGet(`content-folders/users/${folid}`);
+    return resp;
+  },
+
+  setFolderUserRole_meta: true,
+  async setFolderUserRole({ folid, email, role }) {
+    const resp = await callCloudApiPost(`content-folders/set-user-role/${folid}`, { email, role });
+    return resp;
+  },
+
+  removeFolderUser_meta: true,
+  async removeFolderUser({ folid, email }) {
+    const resp = await callCloudApiPost(`content-folders/remove-user/${folid}`, { email });
+    return resp;
+  },
 };

package/src/controllers/config.js

@@ -29,6 +29,7 @@ const {
 } = require('../utility/crypting');
 
 const lock = new AsyncLock();
+let cachedSettingsValue = null;
 
 module.exports = {
   // settingsValue: {},
@@ -118,6 +119,7 @@ module.exports = {
       supportCloudAutoUpgrade: !!process.env.CLOUD_UPGRADE_FILE,
       allowPrivateCloud: platformInfo.isElectron || !!process.env.ALLOW_DBGATE_PRIVATE_CLOUD,
       ...currentVersion,
+      redirectToDbGateCloudLogin: !!process.env.REDIRECT_TO_DBGATE_CLOUD_LOGIN,
     };
 
     return configResult;
@@ -144,6 +146,13 @@ module.exports = {
     return res;
   },
 
+  async getCachedSettings() {
+    if (!cachedSettingsValue) {
+      cachedSettingsValue = await this.loadSettings();
+    }
+    return cachedSettingsValue;
+  },
+
   deleteSettings_meta: true,
   async deleteSettings() {
     await fs.unlink(path.join(datadir(), processArgs.runE2eTests ? 'settings-e2etests.json' : 'settings.json'));
@@ -257,6 +266,7 @@ module.exports = {
   updateSettings_meta: true,
   async updateSettings(values, req) {
     if (!hasPermission(`settings/change`, req)) return false;
+    cachedSettingsValue = null;
 
     const res = await lock.acquire('settings', async () => {
       const currentValue = await this.loadSettings();
@@ -265,7 +275,11 @@ module.exports = {
         if (process.env.STORAGE_DATABASE) {
           updated = {
             ...currentValue,
-            ...values,
+            ..._.mapValues(values, v => {
+              if (v === true) return 'true';
+              if (v === false) return 'false';
+              return v;
+            }),
           };
           await storage.writeConfig({
             group: 'settings',
@@ -303,7 +317,7 @@ module.exports = {
       const resp = await axios.default.get('https://raw.githubusercontent.com/dbgate/dbgate/master/CHANGELOG.md');
       return resp.data;
     } catch (err) {
-      return ''
+      return '';
     }
   },
 

package/src/controllers/connections.js

@@ -536,14 +536,14 @@ module.exports = {
   },
 
   dbloginAuthToken_meta: true,
-  async dbloginAuthToken({ amoid, code, conid, redirectUri, sid }) {
+  async dbloginAuthToken({ amoid, code, conid, redirectUri, sid }, req) {
     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 });
+      const resp = await authProvider.login(null, null, { conid: volatile._id }, req);
       return resp;
     } catch (err) {
       logger.error(extractErrorLogData(err), 'Error getting DB token');
@@ -552,18 +552,18 @@ module.exports = {
   },
 
   dbloginAuth_meta: true,
-  async dbloginAuth({ amoid, conid, user, password }) {
+  async dbloginAuth({ amoid, conid, user, password }, req) {
     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 });
+        const loginResp = await getAuthProviderById(amoid).login(user, password, { conid: saveResp._id }, req);
         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 });
+    const loginResp = await getAuthProviderById(amoid).login(null, null, { conid }, req);
     return loginResp;
   },
 

package/src/controllers/databaseConnections.js

@@ -41,6 +41,7 @@ const { decryptConnection } = require('../utility/crypting');
 const { getSshTunnel } = require('../utility/sshTunnel');
 const sessions = require('./sessions');
 const jsldata = require('./jsldata');
+const { sendToAuditLog } = require('../utility/auditlog');
 
 const logger = getLogger('databaseConnections');
 
@@ -83,8 +84,11 @@ module.exports = {
     }
   },
   handle_response(conid, database, { msgid, ...response }) {
-    const [resolve, reject] = this.requests[msgid];
+    const [resolve, reject, additionalData] = this.requests[msgid];
     resolve(response);
+    if (additionalData?.auditLogger) {
+      additionalData?.auditLogger(response);
+    }
     delete this.requests[msgid];
   },
   handle_status(conid, database, { status }) {
@@ -215,10 +219,10 @@ module.exports = {
   },
 
   /** @param {import('dbgate-types').OpenedDatabaseConnection} conn */
-  sendRequest(conn, message) {
+  sendRequest(conn, message, additionalData = {}) {
     const msgid = crypto.randomUUID();
     const promise = new Promise((resolve, reject) => {
-      this.requests[msgid] = [resolve, reject];
+      this.requests[msgid] = [resolve, reject, additionalData];
       try {
         conn.subprocess.send({ msgid, ...message });
       } catch (err) {
@@ -242,18 +246,57 @@ module.exports = {
   },
 
   sqlSelect_meta: true,
-  async sqlSelect({ conid, database, select }, req) {
+  async sqlSelect({ conid, database, select, auditLogSessionGroup }, req) {
     testConnectionPermission(conid, req);
     const opened = await this.ensureOpened(conid, database);
-    const res = await this.sendRequest(opened, { msgtype: 'sqlSelect', select });
+    const res = await this.sendRequest(
+      opened,
+      { msgtype: 'sqlSelect', select },
+      {
+        auditLogger:
+          auditLogSessionGroup && select?.from?.name?.pureName
+            ? response => {
+                sendToAuditLog(req, {
+                  category: 'dbop',
+                  component: 'DatabaseConnectionsController',
+                  event: 'sql.select',
+                  action: 'select',
+                  severity: 'info',
+                  conid,
+                  database,
+                  schemaName: select?.from?.name?.schemaName,
+                  pureName: select?.from?.name?.pureName,
+                  sumint1: response?.rows?.length,
+                  sessionParam: `${conid}::${database}::${select?.from?.name?.schemaName || '0'}::${
+                    select?.from?.name?.pureName
+                  }`,
+                  sessionGroup: auditLogSessionGroup,
+                  message: `Loaded table data from ${select?.from?.name?.pureName}`,
+                });
+              }
+            : null,
+      }
+    );
     return res;
   },
 
   runScript_meta: true,
-  async runScript({ conid, database, sql, useTransaction }, req) {
+  async runScript({ conid, database, sql, useTransaction, logMessage }, req) {
     testConnectionPermission(conid, req);
     logger.info({ conid, database, sql }, 'Processing script');
     const opened = await this.ensureOpened(conid, database);
+    sendToAuditLog(req, {
+      category: 'dbop',
+      component: 'DatabaseConnectionsController',
+      event: 'sql.runscript',
+      action: 'runscript',
+      severity: 'info',
+      conid,
+      database,
+      detail: sql,
+      message: logMessage || `Running SQL script`,
+    });
+
     const res = await this.sendRequest(opened, { msgtype: 'runScript', sql, useTransaction });
     return res;
   },
@@ -262,16 +305,53 @@ module.exports = {
   async runOperation({ conid, database, operation, useTransaction }, req) {
     testConnectionPermission(conid, req);
     logger.info({ conid, database, operation }, 'Processing operation');
+
+    sendToAuditLog(req, {
+      category: 'dbop',
+      component: 'DatabaseConnectionsController',
+      event: 'sql.runoperation',
+      action: operation.type,
+      severity: 'info',
+      conid,
+      database,
+      detail: operation,
+      message: `Running DB operation: ${operation.type}`,
+    });
+
     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) {
+  async collectionData({ conid, database, options, auditLogSessionGroup }, req) {
     testConnectionPermission(conid, req);
     const opened = await this.ensureOpened(conid, database);
-    const res = await this.sendRequest(opened, { msgtype: 'collectionData', options });
+    const res = await this.sendRequest(
+      opened,
+      { msgtype: 'collectionData', options },
+      {
+        auditLogger:
+          auditLogSessionGroup && options?.pureName
+            ? response => {
+                sendToAuditLog(req, {
+                  category: 'dbop',
+                  component: 'DatabaseConnectionsController',
+                  event: 'nosql.collectionData',
+                  action: 'select',
+                  severity: 'info',
+                  conid,
+                  database,
+                  pureName: options?.pureName,
+                  sumint1: response?.result?.rows?.length,
+                  sessionParam: `${conid}::${database}::${options?.pureName}`,
+                  sessionGroup: auditLogSessionGroup,
+                  message: `Loaded collection data ${options?.pureName}`,
+                });
+              }
+            : null,
+      }
+    );
     return res.result || null;
   },
 
@@ -492,6 +572,20 @@ module.exports = {
     }
 
     const opened = await this.ensureOpened(conid, database);
+
+    sendToAuditLog(req, {
+      category: 'dbop',
+      component: 'DatabaseConnectionsController',
+      action: 'structure',
+      event: 'dbStructure.get',
+      severity: 'info',
+      conid,
+      database,
+      sessionParam: `${conid}::${database}`,
+      sessionGroup: 'getStructure',
+      message: `Loaded database structure for ${database}`,
+    });
+
     return opened.structure;
     // const existing = this.opened.find((x) => x.conid == conid && x.database == database);
     // if (existing) return existing.status;

package/src/controllers/files.js

@@ -203,10 +203,10 @@ module.exports = {
   },
 
   exportChart_meta: true,
-  async exportChart({ filePath, title, config, image }) {
+  async exportChart({ filePath, title, config, image, plugins }) {
     const fileName = path.parse(filePath).base;
     const imageFile = fileName.replace('.html', '-preview.png');
-    const html = getChartExport(title, config, imageFile);
+    const html = getChartExport(title, config, imageFile, plugins);
     await fs.writeFile(filePath, html);
     if (image) {
       const index = image.indexOf('base64,');

package/src/controllers/runners.js

@@ -20,6 +20,7 @@ const { handleProcessCommunication } = require('../utility/processComm');
 const processArgs = require('../utility/processArgs');
 const platformInfo = require('../utility/platformInfo');
 const { checkSecureDirectories, checkSecureDirectoriesInScript } = require('../utility/security');
+const { sendToAuditLog, logJsonRunnerScript } = require('../utility/auditlog');
 const logger = getLogger('runners');
 
 function extractPlugins(script) {
@@ -270,7 +271,7 @@ module.exports = {
   },
 
   start_meta: true,
-  async start({ script }) {
+  async start({ script }, req) {
     const runid = crypto.randomUUID();
 
     if (script.type == 'json') {
@@ -280,14 +281,36 @@ module.exports = {
         }
       }
 
+      logJsonRunnerScript(req, script);
+
       const js = await jsonScriptToJavascript(script);
       return this.startCore(runid, scriptTemplate(js, false));
     }
 
     if (!platformInfo.allowShellScripting) {
+      sendToAuditLog(req, {
+        category: 'shell',
+        component: 'RunnersController',
+        event: 'script.runFailed',
+        action: 'script',
+        severity: 'warn',
+        detail: script,
+        message: 'Scripts are not allowed',
+      });
+
       return { errorMessage: 'Shell scripting is not allowed' };
     }
 
+    sendToAuditLog(req, {
+      category: 'shell',
+      component: 'RunnersController',
+      event: 'script.run.shell',
+      action: 'script',
+      severity: 'info',
+      detail: script,
+      message: 'Running JS script',
+    });
+
     return this.startCore(runid, scriptTemplate(script, false));
   },
 

package/src/controllers/serverConnections.js

@@ -12,6 +12,7 @@ const { testConnectionPermission } = require('../utility/hasPermission');
 const { MissingCredentialsError } = require('../utility/exceptions');
 const pipeForkLogs = require('../utility/pipeForkLogs');
 const { getLogger, extractErrorLogData } = require('dbgate-tools');
+const { sendToAuditLog } = require('../utility/auditlog');
 
 const logger = getLogger('serverConnection');
 
@@ -145,6 +146,17 @@ module.exports = {
     if (conid == '__model') return [];
     testConnectionPermission(conid, req);
     const opened = await this.ensureOpened(conid);
+    sendToAuditLog(req, {
+      category: 'serverop',
+      component: 'ServerConnectionsController',
+      action: 'listDatabases',
+      event: 'databases.list',
+      severity: 'info',
+      conid,
+      sessionParam: `${conid}`,
+      sessionGroup: 'listDatabases',
+      message: `Loaded databases for connection`,
+    });
     return opened?.databases ?? [];
   },
 

package/src/controllers/sessions.js

@@ -11,6 +11,7 @@ const { appdir } = require('../utility/directories');
 const { getLogger, extractErrorLogData } = require('dbgate-tools');
 const pipeForkLogs = require('../utility/pipeForkLogs');
 const config = require('./config');
+const { sendToAuditLog } = require('../utility/auditlog');
 
 const logger = getLogger('sessions');
 
@@ -146,12 +147,24 @@ module.exports = {
   },
 
   executeQuery_meta: true,
-  async executeQuery({ sesid, sql, autoCommit, autoDetectCharts, limitRows, frontMatter }) {
+  async executeQuery({ sesid, sql, autoCommit, autoDetectCharts, limitRows, frontMatter }, req) {
     const session = this.opened.find(x => x.sesid == sesid);
     if (!session) {
       throw new Error('Invalid session');
     }
 
+    sendToAuditLog(req, {
+      category: 'dbop',
+      component: 'SessionController',
+      action: 'executeQuery',
+      event: 'query.execute',
+      severity: 'info',
+      detail: sql,
+      conid: session.conid,
+      database: session.database,
+      message: 'Executing query',
+    });
+
     logger.info({ sesid, sql }, 'Processing query');
     this.dispatchMessage(sesid, 'Query execution started');
     session.subprocess.send({

package/src/controllers/storage.js

@@ -31,9 +31,16 @@ module.exports = {
     return {};
   },
 
+  sendAuditLog_meta: true,
+  async sendAuditLog({}) {
+    return null;
+  },
+
   startRefreshLicense() {},
 
   async getUsedEngines() {
     return null;
   },
+
+  markUserAsActive(licenseUid) {},
 };

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '6.5.4',
-  buildTime: '2025-06-20T15:05:12.349Z'
+  version: '6.5.5',
+  buildTime: '2025-07-04T07:10:46.574Z'
 };

package/src/shell/deployDb.js

@@ -14,7 +14,7 @@ const crypto = require('crypto');
  * @param {object} options.driver - driver object. If not provided, it will be loaded from connection
  * @param {object} options.analysedStructure - analysed structure of the database. If not provided, it will be loaded
  * @param {string} options.modelFolder - folder with model files (YAML files for tables, SQL files for views, procedures, ...)
- * @param {import('dbgate-tools').DatabaseModelFile[]} options.loadedDbModel - loaded database model - collection of yaml and SQL files loaded into array
+ * @param {import('dbgate-tools').DatabaseModelFile[] | import('dbgate-types').DatabaseInfo} options.loadedDbModel - loaded database model - collection of yaml and SQL files loaded into array
  * @param {function[]} options.modelTransforms - array of functions for transforming model
  * @param {object} options.dbdiffOptionsExtra - extra options for dbdiff
  * @param {string} options.ignoreNameRegex - regex for ignoring objects by name

package/src/shell/generateDeploySql.js

@@ -23,7 +23,7 @@ const { connectUtility } = require('../utility/connectUtility');
  * @param {object} options.driver - driver object. If not provided, it will be loaded from connection
  * @param {object} options.analysedStructure - analysed structure of the database. If not provided, it will be loaded
  * @param {string} options.modelFolder - folder with model files (YAML files for tables, SQL files for views, procedures, ...)
- * @param {import('dbgate-tools').DatabaseModelFile[]} options.loadedDbModel - loaded database model - collection of yaml and SQL files loaded into array
+ * @param {import('dbgate-tools').DatabaseModelFile[] | import('dbgate-types').DatabaseInfo} options.loadedDbModel - loaded database model - collection of yaml and SQL files loaded into array
  * @param {function[]} options.modelTransforms - array of functions for transforming model
  * @param {object} options.dbdiffOptionsExtra - extra options for dbdiff
  * @param {string} options.ignoreNameRegex - regex for ignoring objects by name

package/src/shell/importDbFromFolder.js

@@ -3,7 +3,7 @@ const fs = require('fs-extra');
 const executeQuery = require('./executeQuery');
 const { connectUtility } = require('../utility/connectUtility');
 const requireEngineDriver = require('../utility/requireEngineDriver');
-const { getAlterDatabaseScript, DatabaseAnalyser, runCommandOnDriver } = require('dbgate-tools');
+const { getAlterDatabaseScript, DatabaseAnalyser, runCommandOnDriver, adaptDatabaseInfo } = require('dbgate-tools');
 const importDbModel = require('../utility/importDbModel');
 const jsonLinesReader = require('./jsonLinesReader');
 const tableWriter = require('./tableWriter');
@@ -26,10 +26,7 @@ async function importDbFromFolder({ connection, systemConnection, driver, folder
     if (driver?.databaseEngineTypes?.includes('sql')) {
       const model = await importDbModel(folder);
 
-      let modelAdapted = {
-        ...model,
-        tables: model.tables.map(table => driver.adaptTableInfo(table)),
-      };
+      let modelAdapted = adaptDatabaseInfo(model, driver);
       for (const transform of modelTransforms || []) {
         modelAdapted = transform(modelAdapted);
       }

package/src/storageModel.js

@@ -1,5 +1,192 @@
 module.exports = {
   "tables": [
+    {
+      "pureName": "audit_log",
+      "columns": [
+        {
+          "pureName": "audit_log",
+          "columnName": "id",
+          "dataType": "int",
+          "autoIncrement": true,
+          "notNull": true
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "created",
+          "dataType": "bigint",
+          "notNull": true
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "modified",
+          "dataType": "bigint",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "user_id",
+          "dataType": "int",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "user_login",
+          "dataType": "varchar(250)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "category",
+          "dataType": "varchar(50)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "component",
+          "dataType": "varchar(50)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "action",
+          "dataType": "varchar(50)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "severity",
+          "dataType": "varchar(50)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "event",
+          "dataType": "varchar(100)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "message",
+          "dataType": "varchar(250)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "detail",
+          "dataType": "varchar(1000)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "detail_full_length",
+          "dataType": "int",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "session_id",
+          "dataType": "varchar(200)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "session_group",
+          "dataType": "varchar(50)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "session_param",
+          "dataType": "varchar(200)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "conid",
+          "dataType": "varchar(100)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "connection_data",
+          "dataType": "varchar(1000)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "database",
+          "dataType": "varchar(200)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "schema_name",
+          "dataType": "varchar(100)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "pure_name",
+          "dataType": "varchar(100)",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "sumint_1",
+          "dataType": "int",
+          "notNull": false
+        },
+        {
+          "pureName": "audit_log",
+          "columnName": "sumint_2",
+          "dataType": "int",
+          "notNull": false
+        }
+      ],
+      "foreignKeys": [
+        {
+          "constraintType": "foreignKey",
+          "constraintName": "FK_audit_log_user_id",
+          "pureName": "audit_log",
+          "refTableName": "users",
+          "deleteAction": "SET NULL",
+          "columns": [
+            {
+              "columnName": "user_id",
+              "refColumnName": "id"
+            }
+          ]
+        }
+      ],
+      "indexes": [
+        {
+          "constraintName": "idx_audit_log_session",
+          "pureName": "audit_log",
+          "constraintType": "index",
+          "columns": [
+            {
+              "columnName": "session_group"
+            },
+            {
+              "columnName": "session_id"
+            },
+            {
+              "columnName": "session_param"
+            }
+          ]
+        }
+      ],
+      "primaryKey": {
+        "pureName": "audit_log",
+        "constraintType": "primaryKey",
+        "constraintName": "PK_audit_log",
+        "columns": [
+          {
+            "columnName": "id"
+          }
+        ]
+      }
+    },
     {
       "pureName": "auth_methods",
       "columns": [
@@ -50,6 +237,7 @@ module.exports = {
       "primaryKey": {
         "pureName": "auth_methods",
         "constraintType": "primaryKey",
+        "constraintName": "PK_auth_methods",
         "columns": [
           {
             "columnName": "id"
@@ -61,7 +249,8 @@ module.exports = {
           "id": -1,
           "amoid": "790ca4d2-7f01-4800-955b-d691b890cc50",
           "name": "Anonymous",
-          "type": "none"
+          "type": "none",
+          "is_disabled": 1
         },
         {
           "id": -2,
@@ -69,6 +258,9 @@ module.exports = {
           "name": "Local",
           "type": "local"
         }
+      ],
+      "preloadedRowsInsertOnly": [
+        "is_disabled"
       ]
     },
     {
@@ -103,6 +295,7 @@ module.exports = {
       "foreignKeys": [
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_auth_methods_config_auth_method_id",
           "pureName": "auth_methods_config",
           "refTableName": "auth_methods",
           "deleteAction": "CASCADE",
@@ -114,9 +307,25 @@ module.exports = {
           ]
         }
       ],
+      "uniques": [
+        {
+          "constraintName": "UQ_auth_methods_config_auth_method_id_key",
+          "pureName": "auth_methods_config",
+          "constraintType": "unique",
+          "columns": [
+            {
+              "columnName": "auth_method_id"
+            },
+            {
+              "columnName": "key"
+            }
+          ]
+        }
+      ],
       "primaryKey": {
         "pureName": "auth_methods_config",
         "constraintType": "primaryKey",
+        "constraintName": "PK_auth_methods_config",
         "columns": [
           {
             "columnName": "id"
@@ -154,9 +363,25 @@ module.exports = {
         }
       ],
       "foreignKeys": [],
+      "uniques": [
+        {
+          "constraintName": "UQ_config_group_key",
+          "pureName": "config",
+          "constraintType": "unique",
+          "columns": [
+            {
+              "columnName": "group"
+            },
+            {
+              "columnName": "key"
+            }
+          ]
+        }
+      ],
       "primaryKey": {
         "pureName": "config",
         "constraintType": "primaryKey",
+        "constraintName": "PK_config",
         "columns": [
           {
             "columnName": "id"
@@ -449,6 +674,7 @@ module.exports = {
       "primaryKey": {
         "pureName": "connections",
         "constraintType": "primaryKey",
+        "constraintName": "PK_connections",
         "columns": [
           {
             "columnName": "id"
@@ -456,48 +682,6 @@ module.exports = {
         ]
       }
     },
-    {
-      "pureName": "roles",
-      "columns": [
-        {
-          "pureName": "roles",
-          "columnName": "id",
-          "dataType": "int",
-          "autoIncrement": true,
-          "notNull": true
-        },
-        {
-          "pureName": "roles",
-          "columnName": "name",
-          "dataType": "varchar(250)",
-          "notNull": false
-        }
-      ],
-      "foreignKeys": [],
-      "primaryKey": {
-        "pureName": "roles",
-        "constraintType": "primaryKey",
-        "columns": [
-          {
-            "columnName": "id"
-          }
-        ]
-      },
-      "preloadedRows": [
-        {
-          "id": -1,
-          "name": "anonymous-user"
-        },
-        {
-          "id": -2,
-          "name": "logged-user"
-        },
-        {
-          "id": -3,
-          "name": "superadmin"
-        }
-      ]
-    },
     {
       "pureName": "role_connections",
       "columns": [
@@ -524,6 +708,7 @@ module.exports = {
       "foreignKeys": [
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_role_connections_role_id",
           "pureName": "role_connections",
           "refTableName": "roles",
           "deleteAction": "CASCADE",
@@ -536,6 +721,7 @@ module.exports = {
         },
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_role_connections_connection_id",
           "pureName": "role_connections",
           "refTableName": "connections",
           "deleteAction": "CASCADE",
@@ -550,6 +736,7 @@ module.exports = {
       "primaryKey": {
         "pureName": "role_connections",
         "constraintType": "primaryKey",
+        "constraintName": "PK_role_connections",
         "columns": [
           {
             "columnName": "id"
@@ -583,6 +770,7 @@ module.exports = {
       "foreignKeys": [
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_role_permissions_role_id",
           "pureName": "role_permissions",
           "refTableName": "roles",
           "deleteAction": "CASCADE",
@@ -597,6 +785,7 @@ module.exports = {
       "primaryKey": {
         "pureName": "role_permissions",
         "constraintType": "primaryKey",
+        "constraintName": "PK_role_permissions",
         "columns": [
           {
             "columnName": "id"
@@ -605,44 +794,47 @@ module.exports = {
       }
     },
     {
-      "pureName": "users",
+      "pureName": "roles",
       "columns": [
         {
-          "pureName": "users",
+          "pureName": "roles",
           "columnName": "id",
           "dataType": "int",
           "autoIncrement": true,
           "notNull": true
         },
         {
-          "pureName": "users",
-          "columnName": "login",
-          "dataType": "varchar(250)",
-          "notNull": false
-        },
-        {
-          "pureName": "users",
-          "columnName": "password",
-          "dataType": "varchar(250)",
-          "notNull": false
-        },
-        {
-          "pureName": "users",
-          "columnName": "email",
+          "pureName": "roles",
+          "columnName": "name",
           "dataType": "varchar(250)",
           "notNull": false
         }
       ],
       "foreignKeys": [],
       "primaryKey": {
-        "pureName": "users",
+        "pureName": "roles",
         "constraintType": "primaryKey",
+        "constraintName": "PK_roles",
         "columns": [
           {
             "columnName": "id"
           }
         ]
-      }
+      },
+      "preloadedRows": [
+        {
+          "id": -1,
+          "name": "anonymous-user"
+        },
+        {
+          "id": -2,
+          "name": "logged-user"
+        },
+        {
+          "id": -3,
+          "name": "superadmin"
+        }
+      ]
     },
     {
       "pureName": "user_connections",
@@ -670,6 +862,7 @@ module.exports = {
       "foreignKeys": [
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_user_connections_user_id",
           "pureName": "user_connections",
           "refTableName": "users",
           "deleteAction": "CASCADE",
@@ -682,6 +875,7 @@ module.exports = {
         },
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_user_connections_connection_id",
           "pureName": "user_connections",
           "refTableName": "connections",
           "deleteAction": "CASCADE",
@@ -696,6 +890,7 @@ module.exports = {
       "primaryKey": {
         "pureName": "user_connections",
         "constraintType": "primaryKey",
+        "constraintName": "PK_user_connections",
         "columns": [
           {
             "columnName": "id"
@@ -729,6 +924,7 @@ module.exports = {
       "foreignKeys": [
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_user_permissions_user_id",
           "pureName": "user_permissions",
           "refTableName": "users",
           "deleteAction": "CASCADE",
@@ -743,6 +939,7 @@ module.exports = {
       "primaryKey": {
         "pureName": "user_permissions",
         "constraintType": "primaryKey",
+        "constraintName": "PK_user_permissions",
         "columns": [
           {
             "columnName": "id"
@@ -776,6 +973,7 @@ module.exports = {
       "foreignKeys": [
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_user_roles_user_id",
           "pureName": "user_roles",
           "refTableName": "users",
           "deleteAction": "CASCADE",
@@ -788,6 +986,7 @@ module.exports = {
         },
         {
           "constraintType": "foreignKey",
+          "constraintName": "FK_user_roles_role_id",
           "pureName": "user_roles",
           "refTableName": "roles",
           "deleteAction": "CASCADE",
@@ -802,6 +1001,48 @@ module.exports = {
       "primaryKey": {
         "pureName": "user_roles",
         "constraintType": "primaryKey",
+        "constraintName": "PK_user_roles",
+        "columns": [
+          {
+            "columnName": "id"
+          }
+        ]
+      }
+    },
+    {
+      "pureName": "users",
+      "columns": [
+        {
+          "pureName": "users",
+          "columnName": "id",
+          "dataType": "int",
+          "autoIncrement": true,
+          "notNull": true
+        },
+        {
+          "pureName": "users",
+          "columnName": "login",
+          "dataType": "varchar(250)",
+          "notNull": false
+        },
+        {
+          "pureName": "users",
+          "columnName": "password",
+          "dataType": "varchar(250)",
+          "notNull": false
+        },
+        {
+          "pureName": "users",
+          "columnName": "email",
+          "dataType": "varchar(250)",
+          "notNull": false
+        }
+      ],
+      "foreignKeys": [],
+      "primaryKey": {
+        "pureName": "users",
+        "constraintType": "primaryKey",
+        "constraintName": "PK_users",
         "columns": [
           {
             "columnName": "id"
@@ -815,5 +1056,6 @@ module.exports = {
   "matviews": [],
   "functions": [],
   "procedures": [],
-  "triggers": []
+  "triggers": [],
+  "schedulerEvents": []
 };

package/src/utility/auditlog.js

@@ -0,0 +1,9 @@
+// only in DbGate Premium
+
+async function sendToAuditLog(req, props) {}
+async function logJsonRunnerScript(req, script) {}
+
+module.exports = {
+  sendToAuditLog,
+  logJsonRunnerScript,
+};

package/src/utility/cloudIntf.js

@@ -34,11 +34,12 @@ const DBGATE_CLOUD_URL = process.env.LOCAL_DBGATE_CLOUD
   ? 'https://cloud.dbgate.udolni.net'
   : 'https://cloud.dbgate.io';
 
-async function createDbGateIdentitySession(client) {
+async function createDbGateIdentitySession(client, redirectUri) {
   const resp = await axios.default.post(
     `${DBGATE_IDENTITY_URL}/api/create-session`,
     {
       client,
+      redirectUri,
     },
     {
       headers: {
@@ -70,7 +71,7 @@ function startCloudTokenChecking(sid, callback) {
       });
       // console.log('CHECK RESP:', resp.data);
 
-      if (resp.data.email) {
+      if (resp.data?.email) {
         clearInterval(interval);
         callback(resp.data);
       }
@@ -80,6 +81,34 @@ function startCloudTokenChecking(sid, callback) {
   }, 500);
 }
 
+async function readCloudTokenHolder(sid) {
+  const resp = await axios.default.get(`${DBGATE_IDENTITY_URL}/api/get-token/${sid}`, {
+    headers: {
+      ...getLicenseHttpHeaders(),
+    },
+  });
+  if (resp.data?.email) {
+    return resp.data;
+  }
+  return null;
+}
+
+async function readCloudTestTokenHolder(email) {
+  const resp = await axios.default.post(
+    `${DBGATE_IDENTITY_URL}/api/test-token`,
+    { email },
+    {
+      headers: {
+        ...getLicenseHttpHeaders(),
+      },
+    }
+  );
+  if (resp.data?.email) {
+    return resp.data;
+  }
+  return null;
+}
+
 async function loadCloudFiles() {
   try {
     const fileContent = await fs.readFile(path.join(datadir(), 'cloud-files.jsonl'), 'utf-8');
@@ -396,4 +425,6 @@ module.exports = {
   loadCachedCloudConnection,
   putCloudContent,
   removeCloudCachedConnection,
+  readCloudTokenHolder,
+  readCloudTestTokenHolder,
 };

package/src/utility/getChartExport.js

@@ -1,4 +1,12 @@
-const getChartExport = (title, config, imageFile) => {
+const getChartExport = (title, config, imageFile, plugins) => {
+  const PLUGIN_TAGS = {
+    zoom: '<script src="https://cdnjs.cloudflare.com/ajax/libs/chartjs-plugin-zoom/1.2.0/chartjs-plugin-zoom.min.js" integrity="sha512-TT0wAMqqtjXVzpc48sI0G84rBP+oTkBZPgeRYIOVRGUdwJsyS3WPipsNh///ay2LJ+onCM23tipnz6EvEy2/UA==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>',
+    dataLabels:
+      '<script src="https://cdnjs.cloudflare.com/ajax/libs/chartjs-plugin-datalabels/2.2.0/chartjs-plugin-datalabels.min.js" integrity="sha512-JPcRR8yFa8mmCsfrw4TNte1ZvF1e3+1SdGMslZvmrzDYxS69J7J49vkFL8u6u8PlPJK+H3voElBtUCzaXj+6ig==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>',
+    outlabels:
+      '<script src="https://cdn.jsdelivr.net/npm/@energiency/chartjs-plugin-piechart-outlabels@1.3.4/dist/chartjs-plugin-piechart-outlabels.min.js"></script>',
+  };
+
   return `<html>
 <meta charset='utf-8'>
 
@@ -8,7 +16,7 @@ const getChartExport = (title, config, imageFile) => {
     <script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.29.1/moment.min.js" integrity="sha512-qTXRIMyZIFb8iQcfjXWCO8+M5Tbc38Qi5WzdPOYZHIlZpzBHG3L3by84BBBOiRGiEb7KKtAOAs5qYdUiZiQNNQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/chartjs-adapter-moment/1.0.0/chartjs-adapter-moment.min.js" integrity="sha512-oh5t+CdSBsaVVAvxcZKy3XJdP7ZbYUBSRCXDTVn0ODewMDDNnELsrG9eDm8rVZAQg7RsDD/8K3MjPAFB13o6eA==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/hammer.js/2.0.8/hammer.min.js" integrity="sha512-UXumZrZNiOwnTcZSHLOfcTs0aos2MzBWHXOHOuB0J/R44QB0dwY5JgfbvljXcklVf65Gc4El6RjZ+lnwd2az2g==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/chartjs-plugin-zoom/1.2.0/chartjs-plugin-zoom.min.js" integrity="sha512-TT0wAMqqtjXVzpc48sI0G84rBP+oTkBZPgeRYIOVRGUdwJsyS3WPipsNh///ay2LJ+onCM23tipnz6EvEy2/UA==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+    ${plugins.map(plugin => PLUGIN_TAGS[plugin] ?? '')}
 
     <style>
         a { text-decoration: none }
@@ -45,7 +53,7 @@ const getChartExport = (title, config, imageFile) => {
     </div>
 
     <div class="footer">
-        Exported from <a href='https://dbgate.org/' target='_blank'>DbGate</a>, powered by <a href='https://www.chartjs.org/' target='_blank'>Chart.js</a>
+        Exported from <a href='https://dbgate.io/' target='_blank'>DbGate</a>, powered by <a href='https://www.chartjs.org/' target='_blank'>Chart.js</a>
     </div>
 </body>
 

package/src/utility/getMapExport.js

@@ -18,7 +18,7 @@ const getMapExport = (geoJson) => {
     leaflet
       .tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
         maxZoom: 19,
-        attribution: '<a href="https://dbgate.org" title="Exported from DbGate">DbGate</a> | © OpenStreetMap',
+        attribution: '<a href="https://dbgate.io" title="Exported from DbGate">DbGate</a> | © OpenStreetMap',
       })
       .addTo(map);
       

package/src/utility/loginchecker.js

@@ -0,0 +1,15 @@
+// only in DbGate Premium
+
+function markUserAsActive(licenseUid) {}
+
+async function isLoginLicensed(req, licenseUid) {
+  return true;
+}
+
+const LOGIN_LIMIT_ERROR = '';
+
+module.exports = {
+  markUserAsActive,
+  isLoginLicensed,
+  LOGIN_LIMIT_ERROR,
+};