@dbml/cli 7.0.0 → 7.0.1-alpha.0

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,
-};