@dbml/cli 5.5.1 → 5.6.0-alpha.0

package/lib/index.js

@@ -1,24 +1,378 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+let commander = require("commander");
+commander = __toESM(commander);
+let __dbml_core = require("@dbml/core");
+let figures = require("figures");
+figures = __toESM(figures);
+let chalk = require("chalk");
+chalk = __toESM(chalk);
+let path = require("path");
+path = __toESM(path);
+let fs = require("fs");
+fs = __toESM(fs);
+let lodash = require("lodash");
+lodash = __toESM(lodash);
+let winston = require("winston");
+let __dbml_connector = require("@dbml/connector");
+var config_default = {
+	mysql: { name: "MySQL" },
+	mysqlLegacy: { name: "MySQL" },
+	postgres: { name: "PostgreSQL" },
+	postgresLegacy: { name: "PostgreSQL" },
+	mssql: { name: "SQL Server" },
+	oracle: { name: "Oracle" },
+	snowflake: { name: "Snowflake" }
+};
+function resolvePaths(paths) {
+	if (!Array.isArray(paths)) return path.default.resolve(process.cwd(), paths);
+	return paths.map((_path) => path.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$1 = "postgres";
+	let cnt = 0;
+	formatOpts.forEach((opt) => {
+		if (opts[opt]) {
+			cnt += 1;
+			if (cnt > 1) throw new Error("Too many format options");
+			format$1 = opt;
+		}
+	});
+	return format$1;
+}
+function getConnectionOpt(args) {
+	const supportedDatabases = [
+		"postgres",
+		"mysql",
+		"mssql",
+		"snowflake",
+		"bigquery",
+		"oracle"
+	];
+	return (0, lodash.reduce)(args, (connectionOpt, arg) => {
+		if (supportedDatabases.includes(arg)) connectionOpt.databaseType = arg;
+		if (/^.*[:;]/.test(arg)) connectionOpt.connection = arg;
+		if (/^[a-zA-Z]:[\\/](?:[^<>:"/\\|?*\n\r]+[\\/])*[^<>:"/\\|?*\n\r]*$/.test(arg) || /^(\/|\.\/|~\/|\.\.\/)([^<>:"|?*\n\r]*\/?)*[^<>:"|?*\n\r]*$/.test(arg)) connectionOpt.connection = arg;
+		return connectionOpt;
+	}, {
+		connection: args[0],
+		databaseType: "unknown"
+	});
+}
+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 __dbml_core.CompilerError) throw e.map((diag) => ({
+				...diag,
+				message: diag.message,
+				filepath: path.default.basename(_path),
+				stack: diag.stack
+			}));
+			throw e;
+		}
+	});
+}
+function validateFilePlugin(_path) {
+	if (fs.default.statSync(_path).isDirectory(_path)) throw new Error("Expect input to be files");
+}
+var OutputConsolePlugin = class {
+	static write(content) {
+		console.log(content);
+	}
+};
+var outputConsolePlugin_default = OutputConsolePlugin;
+var OutputFilePlugin = class {
+	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 outputFilePlugin_default = OutputFilePlugin;
+var { combine, timestamp, printf } = winston.format;
+var 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")}`;
 });
-Object.defineProperty(exports, "db2dbml", {
-  enumerable: true,
-  get: function () {
-    return _cli.db2dbml;
-  }
+var fileFormat = printf((info) => {
+	const { timestamp: timestamp$1, stack, rootError } = info;
+	let logContent = `${timestamp$1}\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;
 });
-Object.defineProperty(exports, "dbml2sql", {
-  enumerable: true,
-  get: function () {
-    return _cli.dbml2sql;
-  }
+var consoleLogger = (0, winston.createLogger)({
+	format: combine(consoleFormat),
+	transports: [new winston.transports.Console({ level: "error" })]
 });
-Object.defineProperty(exports, "sql2dbml", {
-  enumerable: true,
-  get: function () {
-    return _cli.sql2dbml;
-  }
+var fileLogger = (0, winston.createLogger)({
+	format: combine(timestamp(), fileFormat),
+	transports: [new winston.transports.File({
+		filename: "dbml-error.log",
+		level: "error"
+	})]
 });
-var _cli = require("./cli");
+var 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 logger_default = logger;
+var DomainError = class extends Error {
+	constructor(message, rootError = {}) {
+		super(message);
+		this.name = this.constructor.name;
+		this.rootError = rootError;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+var domainError_default = DomainError;
+var SyntaxError = class 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 syntaxError_default = SyntaxError;
+async function importHandler(program$1) {
+	try {
+		const inputPaths = resolvePaths(program$1.args);
+		validateInputFilePaths(inputPaths, validateFilePlugin);
+		const opts = program$1.opts();
+		const format$1 = getFormatOpt(opts);
+		if (!opts.outFile && !opts.outDir) generate(inputPaths, (sql) => __dbml_core.importer.import(sql, format$1), outputConsolePlugin_default);
+		else if (opts.outFile) {
+			generate(inputPaths, (sql) => __dbml_core.importer.import(sql, format$1), new outputFilePlugin_default(resolvePaths(opts.outFile)));
+			console.log(`  ${chalk.default.green(figures.default.main.tick)} Generated DBML file from SQL file (${config_default[format$1].name}): ${path.default.basename(opts.outFile)}`);
+		}
+	} catch (error) {
+		logger_default.error(`\n    ${error.diags.map((diag) => new syntaxError_default(diag.filepath, diag)).map(({ message }) => message).join("\n    ")}`);
+	}
+}
+async function exportHandler(program$1) {
+	try {
+		const inputPaths = resolvePaths(program$1.args);
+		validateInputFilePaths(inputPaths, validateFilePlugin);
+		const opts = program$1.opts();
+		const format$1 = getFormatOpt(opts);
+		if (!opts.outFile && !opts.outDir) generate(inputPaths, (dbml) => __dbml_core.exporter.export(dbml, format$1), outputConsolePlugin_default);
+		else if (opts.outFile) {
+			const header = [
+				"-- SQL dump generated using DBML (dbml.dbdiagram.io)\n",
+				`-- Database: ${config_default[format$1].name}\n`,
+				`-- Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}\n\n`
+			].join("");
+			generate(inputPaths, (dbml) => __dbml_core.exporter.export(dbml, format$1), new outputFilePlugin_default(resolvePaths(opts.outFile), header));
+			console.log(`  ${chalk.default.green(figures.default.main.tick)} Generated SQL dump file (${config_default[format$1].name}): ${path.default.basename(opts.outFile)}`);
+		}
+	} catch (error) {
+		logger_default.error(`\n    ${error.diags.map((diag) => new syntaxError_default(diag.filepath, diag)).map(({ message }) => message).join("\n    ")}`);
+	}
+}
+async function connectionHandler(program$1) {
+	try {
+		const { connection, databaseType } = getConnectionOpt(program$1.args);
+		const opts = program$1.opts();
+		const schemaJson = await __dbml_connector.connector.fetchSchemaJson(connection, databaseType);
+		if (!opts.outFile && !opts.outDir) {
+			const res = __dbml_core.importer.generateDbml(schemaJson);
+			outputConsolePlugin_default.write(res);
+		} else if (opts.outFile) {
+			const res = __dbml_core.importer.generateDbml(schemaJson);
+			new outputFilePlugin_default(resolvePaths(opts.outFile)).write(res);
+			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);
+	}
+}
+const $schema = "https://json.schemastore.org/package";
+const name = "@dbml/cli";
+const version = "5.6.0-alpha.0";
+const description = "";
+const main = "lib/index.js";
+const license = "Apache-2.0";
+const scripts = {
+	"test": "vitest",
+	"test:watch": "vitest tests",
+	"coverage": "vitest --coverage",
+	"build": "rm -rf ./lib && tsc --noEmit && vite build",
+	"dev": "vite build --watch",
+	"prepublish": "npm run build",
+	"lint": "eslint .",
+	"lint:fix": "eslint --fix ."
+};
+const publishConfig = { "access": "public" };
+const bin = {
+	"dbml2sql": "bin/dbml2sql.js",
+	"sql2dbml": "bin/sql2dbml.js",
+	"db2dbml": "bin/db2dbml.js"
+};
+const author = "Holistics <dev@holistics.io>";
+const homepage = "https://dbml.dbdiagram.io";
+const repository = "https://github.com/holistics/dbml/tree/master/packages/dbml-cli";
+const keywords = ["dbml", "dbml-cli"];
+const dependencies = {
+	"@dbml/connector": "^5.6.0-alpha.0",
+	"@dbml/core": "^5.6.0-alpha.0",
+	"bluebird": "^3.5.5",
+	"chalk": "^2.4.2",
+	"commander": "^2.20.0",
+	"esm": "^3.2.25",
+	"figures": "^3.2.0",
+	"lodash": "^4.17.15",
+	"pegjs-require-import": "^0.0.2",
+	"strip-ansi": "^5.2.0",
+	"winston": "^3.2.1"
+};
+const gitHead = "e0cd0b00099344c05af0a83e30c2c9c2ccc325cc";
+const engines = { "node": ">=18" };
+var package_default = {
+	$schema,
+	name,
+	version,
+	description: "",
+	main,
+	license,
+	scripts,
+	publishConfig,
+	bin,
+	author,
+	homepage,
+	repository,
+	keywords,
+	dependencies,
+	gitHead,
+	engines
+};
+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");
+	showHelp(args);
+	commander.default.parse(args);
+	exportHandler(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");
+	showHelp(args);
+	commander.default.parse(args);
+	importHandler(commander.default);
+}
+function db2dbml(args) {
+	commander.default.version(package_default.version);
+	commander.default.usage("<database-type> <connection-string> [options]").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.
+  `).option("-o, --out-file <pathspec>", "compile all input files into a single files");
+	showHelp(args);
+	commander.default.parse(args);
+	connectionHandler(commander.default);
+}
+exports.db2dbml = db2dbml;
+exports.dbml2sql = dbml2sql;
+exports.sql2dbml = sql2dbml;

package/package.json

@@ -1,14 +1,16 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/cli",
-  "version": "5.5.1",
+  "version": "5.6.0-alpha.0",
   "description": "",
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "scripts": {
-    "test": "jest --coverage=false",
-    "coverage": "jest --coverage",
-    "build": "babel src --out-dir lib --copy-files",
+    "test": "vitest",
+    "test:watch": "vitest tests",
+    "coverage": "vitest --coverage",
+    "build": "rm -rf ./lib && tsc --noEmit && vite build",
+    "dev": "vite build --watch",
     "prepublish": "npm run build",
     "lint": "eslint .",
     "lint:fix": "eslint --fix ."
@@ -29,9 +31,8 @@
     "dbml-cli"
   ],
   "dependencies": {
-    "@babel/cli": "^7.21.0",
-    "@dbml/connector": "^5.5.1",
-    "@dbml/core": "^5.5.1",
+    "@dbml/connector": "^5.6.0-alpha.0",
+    "@dbml/core": "^5.6.0-alpha.0",
     "bluebird": "^3.5.5",
     "chalk": "^2.4.2",
     "commander": "^2.20.0",
@@ -42,25 +43,7 @@
     "strip-ansi": "^5.2.0",
     "winston": "^3.2.1"
   },
-  "devDependencies": {
-    "@babel/core": "^7.21.4",
-    "@babel/node": "^7.20.7",
-    "@babel/plugin-transform-runtime": "^7.21.4",
-    "@babel/preset-env": "^7.21.4",
-    "@babel/runtime": "^7.21.0",
-    "@stylistic/eslint-plugin": "^5.5.0",
-    "@typescript-eslint/eslint-plugin": "^8.46.3",
-    "@typescript-eslint/parser": "^8.46.3",
-    "babel-jest": "^29.5.0",
-    "eslint": "^9.39.1",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-plugin-jest": "^29.0.1",
-    "jest": "^29.5.0",
-    "ts-jest": "^29.4.5",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.3"
-  },
-  "gitHead": "4519233511e253390842ffe363dd881e3413fd0a",
+  "gitHead": "e0cd0b00099344c05af0a83e30c2c9c2ccc325cc",
   "engines": {
     "node": ">=18"
   }

package/tsconfig.json

@@ -6,7 +6,8 @@
       "./"
     ], /* Allow multiple folders to be treated as one when resolving modules. */
     "baseUrl": "./src", /* Specify the base directory to resolve non-relative module names. */
-    "outDir": "./lib" /* Specify an output folder for all emitted files. */
+    "outDir": "./lib", /* Specify an output folder for all emitted files. */
+    "types": ["vitest/globals", "node"]
   },
   "files": [
     "package.json"

package/vite.config.ts

@@ -0,0 +1,50 @@
+/// <reference types="vitest" />
+
+import path from 'path';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "src/"),
+    },
+  },
+  build: {
+    target: 'node18',
+    outDir: 'lib',
+    minify: false,
+    lib: {
+      entry: path.resolve(__dirname, "src/index.js"),
+      fileName: 'index',
+      formats: ['cjs'],
+    },
+    rollupOptions: {
+      output: {
+        exports: 'named',
+      },
+      external: [
+        '@dbml/connector',
+        '@dbml/core',
+        'bluebird',
+        'chalk',
+        'commander',
+        'esm',
+        'figures',
+        'lodash',
+        'pegjs-require-import',
+        'strip-ansi',
+        'winston',
+        'path',
+        'fs',
+        /^node:.*/,
+      ],
+    },
+  },
+  test: {
+    globals: true,
+    coverage: {
+      provider: 'v8',
+      reporter: ['json', 'json-summary', 'html', 'text'],
+    },
+  },
+});

package/.babelrc

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

package/jest.config.ts

@@ -1,14 +0,0 @@
-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

@@ -1,29 +0,0 @@
-"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

@@ -1,38 +0,0 @@
-"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

@@ -1,37 +0,0 @@
-"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    ')}`);
-  }
-}