dbgate-api 5.4.5-alpha.5 → 5.5.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dbgate-api",
   "main": "src/index.js",
-  "version": "5.4.5-alpha.5",
+  "version": "5.5.1",
   "homepage": "https://dbgate.org/",
   "repository": {
     "type": "git",
@@ -26,10 +26,10 @@
     "compare-versions": "^3.6.0",
     "cors": "^2.8.5",
     "cross-env": "^6.0.3",
-    "dbgate-datalib": "^5.4.5-alpha.5",
+    "dbgate-datalib": "^5.5.1",
     "dbgate-query-splitter": "^4.10.3",
-    "dbgate-sqltree": "^5.4.5-alpha.5",
-    "dbgate-tools": "^5.4.5-alpha.5",
+    "dbgate-sqltree": "^5.5.1",
+    "dbgate-tools": "^5.5.1",
     "debug": "^4.3.4",
     "diff": "^5.0.0",
     "diff2html": "^3.4.13",
@@ -57,6 +57,7 @@
     "rimraf": "^3.0.0",
     "simple-encryptor": "^4.0.0",
     "ssh2": "^1.11.0",
+    "stream-json": "^1.8.0",
     "tar": "^6.0.5"
   },
   "scripts": {
@@ -74,7 +75,7 @@
   "devDependencies": {
     "@types/fs-extra": "^9.0.11",
     "@types/lodash": "^4.14.149",
-    "dbgate-types": "^5.4.5-alpha.5",
+    "dbgate-types": "^5.5.1",
     "env-cmd": "^10.1.0",
     "node-loader": "^1.0.2",
     "nodemon": "^2.0.2",

package/src/controllers/connections.js

@@ -76,6 +76,7 @@ function getPortalCollections() {
       allowedDatabases: process.env[`ALLOWED_DATABASES_${id}`]?.replace(/\|/g, '\n'),
       allowedDatabasesRegex: process.env[`ALLOWED_DATABASES_REGEX_${id}`],
       parent: process.env[`PARENT_${id}`] || undefined,
+      useSeparateSchemas: !!process.env[`USE_SEPARATE_SCHEMAS_${id}`],
 
       // SSH tunnel
       useSshTunnel: process.env[`USE_SSH_${id}`],

package/src/controllers/databaseConnections.js

@@ -213,6 +213,17 @@ module.exports = {
     return res.result || null;
   },
 
+  schemaList_meta: true,
+  async schemaList({ conid, database }, req) {
+    testConnectionPermission(conid, req);
+    return this.loadDataCore('schemaList', { conid, database });
+  },
+
+  dispatchDatabaseChangedEvent_meta: true,
+  dispatchDatabaseChangedEvent({ event, conid, database }) {
+    socket.emitChanged(event, { conid, database });
+  },
+
   loadKeys_meta: true,
   async loadKeys({ conid, database, root, filter }, req) {
     testConnectionPermission(conid, req);

package/src/controllers/jsldata.js

@@ -18,11 +18,14 @@ function readFirstLine(file) {
       }
       if (reader.hasNextLine()) {
         reader.nextLine((err, line) => {
-          if (err) reject(err);
-          resolve(line);
+          if (err) {
+            reader.close(() => reject(err)); // Ensure reader is closed on error
+            return;
+          }
+          reader.close(() => resolve(line)); // Ensure reader is closed after reading
         });
       } else {
-        resolve(null);
+        reader.close(() => resolve(null)); // Properly close if no lines are present
       }
     });
   });

package/src/currentVersion.js

@@ -1,5 +1,5 @@
 
 module.exports = { 
-  version: '5.4.5-alpha.5',
-  buildTime: '2024-09-13T11:38:16.179Z'
+  version: '5.5.1',
+  buildTime: '2024-09-25T07:31:46.919Z'
 };

package/src/proc/databaseConnectionProcess.js

@@ -11,7 +11,7 @@ const { dumpSqlSelect } = require('dbgate-sqltree');
 
 const logger = getLogger('dbconnProcess');
 
-let systemConnection;
+let dbhan;
 let storedConnection;
 let afterConnectCallbacks = [];
 let afterAnalyseCallbacks = [];
@@ -49,7 +49,7 @@ async function handleFullRefresh() {
   loadingModel = true;
   const driver = requireEngineDriver(storedConnection);
   setStatusName('loadStructure');
-  analysedStructure = await checkedAsyncCall(driver.analyseFull(systemConnection, serverVersion));
+  analysedStructure = await checkedAsyncCall(driver.analyseFull(dbhan, serverVersion));
   analysedTime = new Date().getTime();
   process.send({ msgtype: 'structure', structure: analysedStructure });
   process.send({ msgtype: 'structureTime', analysedTime });
@@ -63,9 +63,7 @@ async function handleIncrementalRefresh(forceSend) {
   loadingModel = true;
   const driver = requireEngineDriver(storedConnection);
   setStatusName('checkStructure');
-  const newStructure = await checkedAsyncCall(
-    driver.analyseIncremental(systemConnection, analysedStructure, serverVersion)
-  );
+  const newStructure = await checkedAsyncCall(driver.analyseIncremental(dbhan, analysedStructure, serverVersion));
   analysedTime = new Date().getTime();
   if (newStructure != null) {
     analysedStructure = newStructure;
@@ -103,7 +101,7 @@ function setStatusName(name) {
 
 async function readVersion() {
   const driver = requireEngineDriver(storedConnection);
-  const version = await driver.getVersion(systemConnection);
+  const version = await driver.getVersion(dbhan);
   process.send({ msgtype: 'version', version });
   serverVersion = version;
 }
@@ -114,8 +112,8 @@ async function handleConnect({ connection, structure, globalSettings }) {
 
   if (!structure) setStatusName('pending');
   const driver = requireEngineDriver(storedConnection);
-  systemConnection = await checkedAsyncCall(connectUtility(driver, storedConnection, 'app'));
-  systemConnection.feedback = feedback => setStatus({ feedback });
+  dbhan = await checkedAsyncCall(connectUtility(driver, storedConnection, 'app'));
+  dbhan.feedback = feedback => setStatus({ feedback });
   await checkedAsyncCall(readVersion());
   if (structure) {
     analysedStructure = structure;
@@ -138,7 +136,7 @@ async function handleConnect({ connection, structure, globalSettings }) {
 }
 
 function waitConnected() {
-  if (systemConnection) return Promise.resolve();
+  if (dbhan) return Promise.resolve();
   return new Promise((resolve, reject) => {
     afterConnectCallbacks.push([resolve, reject]);
   });
@@ -163,7 +161,7 @@ async function handleRunScript({ msgid, sql, useTransaction }, skipReadonlyCheck
   const driver = requireEngineDriver(storedConnection);
   try {
     if (!skipReadonlyCheck) ensureExecuteCustomScript(driver);
-    await driver.script(systemConnection, sql, { useTransaction });
+    await driver.script(dbhan, sql, { useTransaction });
     process.send({ msgtype: 'response', msgid });
   } catch (err) {
     process.send({ msgtype: 'response', msgid, errorMessage: err.message });
@@ -175,7 +173,7 @@ async function handleRunOperation({ msgid, operation, useTransaction }, skipRead
   const driver = requireEngineDriver(storedConnection);
   try {
     if (!skipReadonlyCheck) ensureExecuteCustomScript(driver);
-    await driver.operation(systemConnection, operation, { useTransaction });
+    await driver.operation(dbhan, operation, { useTransaction });
     process.send({ msgtype: 'response', msgid });
   } catch (err) {
     process.send({ msgtype: 'response', msgid, errorMessage: err.message });
@@ -188,7 +186,7 @@ async function handleQueryData({ msgid, sql }, skipReadonlyCheck = false) {
   try {
     if (!skipReadonlyCheck) ensureExecuteCustomScript(driver);
     // console.log(sql);
-    const res = await driver.query(systemConnection, sql);
+    const res = await driver.query(dbhan, sql);
     process.send({ msgtype: 'response', msgid, ...res });
   } catch (err) {
     process.send({ msgtype: 'response', msgid, errorMessage: err.message || 'Error executing SQL script' });
@@ -202,52 +200,64 @@ async function handleSqlSelect({ msgid, select }) {
   return handleQueryData({ msgid, sql: dmp.s }, true);
 }
 
-async function handleDriverDataCore(msgid, callMethod) {
+async function handleDriverDataCore(msgid, callMethod, { logName }) {
   await waitConnected();
   const driver = requireEngineDriver(storedConnection);
   try {
     const result = await callMethod(driver);
     process.send({ msgtype: 'response', msgid, result });
   } catch (err) {
+    logger.error(err, `Error when handling message ${logName}`);
     process.send({ msgtype: 'response', msgid, errorMessage: err.message });
   }
 }
 
+async function handleSchemaList({ msgid }) {
+  logger.debug('Loading schema list');
+  return handleDriverDataCore(msgid, driver => driver.listSchemas(dbhan), { logName: 'listSchemas' });
+}
+
 async function handleCollectionData({ msgid, options }) {
-  return handleDriverDataCore(msgid, driver => driver.readCollection(systemConnection, options));
+  return handleDriverDataCore(msgid, driver => driver.readCollection(dbhan, options), { logName: 'readCollection' });
 }
 
 async function handleLoadKeys({ msgid, root, filter }) {
-  return handleDriverDataCore(msgid, driver => driver.loadKeys(systemConnection, root, filter));
+  return handleDriverDataCore(msgid, driver => driver.loadKeys(dbhan, root, filter), { logName: 'loadKeys' });
 }
 
 async function handleExportKeys({ msgid, options }) {
-  return handleDriverDataCore(msgid, driver => driver.exportKeys(systemConnection, options));
+  return handleDriverDataCore(msgid, driver => driver.exportKeys(dbhan, options), { logName: 'exportKeys' });
 }
 
 async function handleLoadKeyInfo({ msgid, key }) {
-  return handleDriverDataCore(msgid, driver => driver.loadKeyInfo(systemConnection, key));
+  return handleDriverDataCore(msgid, driver => driver.loadKeyInfo(dbhan, key), { logName: 'loadKeyInfo' });
 }
 
 async function handleCallMethod({ msgid, method, args }) {
-  return handleDriverDataCore(msgid, driver => {
-    if (storedConnection.isReadOnly) {
-      throw new Error('Connection is read only, cannot call custom methods');
-    }
-
-    ensureExecuteCustomScript(driver);
-    return driver.callMethod(systemConnection, method, args);
-  });
+  return handleDriverDataCore(
+    msgid,
+    driver => {
+      if (storedConnection.isReadOnly) {
+        throw new Error('Connection is read only, cannot call custom methods');
+      }
+
+      ensureExecuteCustomScript(driver);
+      return driver.callMethod(dbhan, method, args);
+    },
+    { logName: `callMethod:${method}` }
+  );
 }
 
 async function handleLoadKeyTableRange({ msgid, key, cursor, count }) {
-  return handleDriverDataCore(msgid, driver => driver.loadKeyTableRange(systemConnection, key, cursor, count));
+  return handleDriverDataCore(msgid, driver => driver.loadKeyTableRange(dbhan, key, cursor, count), {
+    logName: 'loadKeyTableRange',
+  });
 }
 
 async function handleLoadFieldValues({ msgid, schemaName, pureName, field, search }) {
-  return handleDriverDataCore(msgid, driver =>
-    driver.loadFieldValues(systemConnection, { schemaName, pureName }, field, search)
-  );
+  return handleDriverDataCore(msgid, driver => driver.loadFieldValues(dbhan, { schemaName, pureName }, field, search), {
+    logName: 'loadFieldValues',
+  });
 }
 
 function ensureExecuteCustomScript(driver) {
@@ -264,7 +274,7 @@ async function handleUpdateCollection({ msgid, changeSet }) {
   const driver = requireEngineDriver(storedConnection);
   try {
     ensureExecuteCustomScript(driver);
-    const result = await driver.updateCollection(systemConnection, changeSet);
+    const result = await driver.updateCollection(dbhan, changeSet);
     process.send({ msgtype: 'response', msgid, result });
   } catch (err) {
     process.send({ msgtype: 'response', msgid, errorMessage: err.message });
@@ -277,7 +287,7 @@ async function handleSqlPreview({ msgid, objects, options }) {
 
   try {
     const dmp = driver.createDumper();
-    const generator = new SqlGenerator(analysedStructure, options, objects, dmp, driver, systemConnection);
+    const generator = new SqlGenerator(analysedStructure, options, objects, dmp, driver, dbhan);
 
     await generator.dump();
     process.send({ msgtype: 'response', msgid, sql: dmp.s, isTruncated: generator.isTruncated });
@@ -297,7 +307,7 @@ async function handleGenerateDeploySql({ msgid, modelFolder }) {
 
   try {
     const res = await generateDeploySql({
-      systemConnection,
+      systemConnection: dbhan,
       connection: storedConnection,
       analysedStructure,
       modelFolder,
@@ -337,6 +347,7 @@ const messageHandlers = {
   loadFieldValues: handleLoadFieldValues,
   sqlSelect: handleSqlSelect,
   exportKeys: handleExportKeys,
+  schemaList: handleSchemaList,
   // runCommand: handleRunCommand,
 };
 

package/src/shell/importDatabase.js

@@ -16,7 +16,7 @@ class ImportStream extends stream.Transform {
   }
   async _transform(chunk, encoding, cb) {
     try {
-      await this.driver.script(this.pool, chunk);
+      await this.driver.script(this.pool, chunk, { queryOptions: { importSqlDump: true } });
     } catch (err) {
       this.emit('error', err.message);
     }
@@ -47,7 +47,9 @@ async function importDatabase({ connection = undefined, systemConnection = undef
   const pool = systemConnection || (await connectUtility(driver, connection, 'write'));
   logger.info(`Connected.`);
 
+  logger.info(`Input file: ${inputFile}`);
   const downloadedFile = await download(inputFile);
+  logger.info(`Downloaded file: ${downloadedFile}`);
 
   const fileStream = fs.createReadStream(downloadedFile, 'utf-8');
   const splittedStream = splitQueryStream(fileStream, driver.getQuerySplitterOptions('script'));

package/src/shell/index.js

@@ -6,7 +6,7 @@ const copyStream = require('./copyStream');
 const fakeObjectReader = require('./fakeObjectReader');
 const consoleObjectWriter = require('./consoleObjectWriter');
 const jsonLinesWriter = require('./jsonLinesWriter');
-const jsonArrayWriter = require('./jsonArrayWriter');
+const jsonWriter = require('./jsonWriter');
 const jsonLinesReader = require('./jsonLinesReader');
 const sqlDataWriter = require('./sqlDataWriter');
 const jslDataReader = require('./jslDataReader');
@@ -29,6 +29,7 @@ const modifyJsonLinesReader = require('./modifyJsonLinesReader');
 const dataDuplicator = require('./dataDuplicator');
 const dbModelToJson = require('./dbModelToJson');
 const jsonToDbModel = require('./jsonToDbModel');
+const jsonReader = require('./jsonReader');
 
 const dbgateApi = {
   queryReader,
@@ -37,8 +38,9 @@ const dbgateApi = {
   tableReader,
   copyStream,
   jsonLinesWriter,
-  jsonArrayWriter,
   jsonLinesReader,
+  jsonReader,
+  jsonWriter,
   sqlDataWriter,
   fakeObjectReader,
   consoleObjectWriter,

package/src/shell/jsonLinesReader.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const stream = require('stream');
 const byline = require('byline');
 const { getLogger } = require('dbgate-tools');
+const download = require('./download');
 const logger = getLogger('jsonLinesReader');
 
 class ParseStream extends stream.Transform {
@@ -35,8 +36,10 @@ class ParseStream extends stream.Transform {
 async function jsonLinesReader({ fileName, encoding = 'utf-8', limitRows = undefined }) {
   logger.info(`Reading file ${fileName}`);
 
+  const downloadedFile = await download(fileName);
+
   const fileStream = fs.createReadStream(
-    fileName,
+    downloadedFile,
     // @ts-ignore
     encoding
   );

package/src/shell/jsonReader.js

@@ -0,0 +1,84 @@
+const fs = require('fs');
+const stream = require('stream');
+const byline = require('byline');
+const { getLogger } = require('dbgate-tools');
+const { parser } = require('stream-json');
+const { pick } = require('stream-json/filters/Pick');
+const { streamArray } = require('stream-json/streamers/StreamArray');
+const { streamObject } = require('stream-json/streamers/StreamObject');
+const download = require('./download');
+
+const logger = getLogger('jsonReader');
+
+
+class ParseStream extends stream.Transform {
+  constructor({ limitRows, jsonStyle, keyField }) {
+    super({ objectMode: true });
+    this.wasHeader = false;
+    this.limitRows = limitRows;
+    this.jsonStyle = jsonStyle;
+    this.keyField = keyField || '_key';
+    this.rowsWritten = 0;
+  }
+  _transform(chunk, encoding, done) {
+    if (!this.wasHeader) {
+      this.push({
+        __isStreamHeader: true,
+        __isDynamicStructure: true,
+      });
+
+      this.wasHeader = true;
+    }
+    if (!this.limitRows || this.rowsWritten < this.limitRows) {
+      if (this.jsonStyle === 'object') {
+        this.push({
+          ...chunk.value,
+          [this.keyField]: chunk.key,
+        });
+      } else {
+        this.push(chunk.value);
+      }
+
+      this.rowsWritten += 1;
+    }
+    done();
+  }
+}
+
+async function jsonReader({
+  fileName,
+  jsonStyle,
+  keyField = '_key',
+  rootField = null,
+  encoding = 'utf-8',
+  limitRows = undefined,
+}) {
+  logger.info(`Reading file ${fileName}`);
+
+  const downloadedFile = await download(fileName);
+  const fileStream = fs.createReadStream(
+    downloadedFile,
+    // @ts-ignore
+    encoding
+  );
+  const parseJsonStream = parser();
+  fileStream.pipe(parseJsonStream);
+
+  const parseStream = new ParseStream({ limitRows, jsonStyle, keyField });
+
+  const tramsformer = jsonStyle === 'object' ? streamObject() : streamArray();
+
+  if (rootField) {
+    const filterStream = pick({ filter: rootField });
+    parseJsonStream.pipe(filterStream);
+    filterStream.pipe(tramsformer);
+  } else {
+    parseJsonStream.pipe(tramsformer);
+  }
+
+  tramsformer.pipe(parseStream);
+
+  return parseStream;
+}
+
+module.exports = jsonReader;

package/src/shell/jsonWriter.js

@@ -0,0 +1,97 @@
+const { getLogger } = require('dbgate-tools');
+const fs = require('fs');
+const stream = require('stream');
+const _ = require('lodash');
+
+const logger = getLogger('jsonArrayWriter');
+
+class StringifyStream extends stream.Transform {
+  constructor({ jsonStyle, keyField, rootField }) {
+    super({ objectMode: true });
+    this.wasHeader = false;
+    this.wasRecord = false;
+    this.jsonStyle = jsonStyle;
+    this.keyField = keyField || '_key';
+    this.rootField = rootField;
+  }
+  _transform(chunk, encoding, done) {
+    let skip = false;
+
+    if (!this.wasHeader) {
+      skip = chunk.__isStreamHeader;
+      this.wasHeader = true;
+    }
+    if (!skip) {
+      if (!this.wasRecord) {
+        if (this.rootField) {
+          if (this.jsonStyle === 'object') {
+            this.push(`{"${this.rootField}": {\n`);
+          } else {
+            this.push(`{"${this.rootField}": [\n`);
+          }
+        } else {
+          if (this.jsonStyle === 'object') {
+            this.push('{\n');
+          } else {
+            this.push('[\n');
+          }
+        }
+      } else {
+        this.push(',\n');
+      }
+      this.wasRecord = true;
+
+      if (this.jsonStyle === 'object') {
+        const key = chunk[this.keyField] ?? chunk[Object.keys(chunk)[0]];
+        this.push(`"${key}": ${JSON.stringify(_.omit(chunk, [this.keyField]))}`);
+      } else {
+        this.push(JSON.stringify(chunk));
+      }
+    }
+    done();
+  }
+
+  _flush(done) {
+    if (!this.wasRecord) {
+      if (this.rootField) {
+        if (this.jsonStyle === 'object') {
+          this.push(`{"${this.rootField}": {}}\n`);
+        } else {
+          this.push(`{"${this.rootField}": []}\n`);
+        }
+      } else {
+        if (this.jsonStyle === 'object') {
+          this.push('{}\n');
+        } else {
+          this.push('[]\n');
+        }
+      }
+    } else {
+      if (this.rootField) {
+        if (this.jsonStyle === 'object') {
+          this.push('\n}}\n');
+        } else {
+          this.push('\n]}\n');
+        }
+      } else {
+        if (this.jsonStyle === 'object') {
+          this.push('\n}\n');
+        } else {
+          this.push('\n]\n');
+        }
+      }
+    }
+    done();
+  }
+}
+
+async function jsonWriter({ fileName, jsonStyle, keyField = '_key', rootField, encoding = 'utf-8' }) {
+  logger.info(`Writing file ${fileName}`);
+  const stringify = new StringifyStream({ jsonStyle, keyField, rootField });
+  const fileStream = fs.createWriteStream(fileName, encoding);
+  stringify.pipe(fileStream);
+  stringify['finisher'] = fileStream;
+  return stringify;
+}
+
+module.exports = jsonWriter;

package/src/shell/modifyJsonLinesReader.js

@@ -66,7 +66,7 @@ class ParseStream extends stream.Transform {
                 ...obj,
                 ...update.fields,
               },
-              (v, k) => v.$$undefined$$
+              (v, k) => v?.$$undefined$$
             );
           }
         }

package/src/shell/runScript.js

@@ -11,7 +11,7 @@ async function runScript(func) {
     await func();
     process.exit(0);
   } catch (err) {
-    logger.error({ err }, `Error running script: ${err.message}`);
+    logger.error({ err }, `Error running script: ${err.message || err}`);
     process.exit(1);
   }
 }

package/src/shell/jsonArrayWriter.js

@@ -1,52 +0,0 @@
-const { getLogger } = require('dbgate-tools');
-const fs = require('fs');
-const stream = require('stream');
-
-const logger = getLogger('jsonArrayWriter');
-
-class StringifyStream extends stream.Transform {
-  constructor() {
-    super({ objectMode: true });
-    this.wasHeader = false;
-    this.wasRecord = false;
-  }
-  _transform(chunk, encoding, done) {
-    let skip = false;
-
-    if (!this.wasHeader) {
-      skip = chunk.__isStreamHeader;
-      this.wasHeader = true;
-    }
-    if (!skip) {
-      if (!this.wasRecord) {
-        this.push('[\n');
-      } else {
-        this.push(',\n');
-      }
-      this.wasRecord = true;
-
-      this.push(JSON.stringify(chunk));
-    }
-    done();
-  }
-
-  _flush(done) {
-    if (!this.wasRecord) {
-      this.push('[]\n');
-    } else {
-      this.push('\n]\n');
-    }
-    done();
-  }
-}
-
-async function jsonArrayWriter({ fileName, encoding = 'utf-8' }) {
-  logger.info(`Writing file ${fileName}`);
-  const stringify = new StringifyStream();
-  const fileStream = fs.createWriteStream(fileName, encoding);
-  stringify.pipe(fileStream);
-  stringify['finisher'] = fileStream;
-  return stringify;
-}
-
-module.exports = jsonArrayWriter;