@dbml/cli 5.6.0-alpha.2 → 6.0.0

package/.babelrc

@@ -0,0 +1,19 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "node": "current"
+        }
+      }
+    ]
+  ],
+  "env": {
+    "test": {
+      "plugins": [
+        "@babel/plugin-transform-runtime"
+      ]
+    }
+  }
+}

package/eslint.config.ts

@@ -4,6 +4,7 @@ import { defineConfig } from 'eslint/config';
 import stylistic from '@stylistic/eslint-plugin';
 import tseslint from 'typescript-eslint';
 import tsparser from '@typescript-eslint/parser';
+import jest from 'eslint-plugin-jest';
 
 export default defineConfig(
   eslint.configs.recommended,
@@ -20,8 +21,9 @@ export default defineConfig(
         'node_modules/*',
         'lib/*',
         'bin/*',
+        'jestHelpers.js',
         'eslint.config.ts',
-        'vite.config.ts',
+        'jest.config.ts',
       ],
     },
     {
@@ -36,7 +38,6 @@ export default defineConfig(
           sourceType: 'module',
           ecmaVersion: 2018,
           project: './tsconfig.json',
-          tsconfigRootDir: import.meta.dirname,
         },
       },
       plugins: {
@@ -73,19 +74,11 @@ export default defineConfig(
       },
     },
     {
-      files: ['**/*.test.js', '**/*.spec.js', '**/*.test.ts', '**/*.spec.ts'],
+      files: ['**/*.test.js', '**/*.spec.js'],
+      ...jest.configs['flat/recommended'],
       languageOptions: {
         globals: {
-          // Vitest globals
-          describe: 'readonly',
-          it: 'readonly',
-          test: 'readonly',
-          expect: 'readonly',
-          beforeAll: 'readonly',
-          afterAll: 'readonly',
-          beforeEach: 'readonly',
-          afterEach: 'readonly',
-          vi: 'readonly',
+          ...jest.environments.globals.globals,
         },
       },
       rules: {

package/jest.config.ts

@@ -0,0 +1,14 @@
+import { type Config } from 'jest';
+
+const config: Config = {
+  testMatch: ["**/?(*.)+(spec|test).?([mc])[jt]s?(x)"],
+  preset: 'ts-jest',
+  transform: {
+    "^.+\\.js$": "babel-jest",
+  },
+  collectCoverage: true,
+  coverageReporters: ["json", "json-summary", "html", "text"],
+  coverageDirectory: "coverage",
+};
+
+export default config;

package/lib/cli/config.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  mysql: {
+    name: 'MySQL'
+  },
+  mysqlLegacy: {
+    name: 'MySQL'
+  },
+  postgres: {
+    name: 'PostgreSQL'
+  },
+  postgresLegacy: {
+    name: 'PostgreSQL'
+  },
+  mssql: {
+    name: 'SQL Server'
+  },
+  oracle: {
+    name: 'Oracle'
+  },
+  snowflake: {
+    name: 'Snowflake'
+  }
+};

package/lib/cli/connector.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = connectionHandler;
+var _core = require("@dbml/core");
+var _connector = require("@dbml/connector");
+var _figures = _interopRequireDefault(require("figures"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("./utils");
+var _outputConsolePlugin = _interopRequireDefault(require("./outputPlugins/outputConsolePlugin"));
+var _outputFilePlugin = _interopRequireDefault(require("./outputPlugins/outputFilePlugin"));
+var _logger = _interopRequireDefault(require("../helpers/logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function connectionHandler(program) {
+  try {
+    const {
+      connection,
+      databaseType
+    } = (0, _utils.getConnectionOpt)(program.args);
+    const opts = program.opts();
+    const schemaJson = await _connector.connector.fetchSchemaJson(connection, databaseType);
+    if (!opts.outFile && !opts.outDir) {
+      const res = _core.importer.generateDbml(schemaJson);
+      _outputConsolePlugin.default.write(res);
+    } else if (opts.outFile) {
+      const res = _core.importer.generateDbml(schemaJson);
+      new _outputFilePlugin.default((0, _utils.resolvePaths)(opts.outFile)).write(res);
+
+      // bearer:disable javascript_lang_logger
+      console.log(`  ${_chalk.default.green(_figures.default.main.tick)} Generated DBML file from database's connection: ${_path.default.basename(opts.outFile)}`);
+    }
+  } catch (error) {
+    _logger.default.error(error);
+  }
+}

package/lib/cli/export.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exportHandler;
+var _figures = _interopRequireDefault(require("figures"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _path = _interopRequireDefault(require("path"));
+var _core = require("@dbml/core");
+var _utils = require("./utils");
+var _validatePlugins = require("./validatePlugins/validatePlugins");
+var _outputConsolePlugin = _interopRequireDefault(require("./outputPlugins/outputConsolePlugin"));
+var _outputFilePlugin = _interopRequireDefault(require("./outputPlugins/outputFilePlugin"));
+var _config = _interopRequireDefault(require("./config"));
+var _logger = _interopRequireDefault(require("../helpers/logger"));
+var _errors = require("../errors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function exportHandler(program) {
+  try {
+    const inputPaths = (0, _utils.resolvePaths)(program.args);
+    (0, _utils.validateInputFilePaths)(inputPaths, _validatePlugins.validateFilePlugin);
+    const opts = program.opts();
+    const format = (0, _utils.getFormatOpt)(opts);
+    if (!opts.outFile && !opts.outDir) {
+      (0, _utils.generate)(inputPaths, dbml => _core.exporter.export(dbml, format), _outputConsolePlugin.default);
+    } else if (opts.outFile) {
+      const header = ['-- SQL dump generated using DBML (dbml.dbdiagram.io)\n', `-- Database: ${_config.default[format].name}\n`, `-- Generated at: ${new Date().toISOString()}\n\n`].join('');
+      (0, _utils.generate)(inputPaths, dbml => _core.exporter.export(dbml, format), new _outputFilePlugin.default((0, _utils.resolvePaths)(opts.outFile), header));
+      console.log(`  ${_chalk.default.green(_figures.default.main.tick)} Generated SQL dump file (${_config.default[format].name}): ${_path.default.basename(opts.outFile)}`);
+    }
+  } catch (error) {
+    _logger.default.error(`\n    ${error.diags.map(diag => new _errors.SyntaxError(diag.filepath, diag)).map(({
+      message
+    }) => message).join('\n    ')}`);
+  }
+}

package/lib/cli/import.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = importHandler;
+var _core = require("@dbml/core");
+var _figures = _interopRequireDefault(require("figures"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _path = _interopRequireDefault(require("path"));
+var _config = _interopRequireDefault(require("./config"));
+var _utils = require("./utils");
+var _validatePlugins = require("./validatePlugins/validatePlugins");
+var _outputConsolePlugin = _interopRequireDefault(require("./outputPlugins/outputConsolePlugin"));
+var _outputFilePlugin = _interopRequireDefault(require("./outputPlugins/outputFilePlugin"));
+var _logger = _interopRequireDefault(require("../helpers/logger"));
+var _errors = require("../errors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function importHandler(program) {
+  try {
+    const inputPaths = (0, _utils.resolvePaths)(program.args);
+    (0, _utils.validateInputFilePaths)(inputPaths, _validatePlugins.validateFilePlugin);
+    const opts = program.opts();
+    const format = (0, _utils.getFormatOpt)(opts);
+    if (!opts.outFile && !opts.outDir) {
+      (0, _utils.generate)(inputPaths, sql => _core.importer.import(sql, format), _outputConsolePlugin.default);
+    } else if (opts.outFile) {
+      (0, _utils.generate)(inputPaths, sql => _core.importer.import(sql, format), new _outputFilePlugin.default((0, _utils.resolvePaths)(opts.outFile)));
+      console.log(`  ${_chalk.default.green(_figures.default.main.tick)} Generated DBML file from SQL file (${_config.default[format].name}): ${_path.default.basename(opts.outFile)}`);
+    }
+  } catch (error) {
+    _logger.default.error(`\n    ${error.diags.map(diag => new _errors.SyntaxError(diag.filepath, diag)).map(({
+      message
+    }) => message).join('\n    ')}`);
+  }
+}

package/lib/cli/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.db2dbml = db2dbml;
+exports.dbml2sql = dbml2sql;
+exports.sql2dbml = sql2dbml;
+var _commander = _interopRequireDefault(require("commander"));
+var _import = _interopRequireDefault(require("./import"));
+var _export = _interopRequireDefault(require("./export"));
+var _connector = _interopRequireDefault(require("./connector"));
+var _package = _interopRequireDefault(require("../../package.json"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function showHelp(args) {
+  if (args.length < 3) _commander.default.help();
+}
+function dbml2sql(args) {
+  _commander.default.version(_package.default.version);
+  _commander.default.usage('[options] <files...>').option('--mysql').option('--postgres').option('--mssql').option('--oracle').option('-o, --out-file <pathspec>', 'compile all input files into a single files');
+  // .option('-d, --out-dir <pathspec>', 'compile an input directory of dbml files into an output directory');
+
+  showHelp(args);
+  _commander.default.parse(args);
+  (0, _export.default)(_commander.default);
+}
+function sql2dbml(args) {
+  _commander.default.version(_package.default.version);
+  _commander.default.usage('[options] <files...>').option('--mysql').option('--mysql-legacy').option('--postgres').option('--postgres-legacy').option('--mssql').option('--mssql-legacy').option('--snowflake').option('--oracle').option('-o, --out-file <pathspec>', 'compile all input files into a single files');
+  // .option('-d, --out-dir <pathspec>', 'compile an input directory of sql files into an output directory');
+
+  showHelp(args);
+  _commander.default.parse(args);
+  (0, _import.default)(_commander.default);
+}
+function db2dbml(args) {
+  _commander.default.version(_package.default.version);
+  const description = `Generate DBML directly from a database
+    <database-type>     your database format (postgres, mysql, mssql, snowflake, bigquery)
+    <connection-string> your database connection string:
+                        - postgres: 'postgresql://user:password@localhost:5432/dbname?schemas=schema1,schema2,schema3'
+                        - mysql: 'mysql://user:password@localhost:3306/dbname'
+                        - mssql: 'Server=localhost,1433;Database=master;User Id=sa;Password=your_password;Encrypt=true;TrustServerCertificate=true;Schemas=schema1,schema2,schema3;'
+                        - oracle: 'username/password@[//]host[:port][/service_name]'
+                        - snowflake:
+                          - password-based authentication: 'SERVER=<account_identifier>.<region>;UID=<your_username>;PWD=<your_password>;DATABASE=<your_database>;WAREHOUSE=<your_warehouse>;ROLE=<your_role>;SCHEMAS=schema1,schema2,schema3;'
+                          - key pair authentication: 'SERVER=<account_identifier>.<region>;UID=<your_username>;AUTHENTICATOR=SNOWFLAKE_JWT;PRIVATE_KEY_PATH=<path_to_your_private_key.p8>;PASSPHRASE=<your_private_key_passphrase>;DATABASE=<your_database>;WAREHOUSE=<your_warehouse>;ROLE=<your_role>;SCHEMAS=schema1,schema2,schema3;'
+
+                          Note: If you did not use passphrase to encrypt your private key, you can leave the "PASSPHRASE" empty.
+
+                        - bigquery: /path_to_json_credential.json
+
+                        For BigQuery, the credential file supports flexible authentication:
+
+                        1. Application Default Credentials (ADC):
+                           - Empty file: {} - uses environment authentication
+                           - Override specific fields: {"project_id": "my-project", "datasets": [...]}
+
+                          For more information about ADC, see https://cloud.google.com/docs/authentication/application-default-credentials
+
+                        2. Explicit Service Account (bypasses ADC):
+                           {
+                             "project_id": "your-project-id",
+                             "client_email": "your-client-email",
+                             "private_key": "your-private-key",
+                             "datasets": ["dataset_1", "dataset_2", ...]
+                           }
+                           Note: Both client_email and private_key must be provided together.
+
+                        If "datasets" is not specified or is empty, all accessible datasets will be fetched.
+  `;
+  _commander.default.usage('<database-type> <connection-string> [options]').description(description).option('-o, --out-file <pathspec>', 'compile all input files into a single files');
+  showHelp(args);
+  _commander.default.parse(args);
+  (0, _connector.default)(_commander.default);
+}

package/lib/cli/outputPlugins/outputConsolePlugin.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class OutputConsolePlugin {
+  static write(content) {
+    console.log(content);
+  }
+}
+var _default = exports.default = OutputConsolePlugin;

package/lib/cli/outputPlugins/outputFilePlugin.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class OutputFilePlugin {
+  constructor(filePath, header) {
+    this.filePath = filePath;
+    this.header = header;
+    this.isWrite = false;
+  }
+  start() {
+    _fs.default.writeFileSync(this.filePath, '');
+    this.stream = _fs.default.createWriteStream(this.filePath, {
+      flags: 'a'
+    });
+    if (this.header) this.stream.write(this.header);
+    this.isWrite = true;
+  }
+  write(content) {
+    if (!this.isWrite) this.start();
+    this.stream.write(content);
+  }
+}
+var _default = exports.default = OutputFilePlugin;

package/lib/cli/utils.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generate = generate;
+exports.getConnectionOpt = getConnectionOpt;
+exports.getFormatOpt = getFormatOpt;
+exports.resolvePaths = resolvePaths;
+exports.validateInputFilePaths = validateInputFilePaths;
+var _path2 = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _core = require("@dbml/core");
+var _lodash = require("lodash");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function resolvePaths(paths) {
+  if (!Array.isArray(paths)) {
+    return _path2.default.resolve(process.cwd(), paths);
+  }
+  return paths.map(_path => _path2.default.resolve(process.cwd(), _path));
+}
+function validateInputFilePaths(paths, validatePlugin) {
+  return paths.every(_path => validatePlugin(_path));
+}
+function getFormatOpt(opts) {
+  const formatOpts = Object.keys(opts).filter(opt => {
+    return ['postgres', 'mysql', 'mssql', 'postgresLegacy', 'mysqlLegacy', 'mssqlLegacy', 'oracle', 'snowflake'].includes(opt);
+  });
+  let format = 'postgres';
+  let cnt = 0;
+  formatOpts.forEach(opt => {
+    if (opts[opt]) {
+      cnt += 1;
+      if (cnt > 1) throw new Error('Too many format options');
+      format = opt;
+    }
+  });
+  return format;
+}
+function getConnectionOpt(args) {
+  const supportedDatabases = ['postgres', 'mysql', 'mssql', 'snowflake', 'bigquery', 'oracle'];
+  const defaultConnectionOpt = {
+    connection: args[0],
+    databaseType: 'unknown'
+  };
+  return (0, _lodash.reduce)(args, (connectionOpt, arg) => {
+    if (supportedDatabases.includes(arg)) connectionOpt.databaseType = arg;
+    // Check if the arg is a connection string using regex
+    const connectionStringRegex = /^.*[:;]/;
+    if (connectionStringRegex.test(arg)) {
+      // Example: jdbc:mysql://localhost:3306/mydatabase
+      // Example: odbc:Driver={SQL Server};Server=myServerAddress;Database=myDataBase;Uid=myUsername;Pwd=myPassword;
+      connectionOpt.connection = arg;
+    }
+    const windowFilepathRegex = /^[a-zA-Z]:[\\/](?:[^<>:"/\\|?*\n\r]+[\\/])*[^<>:"/\\|?*\n\r]*$/;
+    const unixFilepathRegex = /^(\/|\.\/|~\/|\.\.\/)([^<>:"|?*\n\r]*\/?)*[^<>:"|?*\n\r]*$/;
+    if (windowFilepathRegex.test(arg) || unixFilepathRegex.test(arg)) {
+      connectionOpt.connection = arg;
+    }
+    return connectionOpt;
+  }, defaultConnectionOpt);
+}
+function generate(inputPaths, transform, outputPlugin) {
+  inputPaths.forEach(_path => {
+    const source = _fs.default.readFileSync(_path, 'utf-8');
+    try {
+      const content = transform(source);
+      outputPlugin.write(content);
+    } catch (e) {
+      if (e instanceof _core.CompilerError) {
+        throw e.map(diag => ({
+          ...diag,
+          message: diag.message,
+          filepath: _path2.default.basename(_path),
+          stack: diag.stack
+        }));
+      }
+      throw e;
+    }
+  });
+}

package/lib/cli/validatePlugins/validatePlugins.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateFilePlugin = validateFilePlugin;
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function validateFilePlugin(_path) {
+  const stat = _fs.default.statSync(_path);
+  if (stat.isDirectory(_path)) {
+    throw new Error('Expect input to be files');
+  }
+}

package/lib/errors/domainError.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class DomainError extends Error {
+  constructor(message, rootError = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.rootError = rootError;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+var _default = exports.default = DomainError;

package/lib/errors/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DomainError", {
+  enumerable: true,
+  get: function () {
+    return _domainError.default;
+  }
+});
+Object.defineProperty(exports, "SyntaxError", {
+  enumerable: true,
+  get: function () {
+    return _syntaxError.default;
+  }
+});
+var _domainError = _interopRequireDefault(require("./domainError"));
+var _syntaxError = _interopRequireDefault(require("./syntaxError"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/errors/syntaxError.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _lodash = _interopRequireDefault(require("lodash"));
+var _domainError = _interopRequireDefault(require("./domainError"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class SyntaxError extends _domainError.default {
+  constructor(fileName, rootError = {}) {
+    let message = `You have a syntax error at "${fileName}"`;
+    if (rootError.location) {
+      message += ` line ${rootError.location.start.line} column ${rootError.location.start.column}`;
+    }
+    message += '.';
+    if (!_lodash.default.isEmpty(rootError)) {
+      message += ` ${rootError.message}`;
+    }
+    super(message, rootError);
+  }
+}
+var _default = exports.default = SyntaxError;

package/lib/helpers/logger.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _winston = require("winston");
+var _chalk = _interopRequireDefault(require("chalk"));
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  combine,
+  timestamp,
+  printf
+} = _winston.format;
+const consoleFormat = printf(info => {
+  const {
+    level,
+    message
+  } = info;
+  return `  ${_chalk.default.red(level.toUpperCase())}: ${message}\n
+  A complete log can be found in:
+     ${_path.default.resolve(process.cwd(), 'dbml-error.log')}`;
+});
+const fileFormat = printf(info => {
+  const {
+    timestamp,
+    stack,
+    rootError
+  } = info;
+  let logContent = `${timestamp}\n${stack}\n`;
+  if (rootError) {
+    logContent += '\nROOT_ERROR:';
+    logContent += `\n${rootError.stack}`;
+    if (rootError.location) {
+      logContent += `\n${JSON.stringify(rootError.location)}`;
+    }
+    logContent += '\n';
+  }
+  return logContent;
+});
+const consoleLogger = (0, _winston.createLogger)({
+  format: combine(consoleFormat),
+  transports: [new _winston.transports.Console({
+    level: 'error'
+  })]
+});
+const fileLogger = (0, _winston.createLogger)({
+  format: combine(timestamp(), fileFormat),
+  transports: [new _winston.transports.File({
+    filename: 'dbml-error.log',
+    level: 'error'
+  })]
+});
+const logger = {
+  debug(msg) {
+    consoleLogger.debug(msg);
+  },
+  info(msg) {
+    consoleLogger.info(msg);
+  },
+  warn(msg) {
+    consoleLogger.warn(msg);
+  },
+  error(msg) {
+    consoleLogger.error(msg);
+    fileLogger.error(msg);
+  },
+  log(level, msg) {
+    const lvl = exports[level];
+    lvl(msg);
+  }
+};
+var _default = exports.default = logger;