dbgate-api-premium 6.2.0 → 6.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api-premium",
   "main": "src/index.js",
-  "version": "6.2.0",
+  "version": "6.2.1",
   "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": "^6.2.0",
+    "dbgate-datalib": "^6.2.1",
     "dbgate-query-splitter": "^4.11.3",
-    "dbgate-sqltree": "^6.2.0",
-    "dbgate-tools": "^6.2.0",
+    "dbgate-sqltree": "^6.2.1",
+    "dbgate-tools": "^6.2.1",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -83,7 +83,7 @@
   "devDependencies": {
     "@types/fs-extra": "^9.0.11",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "^6.2.0",
+    "dbgate-types": "^6.2.1",
     "env-cmd": "^10.1.0",
     "jsdoc-to-markdown": "^9.0.5",
     "node-loader": "^1.0.2",

package/src/controllers/sessions.js

@@ -56,12 +56,19 @@ module.exports = {
   handle_done(sesid, props) {
     socket.emit(`session-done-${sesid}`);
     if (!props.skipFinishedMessage) {
-      this.dispatchMessage(sesid, 'Query execution finished');
+      if (props.controlCommand) {
+        this.dispatchMessage(sesid, `${_.startCase(props.controlCommand)} finished`);
+      } else {
+        this.dispatchMessage(sesid, 'Query execution finished');
+      }
     }
     const session = this.opened.find(x => x.sesid == sesid);
     if (session.loadingReader_jslid) {
       socket.emit(`session-jslid-done-${session.loadingReader_jslid}`);
     }
+    if (props.autoCommit) {
+      this.executeControlCommand({ sesid, command: 'commitTransaction' });
+    }
     if (session.killOnDone) {
       this.kill({ sesid });
     }
@@ -131,7 +138,7 @@ module.exports = {
   },
 
   executeQuery_meta: true,
-  async executeQuery({ sesid, sql }) {
+  async executeQuery({ sesid, sql, autoCommit }) {
     const session = this.opened.find(x => x.sesid == sesid);
     if (!session) {
       throw new Error('Invalid session');
@@ -139,7 +146,21 @@ module.exports = {
 
     logger.info({ sesid, sql }, 'Processing query');
     this.dispatchMessage(sesid, 'Query execution started');
-    session.subprocess.send({ msgtype: 'executeQuery', sql });
+    session.subprocess.send({ msgtype: 'executeQuery', sql, autoCommit });
+
+    return { state: 'ok' };
+  },
+
+  executeControlCommand_meta: true,
+  async executeControlCommand({ sesid, command }) {
+    const session = this.opened.find(x => x.sesid == sesid);
+    if (!session) {
+      throw new Error('Invalid session');
+    }
+
+    logger.info({ sesid, command }, 'Processing control command');
+    this.dispatchMessage(sesid, `${_.startCase(command)} started`);
+    session.subprocess.send({ msgtype: 'executeControlCommand', command });
 
     return { state: 'ok' };
   },

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '6.2.0',
-  buildTime: '2025-02-14T13:58:57.650Z'
+  version: '6.2.1',
+  buildTime: '2025-02-28T09:57:07.127Z'
 };

package/src/proc/sessionProcess.js

@@ -245,7 +245,47 @@ async function handleStopProfiler({ jslid }) {
   currentProfiler = null;
 }
 
-async function handleExecuteQuery({ sql }) {
+async function handleExecuteControlCommand({ command }) {
+  lastActivity = new Date().getTime();
+
+  await waitConnected();
+  const driver = requireEngineDriver(storedConnection);
+
+  if (command == 'commitTransaction' && !allowExecuteCustomScript(driver)) {
+    process.send({
+      msgtype: 'info',
+      info: {
+        message: 'Connection without read-only sessions is read only',
+        severity: 'error',
+      },
+    });
+    process.send({ msgtype: 'done', skipFinishedMessage: true });
+    return;
+    //process.send({ msgtype: 'error', error: e.message });
+  }
+
+  executingScripts++;
+  try {
+    const dmp = driver.createDumper();
+    switch (command) {
+      case 'commitTransaction':
+        await dmp.commitTransaction();
+        break;
+      case 'rollbackTransaction':
+        await dmp.rollbackTransaction();
+        break;
+      case 'beginTransaction':
+        await dmp.beginTransaction();
+        break;
+    }
+    await driver.query(dbhan, dmp.s, { discardResult: true });
+    process.send({ msgtype: 'done', controlCommand: command });
+  } finally {
+    executingScripts--;
+  }
+}
+
+async function handleExecuteQuery({ sql, autoCommit }) {
   lastActivity = new Date().getTime();
 
   await waitConnected();
@@ -279,7 +319,7 @@ async function handleExecuteQuery({ sql }) {
       // handler.stream = stream;
       // resultIndex = handler.resultIndex;
     }
-    process.send({ msgtype: 'done' });
+    process.send({ msgtype: 'done', autoCommit });
   } finally {
     executingScripts--;
   }
@@ -323,6 +363,7 @@ function handlePing() {
 const messageHandlers = {
   connect: handleConnect,
   executeQuery: handleExecuteQuery,
+  executeControlCommand: handleExecuteControlCommand,
   executeReader: handleExecuteReader,
   startProfiler: handleStartProfiler,
   stopProfiler: handleStopProfiler,

package/src/shell/importDbFromFolder.js

@@ -0,0 +1,110 @@
+const path = require('path');
+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 importDbModel = require('../utility/importDbModel');
+const jsonLinesReader = require('./jsonLinesReader');
+const tableWriter = require('./tableWriter');
+const copyStream = require('./copyStream');
+
+/**
+ * Deploys database model stored in modelFolder (table as yamls) to database
+ * @param {object} options
+ * @param {connectionType} options.connection - connection object
+ * @param {object} options.systemConnection - system connection (result of driver.connect). If not provided, new connection will be created
+ * @param {object} options.driver - driver object. If not provided, it will be loaded from connection
+ * @param {string} options.folder - folder with model files (YAML files for tables, SQL files for views, procedures, ...)
+ * @param {function[]} options.modelTransforms - array of functions for transforming model
+ */
+async function importDbFromFolder({ connection, systemConnection, driver, folder, modelTransforms }) {
+  if (!driver) driver = requireEngineDriver(connection);
+  const dbhan = systemConnection || (await connectUtility(driver, connection, 'read'));
+
+  try {
+    const model = await importDbModel(folder);
+
+    let modelAdapted = {
+      ...model,
+      tables: model.tables.map(table => driver.adaptTableInfo(table)),
+    };
+    for (const transform of modelTransforms || []) {
+      modelAdapted = transform(modelAdapted);
+    }
+
+    const modelNoFk = {
+      ...modelAdapted,
+      tables: modelAdapted.tables.map(table => ({
+        ...table,
+        foreignKeys: [],
+      })),
+    };
+
+    // const plan = createAlterDatabasePlan(
+    //   DatabaseAnalyser.createEmptyStructure(),
+    //   driver.dialect.enableAllForeignKeys ? modelAdapted : modelNoFk,
+    //   {},
+    //   DatabaseAnalyser.createEmptyStructure(),
+    //   driver.dialect.enableAllForeignKeys ? modelAdapted : modelNoFk,
+    //   driver
+    // );
+    // const dmp1 = driver.createDumper({ useHardSeparator: true });
+    // if (driver.dialect.enableAllForeignKeys) {
+    //   dmp1.enableAllForeignKeys(false);
+    // }
+    // plan.run(dmp1);
+    // if (driver.dialect.enableAllForeignKeys) {
+    //   dmp1.enableAllForeignKeys(true);
+    // }
+
+    const { sql } = getAlterDatabaseScript(
+      DatabaseAnalyser.createEmptyStructure(),
+      driver.dialect.enableAllForeignKeys ? modelAdapted : modelNoFk,
+      {},
+      DatabaseAnalyser.createEmptyStructure(),
+      driver.dialect.enableAllForeignKeys ? modelAdapted : modelNoFk,
+      driver
+    );
+    // console.log('CREATING STRUCTURE:', sql);
+    await executeQuery({ connection, systemConnection: dbhan, driver, sql, logScriptItems: true });
+
+    if (driver.dialect.enableAllForeignKeys) {
+      await runCommandOnDriver(dbhan, driver, dmp => dmp.enableAllForeignKeys(false));
+    }
+
+    for (const table of modelAdapted.tables) {
+      const fileName = path.join(folder, `${table.pureName}.jsonl`);
+      if (await fs.exists(fileName)) {
+        const src = await jsonLinesReader({ fileName });
+        const dst = await tableWriter({
+          systemConnection: dbhan,
+          pureName: table.pureName,
+          driver,
+          targetTableStructure: table,
+        });
+        await copyStream(src, dst);
+      }
+    }
+
+    if (driver.dialect.enableAllForeignKeys) {
+      await runCommandOnDriver(dbhan, driver, dmp => dmp.enableAllForeignKeys(true));
+    } else if (driver.dialect.createForeignKey) {
+      const dmp = driver.createDumper();
+      for (const table of modelAdapted.tables) {
+        for (const fk of table.foreignKeys) {
+          dmp.createForeignKey(fk);
+        }
+      }
+
+      // create foreign keys
+      await executeQuery({ connection, systemConnection: dbhan, driver, sql: dmp.s, logScriptItems: true });
+    }
+  } finally {
+    if (!systemConnection) {
+      await driver.close(dbhan);
+    }
+  }
+}
+
+module.exports = importDbFromFolder;

package/src/shell/index.js

@@ -35,6 +35,7 @@ const sqlTextReplacementTransform = require('./sqlTextReplacementTransform');
 const autoIndexForeignKeysTransform = require('./autoIndexForeignKeysTransform');
 const generateDeploySql = require('./generateDeploySql');
 const dropAllDbObjects = require('./dropAllDbObjects');
+const importDbFromFolder = require('./importDbFromFolder');
 
 const dbgateApi = {
   queryReader,
@@ -73,6 +74,7 @@ const dbgateApi = {
   autoIndexForeignKeysTransform,
   generateDeploySql,
   dropAllDbObjects,
+  importDbFromFolder,
 };
 
 requirePlugin.initializeDbgateApi(dbgateApi);

package/src/shell/tableWriter.js

@@ -15,6 +15,7 @@ const logger = getLogger('tableWriter');
  * @param {boolean} options.truncate - truncate table before insert
  * @param {boolean} options.createIfNotExists - create table if not exists
  * @param {boolean} options.commitAfterInsert - commit transaction after insert
+ * @param {any} options.targetTableStructure - target table structure (don't analyse if given)
  * @returns {Promise<writerType>} - writer object
  */
 async function tableWriter({ connection, schemaName, pureName, driver, systemConnection, ...options }) {