dbgate-api-premium 5.5.7-alpha.60 → 5.5.7-alpha.68

package/package.json

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

package/src/controllers/config.js

@@ -62,6 +62,8 @@ module.exports = {
     const logoutUrl = storageConnectionError ? null : await authProvider.getLogoutUrl();
     const adminConfig = storageConnectionError ? null : await storage.readConfig({ group: 'admin' });
 
+    storage.startRefreshLicense();
+
     const isAdminPasswordMissing = !!(
       process.env.STORAGE_DATABASE &&
       !process.env.ADMIN_PASSWORD &&
@@ -81,7 +83,7 @@ module.exports = {
       isElectron: platformInfo.isElectron,
       isLicenseValid,
       isLicenseExpired: checkedLicense?.isExpired,
-      trialDaysLeft: checkedLicense?.isGeneratedTrial && !checkedLicense?.isExpired ? checkedLicense?.daysLeft : null,
+      trialDaysLeft: checkedLicense?.licenseTypeObj?.isTrial && !checkedLicense?.isExpired ? checkedLicense?.daysLeft : null,
       checkedLicense,
       configurationError,
       logoutUrl,

package/src/controllers/connections.js

@@ -201,6 +201,7 @@ module.exports = {
       // @ts-ignore
       this.datastore = new JsonLinesDatabase(path.join(dir, 'connections.jsonl'));
     }
+    await this.checkUnsavedConnectionsLimit();
   },
 
   list_meta: true,
@@ -300,6 +301,29 @@ module.exports = {
     return res;
   },
 
+  async checkUnsavedConnectionsLimit() {
+    const MAX_UNSAVED_CONNECTIONS = 5;
+    await this.datastore.transformAll(connections => {
+      const count = connections.filter(x => x.unsaved).length;
+      if (count > MAX_UNSAVED_CONNECTIONS) {
+        const res = [];
+        let unsavedToSkip = count - MAX_UNSAVED_CONNECTIONS;
+        for (const item of connections) {
+          if (item.unsaved) {
+            if (unsavedToSkip > 0) {
+              unsavedToSkip--;
+            } else {
+              res.push(item);
+            }
+          } else {
+            res.push(item);
+          }
+        }
+        return res;
+      }
+    });
+  },
+
   update_meta: true,
   async update({ _id, values }, req) {
     if (portalConnections) return;

package/src/controllers/runners.js

@@ -111,7 +111,7 @@ module.exports = {
     const scriptFile = path.join(uploadsdir(), runid + '.js');
     fs.writeFileSync(`${scriptFile}`, scriptText);
     fs.mkdirSync(directory);
-    const pluginNames = _.union(fs.readdirSync(pluginsdir()), packagedPluginList);
+    const pluginNames = extractPlugins(scriptText);
     logger.info({ scriptFile }, 'Running script');
     // const subprocess = fork(scriptFile, ['--checkParent', '--max-old-space-size=8192'], {
     const subprocess = fork(

package/src/controllers/serverConnections.js

@@ -52,7 +52,7 @@ module.exports = {
       if (existing) return existing;
       const connection = await connections.getCore({ conid });
       if (!connection) {
-        throw new Error(`Connection with conid="${conid}" not fund`);
+        throw new Error(`Connection with conid="${conid}" not found`);
       }
       if (connection.passwordMode == 'askPassword' || connection.passwordMode == 'askUser') {
         throw new MissingCredentialsError({ conid, passwordMode: connection.passwordMode });

package/src/controllers/storage.js

@@ -1,5 +1,6 @@
 const fs = require('fs-extra');
 const _ = require('lodash');
+const path = require('path');
 const { setAuthProviders, getAuthProviderById } = require('../auth/authProvider');
 const { createStorageAuthProvider } = require('../auth/storageAuthProvider');
 const {
@@ -16,8 +17,12 @@ const { hasPermission } = require('../utility/hasPermission');
 const { changeSetToSql, removeSchemaFromChangeSet } = require('dbgate-datalib');
 const storageModel = require('../storageModel');
 const { dumpSqlCommand } = require('dbgate-sqltree');
-const { runCommandOnDriver } = require('dbgate-tools');
+const { runCommandOnDriver, getLogger } = require('dbgate-tools');
 const socket = require('../utility/socket');
+const { obtainRefreshedLicense } = require('../utility/authProxy');
+const { datadir } = require('../utility/directories');
+
+const logger = getLogger('storage');
 
 function mapConnection(connnection) {
   return {
@@ -32,6 +37,8 @@ async function runQueryFmt(driver, conn, query, ...args) {
   await driver.query(conn, dmp.s);
 }
 
+let refreshLicenseStarted = false;
+
 module.exports = {
   async _init() {
     if (!process.env.STORAGE_DATABASE) {
@@ -48,6 +55,32 @@ module.exports = {
     setAuthProviders(providers, providers[defIndex]);
   },
 
+  async startRefreshLicense() {
+    if (refreshLicenseStarted) {
+      return;
+    }
+    refreshLicenseStarted = true;
+    const resp = await obtainRefreshedLicense();
+    if (!resp) {
+      return;
+    }
+    if (resp.status == 'error') {
+      logger.error(`Error refreshing license: ${resp.message}`);
+      return;
+    }
+    if (resp.status != 'ok') {
+      return;
+    }
+    const { token } = resp;
+    logger.info('License succesfully refreshed');
+    if (process.env.STORAGE_DATABASE) {
+      await this.writeConfig({ group: 'license', config: { licenseKey: token } });
+    } else {
+      await fs.writeFile(path.join(datadir(), 'license.key'), token);
+    }
+    socket.emitChanged(`config-changed`);
+  },
+
   connections_meta: true,
   async connections(req) {
     if (!process.env.STORAGE_DATABASE) {

package/src/controllers/storageDb.js

@@ -81,6 +81,7 @@ async function getStorageConnectionCore() {
     systemConnection: newConnection,
     driver: storageDriver,
     loadedDbModel: storageModel,
+    targetSchema: process.env.STORAGE_SCHEMA,
   });
 
   storageConnection = newConnection;

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '5.5.7-alpha.60',
-  buildTime: '2024-11-20T09:21:10.849Z'
+  version: '5.5.7-alpha.68',
+  buildTime: '2024-12-03T15:39:33.137Z'
 };

package/src/utility/JsonLinesDatabase.js

@@ -111,6 +111,15 @@ class JsonLinesDatabase {
     return removed;
   }
 
+  async transformAll(transformFunction) {
+    await this._ensureLoaded();
+    const newData = transformFunction(this.data);
+    if (newData) {
+      this.data = newData;
+      await this._save();
+    }
+  }
+
   //   async _openReader() {
   //     return new Promise((resolve, reject) =>
   //       lineReader.open(this.filename, (err, reader) => {

package/src/utility/authProxy.js

@@ -1,8 +1,12 @@
 const axios = require('axios');
 const { Signer } = require('@aws-sdk/rds-signer');
+const jwt = require('jsonwebtoken');
+const { getLogger, extractErrorLogData } = require('dbgate-tools');
 
-const AUTH_PROXY_URL = process.env.DEVWEB ? 'https://dbgate-auth-proxy.stages.udolni.net' : 'https://auth.dbgate.eu';
-// const AUTH_PROXY_URL = 'https://dbgate-auth-proxy.stages.udolni.net';
+const logger = getLogger('authProxy');
+
+const AUTH_PROXY_URL = process.env.DEVWEB ? 'https://auth-proxy.dbgate.udolni.net' : 'https://auth.dbgate.eu';
+// const AUTH_PROXY_URL = 'https://auth-proxy.dbgate.udolni.net';
 
 let licenseKey = null;
 
@@ -91,7 +95,7 @@ function startTokenChecking(sid, callback) {
         callback(resp.data.token);
       }
     } catch (err) {
-      console.error('Error checking token', err);
+      logger.error(extractErrorLogData(err), 'Error checking token');
     }
   }, 500);
 }
@@ -121,6 +125,37 @@ async function getAwsIamToken(props) {
   return token;
 }
 
+async function obtainRefreshedLicense() {
+  if (!licenseKey) {
+    return null;
+  }
+
+  const decoded = jwt.decode(licenseKey);
+
+  if (Date.now() > decoded.end * 1000) {
+    logger.info('License expired, trying to obtain fresh license');
+
+    try {
+      const respToken = await axios.default.post(
+        `${AUTH_PROXY_URL}/refresh-license`,
+        {},
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${licenseKey}`,
+          },
+        }
+      );
+      return respToken.data;
+    } catch (err) {
+      return {
+        status: 'error',
+        message: err.message,
+      };
+    }
+  }
+}
+
 module.exports = {
   isAuthProxySupported,
   authProxyGetRedirectUrl,
@@ -130,4 +165,5 @@ module.exports = {
   getAuthProxyUrl,
   supportsAwsIam,
   getAwsIamToken,
+  obtainRefreshedLicense,
 };

package/src/utility/checkLicense.js

@@ -23,6 +23,46 @@ mQIDAQAB
 -----END PUBLIC KEY-----
 `;
 
+const licenseTypeById = {
+  '1414ede2-dfb3-4539-a93d-24db7e5b59d9': {
+    // premium generated by stripe
+    name: 'Premium',
+    isPremium: true,
+    isForWeb: false,
+    isForApp: true,
+  },
+  '9682a88b-909f-48b1-adbf-c03622884421': {
+    name: 'Team Premium',
+    isPremium: true,
+    isForWeb: true,
+    isForApp: true,
+  },
+  '81456363-f167-41e3-9496-b540f4b0c150': {
+    name: 'Premium Trial',
+    isPremium: true,
+    isForWeb: true,
+    isForApp: true,
+    isTrial: true,
+  },
+};
+
+function getLicenseByDecoded(decoded) {
+  if (!decoded) {
+    return null;
+  }
+  if (decoded.licenseId) {
+    return licenseTypeById[decoded.licenseId];
+  }
+  if (decoded.licenseType == 'premium') {
+    if (decoded.isGeneratedTrial) {
+      return licenseTypeById['81456363-f167-41e3-9496-b540f4b0c150'];
+    } else {
+      return licenseTypeById['9682a88b-909f-48b1-adbf-c03622884421'];
+    }
+  }
+  return null;
+}
+
 let awsMetadataLoaded = false;
 let awsMetadata = null;
 async function getAwsMetadata() {
@@ -71,20 +111,27 @@ function checkLicenseKey(licenseKey) {
     const decoded = jwt.verify(licenseKey, publicKey, {
       algorithms: ['RS256'],
     });
-    if (decoded.licenseType != 'premium') {
-      logger.error(`Incorrect license type, expected premium, found ${decoded.licenseType}`);
+
+    const licenseTypeObj = getLicenseByDecoded(decoded);
+
+    if (
+      !licenseTypeObj ||
+      (platformInfo.isElectron && !licenseTypeObj.isForApp) ||
+      (!platformInfo.isElectron && !licenseTypeObj.isForWeb)
+    ) {
+      logger.error(`Incorrect license type, found ${decoded.licenseType}`);
       return {
         status: 'error',
-        error: `Incorrect license type, expected premium, found ${decoded.licenseType}`,
+        error: `Incorrect license type, found ${decoded.licenseType}`,
       };
     }
+
     return {
       status: 'ok',
-      type: 'premium',
       validTo: decoded.validTo,
       expiration: new Date(decoded.exp * 1000).toISOString(),
       daysLeft: Math.round((decoded.exp * 1000 - Date.now()) / (24 * 60 * 60 * 1000)),
-      isGeneratedTrial: decoded.isGeneratedTrial,
+      licenseTypeObj,
     };
   } catch (err) {
     try {
@@ -187,5 +234,6 @@ function isProApp() {
 module.exports = {
   checkLicense,
   checkLicenseKey,
-  isProApp
+  isProApp,
+  licenseTypeById,
 };