dbgate-api-premium 5.5.7-alpha.45

package/src/utility/connectUtility.js

@@ -0,0 +1,111 @@
+const fs = require('fs-extra');
+const { decryptConnection } = require('./crypting');
+const { getSshTunnelProxy } = require('./sshTunnelProxy');
+const platformInfo = require('../utility/platformInfo');
+const connections = require('../controllers/connections');
+const _ = require('lodash');
+
+async function loadConnection(driver, storedConnection, connectionMode) {
+  const { allowShellConnection, allowConnectionFromEnvVariables } = platformInfo;
+
+  if (connectionMode == 'app') {
+    return storedConnection;
+  }
+
+  if (storedConnection._id || !allowShellConnection) {
+    if (!storedConnection._id) {
+      throw new Error('Missing connection _id');
+    }
+
+    await connections._init();
+    const loaded = await connections.getCore({ conid: storedConnection._id });
+    const loadedWithDb = {
+      ...loaded,
+      database: storedConnection.database,
+    };
+
+    if (loaded.isReadOnly) {
+      if (connectionMode == 'read') return loadedWithDb;
+      if (connectionMode == 'write') throw new Error('Cannot write readonly connection');
+      if (connectionMode == 'script') {
+        if (driver.readOnlySessions) return loadedWithDb;
+        throw new Error('Cannot write readonly connection');
+      }
+    }
+    return loadedWithDb;
+  }
+
+  if (allowConnectionFromEnvVariables) {
+    return _.mapValues(storedConnection, (value, key) => {
+      if (_.isString(value) && value.startsWith('${') && value.endsWith('}')) {
+        return process.env[value.slice(2, -1)];
+      }
+      return value;
+    });
+  }
+
+  return storedConnection;
+}
+
+async function connectUtility(driver, storedConnection, connectionMode, additionalOptions = null) {
+  const connectionLoaded = await loadConnection(driver, storedConnection, connectionMode);
+
+  const connection = {
+    database: connectionLoaded.defaultDatabase,
+    ...decryptConnection(connectionLoaded),
+  };
+
+  if (!connection.port && driver.defaultPort) connection.port = driver.defaultPort.toString();
+
+  if (connection.useSshTunnel) {
+    const tunnel = await getSshTunnelProxy(connection);
+    if (tunnel.state == 'error') {
+      throw new Error(tunnel.message);
+    }
+
+    connection.server = 'localhost';
+    connection.port = tunnel.localPort;
+  }
+
+  // SSL functionality - copied from https://github.com/beekeeper-studio/beekeeper-studio
+  if (connection.useSsl) {
+    connection.ssl = {};
+
+    if (connection.sslCaFile) {
+      connection.ssl.ca = await fs.readFile(connection.sslCaFile);
+      connection.ssl.sslCaFile = connection.sslCaFile;
+    }
+
+    if (connection.sslCertFile) {
+      connection.ssl.cert = await fs.readFile(connection.sslCertFile);
+      connection.ssl.sslCertFile = connection.sslCertFile;
+    }
+
+    if (connection.sslKeyFile) {
+      connection.ssl.key = await fs.readFile(connection.sslKeyFile);
+      connection.ssl.sslKeyFile = connection.sslKeyFile;
+    }
+
+    if (connection.sslCertFilePassword) {
+      connection.ssl.password = connection.sslCertFilePassword;
+    }
+
+    if (!connection.ssl.key && !connection.ssl.ca && !connection.ssl.cert) {
+      // TODO: provide this as an option in settings
+      // or per-connection as 'reject self-signed certs'
+      // How it works:
+      // if false, cert can be self-signed
+      // if true, has to be from a public CA
+      // Heroku certs are self-signed.
+      // if you provide ca/cert/key files, it overrides this
+      connection.ssl.rejectUnauthorized = false;
+    } else {
+      connection.ssl.rejectUnauthorized = connection.sslRejectUnauthorized;
+    }
+  }
+
+  const conn = await driver.connect({ ...connection, ...additionalOptions });
+  return conn;
+}
+
+module.exports = connectUtility;

package/src/utility/crypting.js

@@ -0,0 +1,105 @@
+const crypto = require('crypto');
+const simpleEncryptor = require('simple-encryptor');
+const fs = require('fs');
+const path = require('path');
+const _ = require('lodash');
+
+const { datadir } = require('./directories');
+
+const defaultEncryptionKey = 'mQAUaXhavRGJDxDTXSCg7Ej0xMmGCrx6OKA07DIMBiDcYYkvkaXjTAzPUEHEHEf9';
+
+let _encryptionKey = null;
+
+function loadEncryptionKey() {
+  if (_encryptionKey) {
+    return _encryptionKey;
+  }
+  const encryptor = simpleEncryptor.createEncryptor(defaultEncryptionKey);
+
+  const keyFile = path.join(datadir(), '.key');
+
+  if (!fs.existsSync(keyFile)) {
+    const generatedKey = crypto.randomBytes(32);
+    const newKey = generatedKey.toString('hex');
+    const result = {
+      encryptionKey: newKey,
+    };
+    fs.writeFileSync(keyFile, encryptor.encrypt(result), 'utf-8');
+  }
+
+  const encryptedData = fs.readFileSync(keyFile, 'utf-8');
+  const data = encryptor.decrypt(encryptedData);
+  _encryptionKey = data['encryptionKey'];
+  return _encryptionKey;
+}
+
+let _encryptor = null;
+
+function getEncryptor() {
+  if (_encryptor) {
+    return _encryptor;
+  }
+  _encryptor = simpleEncryptor.createEncryptor(loadEncryptionKey());
+  return _encryptor;
+}
+
+function encryptPasswordField(connection, field) {
+  if (
+    connection &&
+    connection[field] &&
+    !connection[field].startsWith('crypt:') &&
+    connection.passwordMode != 'saveRaw'
+  ) {
+    return {
+      ...connection,
+      [field]: 'crypt:' + getEncryptor().encrypt(connection[field]),
+    };
+  }
+  return connection;
+}
+
+function decryptPasswordField(connection, field) {
+  if (connection && connection[field] && connection[field].startsWith('crypt:')) {
+    return {
+      ...connection,
+      [field]: getEncryptor().decrypt(connection[field].substring('crypt:'.length)),
+    };
+  }
+  return connection;
+}
+
+function encryptConnection(connection) {
+  connection = encryptPasswordField(connection, 'password');
+  connection = encryptPasswordField(connection, 'sshPassword');
+  connection = encryptPasswordField(connection, 'sshKeyfilePassword');
+  return connection;
+}
+
+function maskConnection(connection) {
+  if (!connection) return connection;
+  return _.omit(connection, ['password', 'sshPassword', 'sshKeyfilePassword']);
+}
+
+function decryptConnection(connection) {
+  connection = decryptPasswordField(connection, 'password');
+  connection = decryptPasswordField(connection, 'sshPassword');
+  connection = decryptPasswordField(connection, 'sshKeyfilePassword');
+  return connection;
+}
+
+function pickSafeConnectionInfo(connection) {
+  return _.mapValues(connection, (v, k) => {
+    if (k == 'engine' || k == 'port' || k == 'authType' || k == 'sshMode' || k == 'passwordMode') return v;
+    if (v === null || v === true || v === false) return v;
+    if (v) return '***';
+    return undefined;
+  });
+}
+
+module.exports = {
+  loadEncryptionKey,
+  encryptConnection,
+  decryptConnection,
+  maskConnection,
+  pickSafeConnectionInfo,
+};

package/src/utility/diff2htmlPage.js

@@ -0,0 +1,8 @@
+const diff2htmlCss =
+  '.d2h-d-none{display:none}.d2h-wrapper{text-align:left}.d2h-file-header{background-color:#f7f7f7;border-bottom:1px solid #d8d8d8;font-family:Source Sans Pro,Helvetica Neue,Helvetica,Arial,sans-serif;height:35px;padding:5px 10px}.d2h-file-header,.d2h-file-stats{display:-webkit-box;display:-ms-flexbox;display:flex}.d2h-file-stats{font-size:14px;margin-left:auto}.d2h-lines-added{border:1px solid #b4e2b4;border-radius:5px 0 0 5px;color:#399839;padding:2px;text-align:right;vertical-align:middle}.d2h-lines-deleted{border:1px solid #e9aeae;border-radius:0 5px 5px 0;color:#c33;margin-left:1px;padding:2px;text-align:left;vertical-align:middle}.d2h-file-name-wrapper{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;font-size:15px;width:100%}.d2h-file-name{overflow-x:hidden;text-overflow:ellipsis;white-space:nowrap}.d2h-file-wrapper{border:1px solid #ddd;border-radius:3px;margin-bottom:1em}.d2h-file-collapse{-webkit-box-pack:end;-ms-flex-pack:end;-webkit-box-align:center;-ms-flex-align:center;align-items:center;border:1px solid #ddd;border-radius:3px;cursor:pointer;display:none;font-size:12px;justify-content:flex-end;padding:4px 8px}.d2h-file-collapse.d2h-selected{background-color:#c8e1ff}.d2h-file-collapse-input{margin:0 4px 0 0}.d2h-diff-table{border-collapse:collapse;font-family:Menlo,Consolas,monospace;font-size:13px;width:100%}.d2h-files-diff{width:100%}.d2h-file-diff{overflow-y:hidden}.d2h-file-side-diff{display:inline-block;margin-bottom:-8px;margin-right:-4px;overflow-x:scroll;overflow-y:hidden;width:50%}.d2h-code-line{padding:0 8em}.d2h-code-line,.d2h-code-side-line{display:inline-block;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;white-space:nowrap;width:100%}.d2h-code-side-line{padding:0 4.5em}.d2h-code-line-ctn{word-wrap:normal;background:none;display:inline-block;padding:0;-webkit-user-select:text;-moz-user-select:text;-ms-user-select:text;user-select:text;vertical-align:middle;white-space:pre;width:100%}.d2h-code-line del,.d2h-code-side-line del{background-color:#ffb6ba}.d2h-code-line del,.d2h-code-line ins,.d2h-code-side-line del,.d2h-code-side-line ins{border-radius:.2em;display:inline-block;margin-top:-1px;text-decoration:none;vertical-align:middle}.d2h-code-line ins,.d2h-code-side-line ins{background-color:#97f295;text-align:left}.d2h-code-line-prefix{word-wrap:normal;background:none;display:inline;padding:0;white-space:pre}.line-num1{float:left}.line-num1,.line-num2{-webkit-box-sizing:border-box;box-sizing:border-box;overflow:hidden;padding:0 .5em;text-overflow:ellipsis;width:3.5em}.line-num2{float:right}.d2h-code-linenumber{background-color:#fff;border:solid #eee;border-width:0 1px;-webkit-box-sizing:border-box;box-sizing:border-box;color:rgba(0,0,0,.3);cursor:pointer;display:inline-block;position:absolute;text-align:right;width:7.5em}.d2h-code-linenumber:after{content:"\200b"}.d2h-code-side-linenumber{background-color:#fff;border:solid #eee;border-width:0 1px;-webkit-box-sizing:border-box;box-sizing:border-box;color:rgba(0,0,0,.3);cursor:pointer;display:inline-block;overflow:hidden;padding:0 .5em;position:absolute;text-align:right;text-overflow:ellipsis;width:4em}.d2h-code-side-linenumber:after{content:"\200b"}.d2h-code-side-emptyplaceholder,.d2h-emptyplaceholder{background-color:#f1f1f1;border-color:#e1e1e1}.d2h-code-line-prefix,.d2h-code-linenumber,.d2h-code-side-linenumber,.d2h-emptyplaceholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.d2h-code-linenumber,.d2h-code-side-linenumber{direction:rtl}.d2h-del{background-color:#fee8e9;border-color:#e9aeae}.d2h-ins{background-color:#dfd;border-color:#b4e2b4}.d2h-info{background-color:#f8fafd;border-color:#d5e4f2;color:rgba(0,0,0,.3)}.d2h-file-diff .d2h-del.d2h-change{background-color:#fdf2d0}.d2h-file-diff .d2h-ins.d2h-change{background-color:#ded}.d2h-file-list-wrapper{margin-bottom:10px}.d2h-file-list-wrapper a{color:#3572b0;text-decoration:none}.d2h-file-list-wrapper a:visited{color:#3572b0}.d2h-file-list-header{text-align:left}.d2h-file-list-title{font-weight:700}.d2h-file-list-line{display:-webkit-box;display:-ms-flexbox;display:flex;text-align:left}.d2h-file-list{display:block;list-style:none;margin:0;padding:0}.d2h-file-list>li{border-bottom:1px solid #ddd;margin:0;padding:5px 10px}.d2h-file-list>li:last-child{border-bottom:none}.d2h-file-switch{cursor:pointer;display:none;font-size:10px}.d2h-icon{fill:currentColor;margin-right:10px;vertical-align:middle}.d2h-deleted{color:#c33}.d2h-added{color:#399839}.d2h-changed{color:#d0b44c}.d2h-moved{color:#3572b0}.d2h-tag{background-color:#fff;display:-webkit-box;display:-ms-flexbox;display:flex;font-size:10px;margin-left:5px;padding:0 2px}.d2h-deleted-tag{border:1px solid #c33}.d2h-added-tag{border:1px solid #399839}.d2h-changed-tag{border:1px solid #d0b44c}.d2h-moved-tag{border:1px solid #3572b0}';
+
+function diff2htmlPage(content) {
+  return `<html><head><style>${diff2htmlCss}</style><body>${content}</body></html>`;
+}
+
+module.exports = diff2htmlPage;

package/src/utility/directories.js

@@ -0,0 +1,179 @@
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const _ = require('lodash');
+const cleanDirectory = require('./cleanDirectory');
+const platformInfo = require('./platformInfo');
+const processArgs = require('./processArgs');
+const consoleObjectWriter = require('../shell/consoleObjectWriter');
+const { getLogger } = require('dbgate-tools');
+
+let logsFilePath;
+
+const createDirectories = {};
+const ensureDirectory = (dir, clean) => {
+  if (!createDirectories[dir]) {
+    if (clean && fs.existsSync(dir) && !platformInfo.isForkedApi) {
+      getLogger('directories').info(`Cleaning directory ${dir}`);
+      cleanDirectory(dir, _.isNumber(clean) ? clean : null);
+    }
+    if (!fs.existsSync(dir)) {
+      getLogger('directories').info(`Creating directory ${dir}`);
+      fs.mkdirSync(dir);
+    }
+    createDirectories[dir] = true;
+  }
+};
+
+function datadirCore() {
+  if (process.env.WORKSPACE_DIR) {
+    return process.env.WORKSPACE_DIR;
+  }
+  if (processArgs.workspaceDir) {
+    return processArgs.workspaceDir;
+  }
+  return path.join(os.homedir(), '.dbgate');
+}
+
+function datadir() {
+  const dir = datadirCore();
+  ensureDirectory(dir);
+
+  return dir;
+}
+
+const dirFunc =
+  (dirname, clean, subdirs = []) =>
+  () => {
+    const dir = path.join(datadir(), dirname);
+    ensureDirectory(dir, clean);
+    for (const subdir of subdirs) {
+      ensureDirectory(path.join(dir, subdir), false);
+    }
+
+    return dir;
+  };
+
+const jsldir = dirFunc('jsl', true);
+const rundir = dirFunc('run', true);
+const uploadsdir = dirFunc('uploads', true);
+const pluginsdir = dirFunc('plugins');
+const archivedir = dirFunc('archive', false, ['default']);
+const appdir = dirFunc('apps');
+const filesdir = dirFunc('files');
+const logsdir = dirFunc('logs', 3600 * 24 * 7);
+
+function packagedPluginsDir() {
+  // console.log('CALL DIR FROM', new Error('xxx').stack);
+  // console.log('__dirname', __dirname);
+  // console.log('platformInfo.isElectronBundle', platformInfo.isElectronBundle);
+  // console.log('platformInfo.isForkedApi', platformInfo.isForkedApi);
+  if (platformInfo.isDevMode) {
+    return path.resolve(__dirname, '../../../../plugins');
+  }
+  if (platformInfo.isBuiltWebMode) {
+    return path.resolve(__dirname, '../../plugins');
+  }
+  if (platformInfo.isDocker) {
+    return '/home/dbgate-docker/plugins';
+  }
+  if (platformInfo.isAwsUbuntuLayout) {
+    return '/home/ubuntu/build/plugins';
+  }
+  if (platformInfo.isNpmDist) {
+    // node_modules
+    return global['PLUGINS_DIR'];
+  }
+  if (processArgs.pluginsDir) {
+    return processArgs.pluginsDir;
+  }
+  if (platformInfo.isElectronBundle) {
+    return path.resolve(__dirname, '../../plugins');
+
+    // if (platformInfo.isForkedApi) {
+    //   return path.resolve(__dirname, '../plugins');
+    // } else {
+    //   return path.resolve(__dirname, '../../plugins');
+    // }
+  }
+  return null;
+}
+
+const packagedPluginList =
+  packagedPluginsDir() != null ? fs.readdirSync(packagedPluginsDir()).filter(x => x.startsWith('dbgate-plugin-')) : [];
+
+function getPluginBackendPath(packageName) {
+  if (packagedPluginList.includes(packageName)) {
+    if (platformInfo.isDevMode) {
+      return path.join(packagedPluginsDir(), packageName, 'src', 'backend', 'index.js');
+    }
+    return path.join(packagedPluginsDir(), packageName, 'dist', 'backend.js');
+  }
+
+  return path.join(pluginsdir(), packageName, 'dist', 'backend.js');
+}
+
+let archiveLinksCache = {};
+
+function resolveArchiveFolder(folder) {
+  if (folder.endsWith('.link')) {
+    if (!archiveLinksCache[folder]) {
+      archiveLinksCache[folder] = fs.readFileSync(path.join(archivedir(), folder), 'utf-8');
+    }
+    return archiveLinksCache[folder];
+  }
+  return path.join(archivedir(), folder);
+}
+
+function clearArchiveLinksCache() {
+  archiveLinksCache = {};
+}
+
+function migrateDataDir() {
+  if (process.env.WORKSPACE_DIR) {
+    return;
+  }
+  if (processArgs.workspaceDir) {
+    return;
+  }
+
+  try {
+    const oldDir = path.join(os.homedir(), 'dbgate-data');
+    const newDir = path.join(os.homedir(), '.dbgate');
+    if (fs.existsSync(oldDir) && !fs.existsSync(newDir)) {
+      fs.renameSync(oldDir, newDir);
+    }
+  } catch (err) {
+    getLogger('directories').error({ err }, 'Error migrating data dir');
+  }
+}
+
+function setLogsFilePath(value) {
+  logsFilePath = value;
+}
+
+function getLogsFilePath() {
+  return logsFilePath;
+}
+
+migrateDataDir();
+
+module.exports = {
+  datadir,
+  jsldir,
+  rundir,
+  uploadsdir,
+  archivedir,
+  appdir,
+  ensureDirectory,
+  pluginsdir,
+  filesdir,
+  logsdir,
+  packagedPluginsDir,
+  packagedPluginList,
+  getPluginBackendPath,
+  resolveArchiveFolder,
+  clearArchiveLinksCache,
+  getLogsFilePath,
+  setLogsFilePath,
+};

package/src/utility/downloadPackage.js

@@ -0,0 +1,51 @@
+const crypto = require('crypto');
+// const pacote = require('pacote');
+const axios = require('axios');
+// const tarballExtract = require('tarball-extract');
+const path = require('path');
+const fs = require('fs');
+const zlib = require('zlib');
+const tar = require('tar');
+const ncp = require('ncp').ncp;
+const { uploadsdir } = require('./directories');
+const { downloadFile } = require('./downloader');
+
+function extractTarball(tmpFile, destination) {
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(tmpFile)
+      .pipe(zlib.createGunzip())
+      .pipe(tar.extract({ cwd: destination }))
+      .on('error', err => reject(err))
+      .on('end', () => resolve());
+  });
+}
+
+function copyDirectory(source, target) {
+  return new Promise((resolve, reject) => {
+    ncp(source, target, err => {
+      if (err) reject(err);
+      resolve();
+    });
+  });
+}
+
+async function downloadPackage(packageName, directory) {
+  // await pacote.extract(packageName, directory);
+  const infoResp = await axios.default.get(`https://registry.npmjs.org/${packageName}`);
+
+  const { latest } = infoResp.data['dist-tags'] || {};
+  if (!latest) return false;
+
+  const tarball = infoResp.data.versions[latest].dist.tarball;
+
+  const tmpFile = path.join(uploadsdir(), crypto.randomUUID() + '.tgz');
+  await downloadFile(tarball, tmpFile);
+  const tmpDir = path.join(uploadsdir(), crypto.randomUUID());
+  fs.mkdirSync(tmpDir);
+  await extractTarball(tmpFile, tmpDir);
+  await copyDirectory(path.join(tmpDir, 'package'), directory);
+
+  return true;
+}
+
+module.exports = downloadPackage;

package/src/utility/downloader.js

@@ -0,0 +1,25 @@
+const axios = require('axios');
+const fs = require('fs');
+
+function saveStreamToFile(pipedStream, fileName) {
+  return new Promise((resolve, reject) => {
+    const fileStream = fs.createWriteStream(fileName);
+    fileStream.on('close', () => resolve());
+    pipedStream.pipe(fileStream);
+  });
+}
+
+async function downloadFile(url, file) {
+  console.log(`Downloading ${url} into ${file}`);
+  const tarballResp = await axios.default({
+    method: 'get',
+    url,
+    responseType: 'stream',
+  });
+  await saveStreamToFile(tarballResp.data, file);
+}
+
+module.exports = {
+  saveStreamToFile,
+  downloadFile,
+};

package/src/utility/exceptions.js

@@ -0,0 +1,9 @@
+class MissingCredentialsError {
+  constructor(detail) {
+    this.detail = detail;
+  }
+}
+
+module.exports = {
+  MissingCredentialsError,
+};

package/src/utility/exportDbModel.js

@@ -0,0 +1,31 @@
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+const { tableInfoToYaml } = require('dbgate-tools');
+
+async function exportDbModel(dbModel, outputDir) {
+  const { tables, views, procedures, functions, triggers, matviews } = dbModel;
+
+  if (!fs.existsSync(outputDir)) {
+    await fs.mkdir(outputDir);
+  }
+
+  for (const table of tables || []) {
+    const content = yaml.dump(tableInfoToYaml(table));
+    await fs.writeFile(path.join(outputDir, `${table.pureName}.table.yaml`), content);
+  }
+
+  async function writeList(list, ext) {
+    for (const obj of list || []) {
+      await fs.writeFile(path.join(outputDir, `${obj.pureName}.${ext}.sql`), obj.createSql);
+    }
+  }
+
+  await writeList(views, 'view');
+  await writeList(procedures, 'proc');
+  await writeList(functions, 'func');
+  await writeList(triggers, 'trigger');
+  await writeList(matviews, 'matview');
+}
+
+module.exports = exportDbModel;

package/src/utility/exportDbModelSql.js

@@ -0,0 +1,80 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { getSchemasUsedByStructure } = require('dbgate-tools');
+
+async function exportDbModelSql(dbModel, driver, outputDir, outputFile) {
+  const { tables, views, procedures, functions, triggers, matviews } = dbModel;
+
+  const usedSchemas = getSchemasUsedByStructure(dbModel);
+  const useSchemaDir = usedSchemas.length > 1;
+
+  const createdDirs = new Set();
+  async function ensureDir(dir) {
+    if (!createdDirs.has(dir)) {
+      await fs.mkdir(dir, { recursive: true });
+      createdDirs.add(dir);
+    }
+  }
+
+  async function writeLists(writeList) {
+    await writeList(views, 'views');
+    await writeList(procedures, 'procedures');
+    await writeList(functions, 'functions');
+    await writeList(triggers, 'triggers');
+    await writeList(matviews, 'matviews');
+  }
+
+  if (outputFile) {
+    const dmp = driver.createDumper();
+    for (const table of tables || []) {
+      dmp.createTable({
+        ...table,
+        foreignKeys: [],
+        dependencies: [],
+      });
+    }
+    for (const table of tables || []) {
+      for (const fk of table.foreignKeys || []) {
+        dmp.createForeignKey(fk);
+      }
+    }
+    writeLists((list, folder) => {
+      for (const obj of list || []) {
+        dmp.createSqlObject(obj);
+      }
+    });
+
+    const script = dmp.s;
+    await fs.writeFile(outputFile, script);
+  }
+
+  if (outputDir) {
+    for (const table of tables || []) {
+      const tablesDir = useSchemaDir
+        ? path.join(outputDir, table.schemaName ?? 'default', 'tables')
+        : path.join(outputDir, 'tables');
+      await ensureDir(tablesDir);
+      const dmp = driver.createDumper();
+      dmp.createTable({
+        ...table,
+        foreignKeys: [],
+        dependencies: [],
+      });
+      await fs.writeFile(path.join(tablesDir, `${table.pureName}.sql`), dmp.s);
+    }
+
+    await writeLists(async (list, folder) => {
+      for (const obj of list || []) {
+        const objdir = useSchemaDir
+          ? path.join(outputDir, obj.schemaName ?? 'default', folder)
+          : path.join(outputDir, folder);
+        await ensureDir(objdir);
+        const dmp = driver.createDumper();
+        dmp.createSqlObject(obj);
+        await fs.writeFile(path.join(objdir, `${obj.pureName}.sql`), dmp.s);
+      }
+    });
+  }
+}
+
+module.exports = exportDbModelSql;

package/src/utility/getChartExport.js

@@ -0,0 +1,55 @@
+const getChartExport = (title, config, imageFile) => {
+  return `<html>
+<meta charset='utf-8'>
+
+<head>
+    ${title ? `<title>${title}</title>` : ''}
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/3.6.0/chart.min.js" integrity="sha512-GMGzUEevhWh8Tc/njS0bDpwgxdCJLQBWG3Z2Ct+JGOpVnEmjvNx6ts4v6A2XJf1HOrtOsfhv3hBKpK9kE5z8AQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+    <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>
+
+    <style>
+        a { text-decoration: none }
+
+        .footer { 
+            float: right;
+            font-family: Arial;
+            color: #888;
+            margin-top: 10px;
+            margin-right: 10px;
+            font-size: 10pt;
+        }
+    </style>
+
+    <script>
+        const config = ${JSON.stringify(config)};
+
+        function showChart() {
+            document.getElementById('myImage').style.display = "none";
+
+            const myChart = new Chart(
+                document.getElementById('myChart'),
+                config
+            );
+        }
+    </script>
+</head>
+
+<body onload="showChart()">
+    <img src="${imageFile}" id="myImage" />
+
+    <div>
+        <canvas id="myChart"></canvas>
+    </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>
+    </div>
+</body>
+
+</html>`;
+};
+
+module.exports = getChartExport;