@dbml/cli 7.0.0-alpha.1 → 7.1.0-alpha.0

package/__tests__/sql2dbml_bin.js

@@ -1,4 +1,6 @@
 require = require('esm')(module);
-const { sql2dbml } = require('../src');
+const {
+  sql2dbml,
+} = require('../src');
 
 sql2dbml(process.argv);

package/eslint.config.ts

@@ -4,6 +4,41 @@ import { defineConfig } from 'eslint/config';
 import stylistic from '@stylistic/eslint-plugin';
 import tseslint from 'typescript-eslint';
 import tsparser from '@typescript-eslint/parser';
+import importPlugin from 'eslint-plugin-import';
+
+const IMPORT_ORDER_RULES = {
+  'import/order': ['error', {
+    groups: [
+      'builtin',
+      'external',
+      'internal',
+      'parent',
+      'sibling',
+      'index',
+    ],
+    'newlines-between': 'never',
+    alphabetize: {
+      order: 'asc',
+      caseInsensitive: false,
+    },
+  }],
+  'import/newline-after-import': ['error', { count: 1 }],
+  'sort-imports': ['error', {
+    ignoreDeclarationSort: true,
+    ignoreCase: false,
+    memberSyntaxSortOrder: ['none', 'all', 'multiple', 'single'],
+  }],
+};
+
+const IMPORT_SETTINGS = {
+  'import/resolver': {
+    typescript: {
+      alwaysTryTypes: true,
+      project: './tsconfig.json',
+    },
+    node: true,
+  },
+};
 
 export default defineConfig(
   eslint.configs.recommended,
@@ -41,8 +76,18 @@ export default defineConfig(
       },
       plugins: {
         '@stylistic': stylistic,
+        import: importPlugin,
       },
+      settings: IMPORT_SETTINGS,
       rules: {
+        ...IMPORT_ORDER_RULES,
+        '@stylistic/object-curly-newline': ['error', {
+          ObjectExpression: { multiline: true, minProperties: 1 },
+          ObjectPattern: { multiline: true, minProperties: 1 },
+          ImportDeclaration: { multiline: true, minProperties: 1 },
+          ExportDeclaration: { multiline: true, minProperties: 1 },
+        }],
+        '@stylistic/object-property-newline': ['error', { allowAllPropertiesOnSameLine: false }],
         '@typescript-eslint/no-explicit-any': 'off',
         'no-use-before-define': 'off',
         'no-continue': 'off',
@@ -59,18 +104,10 @@ export default defineConfig(
         '@typescript-eslint/consistent-return': [
           'error',
         ],
-        '@stylistic/quotes': ['error', 'single', { 'avoidEscape': true }],
+        '@stylistic/quotes': ['error', 'single', { avoidEscape: true }],
         '@stylistic/max-statements-per-line': 'off',
         '@stylistic/operator-linebreak': ['error', 'before', { overrides: { '=': 'after' } }],
       },
-      settings: {
-        'import/resolver': {
-          typescript: {
-            alwaysTryTypes: true,
-            project: 'packages/*/{ts,js}config.json',
-          },
-        },
-      },
     },
     {
       files: ['**/*.test.js', '**/*.spec.js', '**/*.test.ts', '**/*.spec.ts'],

package/lib/index.js

@@ -21,26 +21,147 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 let commander = require("commander");
 commander = __toESM(commander);
+let path = require("path");
+path = __toESM(path);
+let __dbml_connector = require("@dbml/connector");
 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 figures = require("figures");
+figures = __toESM(figures);
+let winston = require("winston");
 let fs = require("fs");
 fs = __toESM(fs);
-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" }
+const $schema = "https://json.schemastore.org/package";
+const name = "@dbml/cli";
+const version = "7.1.0-alpha.0";
+const description = "";
+const main = "lib/index.js";
+const license = "Apache-2.0";
+const scripts = {
+	"test": "vitest run",
+	"test:watch": "vitest watch",
+	"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 = {
+	"@babel/cli": "^7.21.0",
+	"@dbml/connector": "^7.1.0-alpha.0",
+	"@dbml/core": "^7.1.0-alpha.0",
+	"@dbml/parse": "^7.1.0-alpha.0",
+	"bluebird": "^3.5.5",
+	"chalk": "^2.4.2",
+	"commander": "^2.20.0",
+	"esm": "^3.2.25",
+	"figures": "^3.2.0",
+	"lodash-es": "^4.17.15",
+	"pegjs-require-import": "^0.0.2",
+	"strip-ansi": "^5.2.0",
+	"winston": "^3.2.1"
+};
+const gitHead = "109c30cccebfcb36b793945798d40963fb24d08c";
+const engines = { "node": ">=18" };
+var package_default = {
+	$schema,
+	name,
+	version,
+	description: "",
+	main,
+	license,
+	scripts,
+	publishConfig,
+	bin,
+	author,
+	homepage,
+	repository,
+	keywords,
+	dependencies,
+	gitHead,
+	engines
+};
+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")}`;
+});
+var fileFormat = printf((info) => {
+	const { timestamp: ts, stack, rootError } = info;
+	let logContent = `${ts}\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;
+});
+var consoleLogger = (0, winston.createLogger)({
+	format: combine(consoleFormat),
+	transports: [new winston.transports.Console({ level: "error" })]
+});
+var fileLogger = (0, winston.createLogger)({
+	format: combine(timestamp(), fileFormat),
+	transports: [new winston.transports.File({
+		filename: "dbml-error.log",
+		level: "error"
+	})]
+});
+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);
+	}
+};
+var logger_default = logger;
+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 freeGlobal = typeof global == "object" && global && global.Object === Object && global;
 var _freeGlobal_default = freeGlobal;
 var freeSelf = typeof self == "object" && self && self.Object === Object && self;
@@ -1038,82 +1159,23 @@ function generate(inputPaths, transform, outputPlugin) {
 		}
 	});
 }
-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")}`;
-});
-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;
-});
-var consoleLogger = (0, winston.createLogger)({
-	format: combine(consoleFormat),
-	transports: [new winston.transports.Console({ level: "error" })]
-});
-var fileLogger = (0, winston.createLogger)({
-	format: combine(timestamp(), fileFormat),
-	transports: [new winston.transports.File({
-		filename: "dbml-error.log",
-		level: "error"
-	})]
-});
-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);
+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);
 	}
-};
-var logger_default = logger;
+}
 var DomainError = class extends Error {
 	constructor(message, rootError = {}) {
 		super(message);
@@ -1133,24 +1195,18 @@ var SyntaxError = class extends domainError_default {
 	}
 };
 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) {
-		if ("diags" in error) {
-			logger_default.error(`\n    ${error.diags.map((diag) => new syntaxError_default(diag.filepath, diag)).map(({ message }) => message).join("\n    ")}`);
-			return;
-		}
-		throw error;
-	}
+var config = {
+	mysql: { name: "MySQL" },
+	mysqlLegacy: { name: "MySQL" },
+	postgres: { name: "PostgreSQL" },
+	postgresLegacy: { name: "PostgreSQL" },
+	mssql: { name: "SQL Server" },
+	oracle: { name: "Oracle" },
+	snowflake: { name: "Snowflake" }
+};
+var config_default = config;
+function validateFilePlugin(_path) {
+	if (fs.default.statSync(_path).isDirectory()) throw new Error("Expect input to be files");
 }
 async function exportHandler(program$1) {
 	try {
@@ -1169,86 +1225,29 @@ async function exportHandler(program$1) {
 			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    ")}`);
+		const e = error;
+		logger_default.error(`\n    ${e.diags.map((diag) => new syntaxError_default(diag.filepath ?? "", diag)).map(({ message }) => message).join("\n    ")}`);
 	}
 }
-async function connectionHandler(program$1) {
+async function importHandler(program$1) {
 	try {
-		const { connection, databaseType } = getConnectionOpt(program$1.args);
+		const inputPaths = resolvePaths(program$1.args);
+		validateInputFilePaths(inputPaths, validateFilePlugin);
 		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)}`);
+		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(error);
+		if (error instanceof __dbml_core.CompilerError) {
+			logger_default.error(`\n    ${error.diags.map((diag) => new syntaxError_default(diag.filepath ?? "", diag)).map(({ message }) => message).join("\n    ")}`);
+			return;
+		}
+		throw error;
 	}
 }
-const $schema = "https://json.schemastore.org/package";
-const name = "@dbml/cli";
-const version = "7.0.0-alpha.1";
-const description = "";
-const main = "lib/index.js";
-const license = "Apache-2.0";
-const scripts = {
-	"test": "vitest run",
-	"test:watch": "vitest watch",
-	"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 = {
-	"@babel/cli": "^7.21.0",
-	"@dbml/connector": "^7.0.0-alpha.0",
-	"@dbml/core": "^7.0.0-alpha.1",
-	"bluebird": "^3.5.5",
-	"chalk": "^2.4.2",
-	"commander": "^2.20.0",
-	"esm": "^3.2.25",
-	"figures": "^3.2.0",
-	"lodash-es": "^4.17.15",
-	"pegjs-require-import": "^0.0.2",
-	"strip-ansi": "^5.2.0",
-	"winston": "^3.2.1"
-};
-const gitHead = "283f3bcf7373ecab1e808e8a8035ce906ee6a52e";
-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();
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/cli",
-  "version": "7.0.0-alpha.1",
+  "version": "7.1.0-alpha.0",
   "description": "",
   "main": "lib/index.js",
   "license": "Apache-2.0",
@@ -32,8 +32,9 @@
   ],
   "dependencies": {
     "@babel/cli": "^7.21.0",
-    "@dbml/connector": "^7.0.0-alpha.0",
-    "@dbml/core": "^7.0.0-alpha.1",
+    "@dbml/connector": "^7.1.0-alpha.0",
+    "@dbml/core": "^7.1.0-alpha.0",
+    "@dbml/parse": "^7.1.0-alpha.0",
     "bluebird": "^3.5.5",
     "chalk": "^2.4.2",
     "commander": "^2.20.0",
@@ -44,7 +45,7 @@
     "strip-ansi": "^5.2.0",
     "winston": "^3.2.1"
   },
-  "gitHead": "283f3bcf7373ecab1e808e8a8035ce906ee6a52e",
+  "gitHead": "109c30cccebfcb36b793945798d40963fb24d08c",
   "engines": {
     "node": ">=18"
   }

package/src/cli/{config.js → config.ts}

@@ -1,4 +1,4 @@
-export default {
+const config: Record<string, { name: string }> = {
   mysql: {
     name: 'MySQL',
   },
@@ -21,3 +21,5 @@ export default {
     name: 'Snowflake',
   },
 };
+
+export default config;

package/src/cli/{connector.js → connector.ts}

@@ -1,19 +1,28 @@
-import { importer } from '@dbml/core';
-import { connector } from '@dbml/connector';
-import figures from 'figures';
-import chalk from 'chalk';
 import path from 'path';
 import {
-  resolvePaths,
-  getConnectionOpt,
-} from './utils';
+  connector,
+} from '@dbml/connector';
+import {
+  importer,
+} from '@dbml/core';
+import chalk from 'chalk';
+import {
+  Command,
+} from 'commander';
+import figures from 'figures';
+import logger from '../helpers/logger';
 import OutputConsolePlugin from './outputPlugins/outputConsolePlugin';
 import OutputFilePlugin from './outputPlugins/outputFilePlugin';
-import logger from '../helpers/logger';
+import {
+  getConnectionOpt,
+  resolvePaths,
+} from './utils';
 
-export default async function connectionHandler (program) {
+export default async function connectionHandler (program: Command) {
   try {
-    const { connection, databaseType } = getConnectionOpt(program.args);
+    const {
+      connection, databaseType,
+    } = getConnectionOpt(program.args);
     const opts = program.opts();
     const schemaJson = await connector.fetchSchemaJson(connection, databaseType);
 

package/src/cli/{export.js → export.ts}

@@ -1,27 +1,39 @@
-import figures from 'figures';
-import chalk from 'chalk';
 import path from 'path';
-import { exporter } from '@dbml/core';
 import {
-  validateInputFilePaths,
-  resolvePaths,
-  getFormatOpt,
-  generate,
-} from './utils';
-import { validateFilePlugin } from './validatePlugins/validatePlugins';
+  CompilerError, exporter,
+} from '@dbml/core';
+import type {
+  ExportFormat,
+} from '@dbml/core';
+import chalk from 'chalk';
+import type {
+  Command,
+} from 'commander';
+import figures from 'figures';
+import {
+  SyntaxError,
+} from '../errors';
+import logger from '../helpers/logger';
+import config from './config';
 import OutputConsolePlugin from './outputPlugins/outputConsolePlugin';
 import OutputFilePlugin from './outputPlugins/outputFilePlugin';
-import config from './config';
-import logger from '../helpers/logger';
-import { SyntaxError } from '../errors';
+import {
+  generate,
+  getFormatOpt,
+  resolvePaths,
+  validateInputFilePaths,
+} from './utils';
+import {
+  validateFilePlugin,
+} from './validatePlugins/validatePlugins';
 
-export default async function exportHandler (program) {
+export default async function exportHandler (program: Command) {
   try {
     const inputPaths = resolvePaths(program.args);
     validateInputFilePaths(inputPaths, validateFilePlugin);
     const opts = program.opts();
 
-    const format = getFormatOpt(opts);
+    const format = getFormatOpt(opts) as ExportFormat;
 
     if (!opts.outFile && !opts.outDir) {
       generate(inputPaths, (dbml) => exporter.export(dbml, format), OutputConsolePlugin);
@@ -41,6 +53,9 @@ export default async function exportHandler (program) {
       console.log(`  ${chalk.green(figures.main.tick)} Generated SQL dump file (${config[format].name}): ${path.basename(opts.outFile)}`);
     }
   } catch (error) {
-    logger.error(`\n    ${error.diags.map((diag) => new SyntaxError(diag.filepath, diag)).map(({ message }) => message).join('\n    ')}`);
+    const e = error as CompilerError;
+    logger.error(`\n    ${e.diags.map((diag) => new SyntaxError(diag.filepath ?? '', diag)).map(({
+      message,
+    }) => message).join('\n    ')}`);
   }
 }