@dbml/cli 7.0.0 → 7.1.0-alpha.0

package/__tests__/cli.test.ts

@@ -1,9 +1,11 @@
-import path from 'path';
+import childProcess from 'child_process';
 import fs from 'fs';
+import path from 'path';
 import util from 'util';
-import childProcess from 'child_process';
 import stripAnsi from 'strip-ansi';
-import { scanDirNames } from './testHelpers';
+import {
+  scanDirNames,
+} from './testHelpers';
 
 const exec = util.promisify(childProcess.exec);
 
@@ -20,7 +22,9 @@ describe('@dbml/cli', () => {
       fs.mkdirSync(path.join(dirName, './out-files'));
     }
 
-    const { stdout } = await exec(`node ${args.join(' ')}`);
+    const {
+      stdout,
+    } = await exec(`node ${args.join(' ')}`);
     const expectStdout = fs.readFileSync(path.join(dirName, './stdout.txt'), 'utf-8');
     const actualStdout = stripAnsi(stdout);
 

package/__tests__/db2dbml_bin.js

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

package/__tests__/dbml2sql_bin.js

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

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";
-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",
-	"@dbml/core": "^7.0.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 = "d9579d7cf95b7cafa9f083529393f0206c0acc98";
-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",
+  "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",
-    "@dbml/core": "^7.0.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",
@@ -44,7 +45,7 @@
     "strip-ansi": "^5.2.0",
     "winston": "^3.2.1"
   },
-  "gitHead": "d9579d7cf95b7cafa9f083529393f0206c0acc98",
+  "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    ')}`);
   }
 }

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

@@ -1,27 +1,39 @@
-import { importer } from '@dbml/core';
-import figures from 'figures';
-import chalk from 'chalk';
 import path from 'path';
+import {
+  CompilerError, importer,
+} from '@dbml/core';
+import type {
+  ImportFormat,
+} from '@dbml/core';
+import chalk from 'chalk';
+import {
+  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 {
-  validateInputFilePaths,
-  resolvePaths,
-  getFormatOpt,
   generate,
+  getFormatOpt,
+  resolvePaths,
+  validateInputFilePaths,
 } from './utils';
-import { validateFilePlugin } from './validatePlugins/validatePlugins';
-import OutputConsolePlugin from './outputPlugins/outputConsolePlugin';
-import OutputFilePlugin from './outputPlugins/outputFilePlugin';
-import logger from '../helpers/logger';
-import { SyntaxError } from '../errors';
+import {
+  validateFilePlugin,
+} from './validatePlugins/validatePlugins';
 
-export default async function importHandler (program) {
+export default async function importHandler (program: Command) {
   try {
     const inputPaths = resolvePaths(program.args);
     validateInputFilePaths(inputPaths, validateFilePlugin);
     const opts = program.opts();
 
-    const format = getFormatOpt(opts);
+    const format = getFormatOpt(opts) as ImportFormat;
 
     if (!opts.outFile && !opts.outDir) {
       generate(inputPaths, (sql) => importer.import(sql, format), OutputConsolePlugin);
@@ -31,8 +43,10 @@ export default async function importHandler (program) {
       console.log(`  ${chalk.green(figures.main.tick)} Generated DBML file from SQL file (${config[format].name}): ${path.basename(opts.outFile)}`);
     }
   } catch (error) {
-    if ('diags' in error) {
-      logger.error(`\n    ${error.diags.map((diag) => new SyntaxError(diag.filepath, diag)).map(({ message }) => message).join('\n    ')}`);
+    if (error instanceof CompilerError) {
+      logger.error(`\n    ${error.diags.map((diag) => new SyntaxError(diag.filepath ?? '', diag)).map(({
+        message,
+      }) => message).join('\n    ')}`);
       return;
     }
     throw error;

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

@@ -1,14 +1,14 @@
 import program from 'commander';
-import importHandler from './import';
-import exportHandler from './export';
-import connectionHandler from './connector';
 import projectInfo from '../../package.json';
+import connectionHandler from './connector';
+import exportHandler from './export';
+import importHandler from './import';
 
-function showHelp (args) {
+function showHelp (args: string[]) {
   if (args.length < 3) program.help();
 }
 
-function dbml2sql (args) {
+function dbml2sql (args: string[]) {
   program.version(projectInfo.version);
 
   program
@@ -26,7 +26,7 @@ function dbml2sql (args) {
   exportHandler(program);
 }
 
-function sql2dbml (args) {
+function sql2dbml (args: string[]) {
   program.version(projectInfo.version);
 
   program
@@ -48,7 +48,7 @@ function sql2dbml (args) {
   importHandler(program);
 }
 
-function db2dbml (args) {
+function db2dbml (args: string[]) {
   program.version(projectInfo.version);
 
   const description = `Generate DBML directly from a database

package/src/cli/outputPlugins/{outputConsolePlugin.js → outputConsolePlugin.ts}

@@ -1,5 +1,5 @@
 class OutputConsolePlugin {
-  static write (content) {
+  static write (content: string) {
     console.log(content);
   }
 }

package/src/cli/outputPlugins/{outputFilePlugin.js → outputFilePlugin.ts}

@@ -1,7 +1,12 @@
 import fs from 'fs';
 
 class OutputFilePlugin {
-  constructor (filePath, header) {
+  filePath: string;
+  header: string | undefined;
+  isWrite: boolean;
+  stream!: fs.WriteStream;
+
+  constructor (filePath: string, header?: string) {
     this.filePath = filePath;
     this.header = header;
     this.isWrite = false;
@@ -9,12 +14,14 @@ class OutputFilePlugin {
 
   start () {
     fs.writeFileSync(this.filePath, '');
-    this.stream = fs.createWriteStream(this.filePath, { flags: 'a' });
+    this.stream = fs.createWriteStream(this.filePath, {
+      flags: 'a',
+    });
     if (this.header) this.stream.write(this.header);
     this.isWrite = true;
   }
 
-  write (content) {
+  write (content: string) {
     if (!this.isWrite) this.start();
     this.stream.write(content);
   }

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

@@ -1,41 +1,57 @@
-import path from 'path';
 import fs from 'fs';
-import { CompilerError } from '@dbml/core';
-import { reduce } from 'lodash-es';
+import path from 'path';
+import {
+  CompilerError,
+  type ExportFormat,
+} from '@dbml/core';
+import {
+  reduce,
+} from 'lodash-es';
+
+interface OutputPlugin {
+  write(content: string): void;
+}
+
+interface ConnectionOpt {
+  connection: string;
+  databaseType: string;
+}
 
-function resolvePaths (paths) {
+function resolvePaths (paths: string): string;
+function resolvePaths (paths: string[]): string[];
+function resolvePaths (paths: string | string[]): string | string[] {
   if (!Array.isArray(paths)) {
     return path.resolve(process.cwd(), paths);
   }
   return paths.map((_path) => path.resolve(process.cwd(), _path));
 }
 
-function validateInputFilePaths (paths, validatePlugin) {
+function validateInputFilePaths (paths: string[], validatePlugin: (_path: string) => void) {
   return paths.every((_path) => validatePlugin(_path));
 }
 
-function getFormatOpt (opts) {
+function getFormatOpt (opts: Record<string, unknown>): ExportFormat {
   const formatOpts = Object.keys(opts).filter((opt) => {
     return ['postgres', 'mysql', 'mssql', 'postgresLegacy', 'mysqlLegacy', 'mssqlLegacy', 'oracle', 'snowflake'].includes(opt);
   });
 
-  let format = 'postgres';
+  let format: ExportFormat = 'postgres';
   let cnt = 0;
 
   formatOpts.forEach((opt) => {
     if (opts[opt]) {
       cnt += 1;
       if (cnt > 1) throw new Error('Too many format options');
-      format = opt;
+      format = opt as ExportFormat;
     }
   });
 
-  return format;
+  return format as ExportFormat;
 }
 
-function getConnectionOpt (args) {
+function getConnectionOpt (args: string[]): ConnectionOpt {
   const supportedDatabases = ['postgres', 'mysql', 'mssql', 'snowflake', 'bigquery', 'oracle'];
-  const defaultConnectionOpt = {
+  const defaultConnectionOpt: ConnectionOpt = {
     connection: args[0],
     databaseType: 'unknown',
   };
@@ -61,7 +77,11 @@ function getConnectionOpt (args) {
   }, defaultConnectionOpt);
 }
 
-function generate (inputPaths, transform, outputPlugin) {
+function generate (
+  inputPaths: string[],
+  transform: (source: string) => string,
+  outputPlugin: OutputPlugin,
+): void {
   inputPaths.forEach((_path) => {
     const source = fs.readFileSync(_path, 'utf-8');
     try {
@@ -70,7 +90,10 @@ function generate (inputPaths, transform, outputPlugin) {
     } catch (e) {
       if (e instanceof CompilerError) {
         throw e.map((diag) => ({
-          ...diag, message: diag.message, filepath: path.basename(_path), stack: diag.stack,
+          ...diag,
+          message: diag.message,
+          filepath: path.basename(_path),
+          stack: diag.stack,
         }));
       }
       throw e;

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

@@ -1,8 +1,8 @@
 import fs from 'fs';
 
-function validateFilePlugin (_path) {
+function validateFilePlugin (_path: string) {
   const stat = fs.statSync(_path);
-  if (stat.isDirectory(_path)) {
+  if (stat.isDirectory()) {
     throw new Error('Expect input to be files');
   }
 }

package/src/errors/{domainError.js → domainError.ts}

@@ -1,5 +1,7 @@
 class DomainError extends Error {
-  constructor (message, rootError = {}) {
+  rootError: unknown;
+
+  constructor (message: string, rootError: unknown = {}) {
     super(message);
     this.name = this.constructor.name;
     this.rootError = rootError;

package/src/errors/{syntaxError.js → syntaxError.ts}

@@ -1,8 +1,21 @@
-import { isEmpty } from 'lodash-es';
+import {
+  isEmpty,
+} from 'lodash-es';
 import DomainError from './domainError';
 
+interface RootError {
+  location?: {
+    start: {
+      line: number;
+      column: number;
+    };
+  };
+  message?: string;
+  stack?: unknown;
+}
+
 class SyntaxError extends DomainError {
-  constructor (fileName, rootError = {}) {
+  constructor (fileName: string, rootError: RootError = {}) {
     let message = `You have a syntax error at "${fileName}"`;
 
     if (rootError.location) {

package/src/helpers/{logger.js → logger.ts}

@@ -1,19 +1,30 @@
-import { createLogger, format, transports } from 'winston';
-import chalk from 'chalk';
 import path from 'path';
+import chalk from 'chalk';
+import {
+  createLogger, format, transports,
+} from 'winston';
 
-const { combine, timestamp, printf } = format;
+const {
+  combine, timestamp, printf,
+} = format;
 
 const consoleFormat = printf((info) => {
-  const { level, message } = info;
+  const {
+    level, message,
+  } = info;
   return `  ${chalk.red(level.toUpperCase())}: ${message}\n
   A complete log can be found in:
      ${path.resolve(process.cwd(), 'dbml-error.log')}`;
 });
 
 const fileFormat = printf((info) => {
-  const { timestamp, stack, rootError } = info;
-  let logContent = `${timestamp}\n${stack}\n`;
+  const {
+    timestamp: ts, stack, rootError,
+  } = info as unknown as { timestamp: string;
+    stack?: string;
+    rootError?: { stack?: string;
+      location?: unknown; }; };
+  let logContent = `${ts}\n${stack}\n`;
   if (rootError) {
     logContent += '\nROOT_ERROR:';
     logContent += `\n${rootError.stack}`;
@@ -30,7 +41,9 @@ const consoleLogger = createLogger({
     consoleFormat,
   ),
   transports: [
-    new transports.Console({ level: 'error' }),
+    new transports.Console({
+      level: 'error',
+    }),
   ],
 });
 
@@ -40,28 +53,28 @@ const fileLogger = createLogger({
     fileFormat,
   ),
   transports: [
-    new transports.File({ filename: 'dbml-error.log', level: 'error' }),
+    new transports.File({
+      filename: 'dbml-error.log',
+      level: 'error',
+    }),
   ],
 });
 
 const logger = {
-  debug (msg) {
+  debug (msg: string) {
     consoleLogger.debug(msg);
   },
-  info (msg) {
+  info (msg: string) {
     consoleLogger.info(msg);
   },
-  warn (msg) {
+  warn (msg: string) {
     consoleLogger.warn(msg);
   },
-  error (msg) {
+
+  error (msg: any) {
     consoleLogger.error(msg);
     fileLogger.error(msg);
   },
-  log (level, msg) {
-    const lvl = exports[level];
-    lvl(msg);
-  },
 };
 
 export default logger;

package/src/index.ts

@@ -0,0 +1,9 @@
+import {
+  db2dbml, dbml2sql, sql2dbml,
+} from './cli';
+
+export {
+  dbml2sql,
+  sql2dbml,
+  db2dbml,
+};

package/vite.config.ts

@@ -14,7 +14,7 @@ export default defineConfig({
     outDir: 'lib',
     minify: false,
     lib: {
-      entry: path.resolve(__dirname, 'src/index.js'),
+      entry: path.resolve(__dirname, 'src/index.ts'),
       fileName: 'index',
       formats: ['cjs'],
     },

package/src/index.js

@@ -1,7 +0,0 @@
-import { dbml2sql, sql2dbml, db2dbml } from './cli';
-
-export {
-  dbml2sql,
-  sql2dbml,
-  db2dbml,
-};