@dbml/cli 8.0.0-alpha.8 → 8.0.0-prerelease.0

package/src/NodeProjectLayout.ts

@@ -1,52 +1,25 @@
 import {
-  existsSync, readFileSync, readdirSync, statSync,
+  readFileSync, readdirSync, statSync,
 } from 'node:fs';
 import {
   type DbmlProjectLayout, Filepath,
 } from '@dbml/parse';
+import {
+  fileLogger,
+} from './helpers/logger';
 
 /**
- * A DbmlProjectLayout backed by the Node.js filesystem.
- * Reads source files on demand from disk; setSource/deleteSource maintain an
- * in-memory overlay (e.g. for unsaved edits) without touching the real FS.
+ * A read-only DbmlProjectLayout backed by the Node.js filesystem.
  */
 export class NodeProjectLayout implements DbmlProjectLayout {
-  // Overlay is an overriding map of file absolute paths to file content
-  // `null`: The file is deleted
-  private overlay = new Map<string, string | null>();
-  private entryPoints: Filepath[];
+  private readonly entryPoints: Filepath[];
 
   constructor (entryPoints: Filepath[]) {
     this.entryPoints = [...entryPoints];
   }
 
-  setSource (filePath: Filepath, content: string): void {
-    this.overlay.set(filePath.absolute, content);
-  }
-
   getSource (filePath: Filepath): string | undefined {
-    const absolutePath = filePath.absolute;
-
-    // If overlay already has the file,
-    // return its content
-    if (this.overlay.has(absolutePath)) {
-      const value = this.overlay.get(absolutePath);
-      return value ?? undefined; // null (deleted) -> undefined
-    }
-    try {
-      return readFileSync(absolutePath, 'utf-8');
-    } catch {
-      return undefined;
-    }
-  }
-
-  deleteSource (filePath: Filepath): void {
-    this.overlay.set(filePath.absolute, null);
-  }
-
-  clearSource (): void {
-    this.overlay.clear();
-    this.entryPoints = [];
+    return safeReadFileSync(filePath.absolute, 'utf-8');
   }
 
   exists (filePath: Filepath): boolean {
@@ -54,72 +27,41 @@ export class NodeProjectLayout implements DbmlProjectLayout {
   }
 
   isFile (filePath: Filepath): boolean {
-    const absolutePath = filePath.absolute;
-
-    if (this.overlay.has(absolutePath)) return this.overlay.get(absolutePath) !== null;
-
-    try {
-      // `statSync` (not lstatSync) so symlinks resolve to their target, matching
-      // how node reads the file on disk.
-      return statSync(absolutePath).isFile();
-    } catch {
-      return false;
-    }
+    return safeStatSync(filePath.absolute, {
+      throwIfNoEntry: false,
+    })?.isFile() ?? false;
   }
 
   isDirectory (filePath: Filepath): boolean {
-    const absolutePath = filePath.absolute;
-
-    try {
-      // Exist in filesystem
-      if (statSync(absolutePath).isDirectory()) return true;
-    } catch {
-      // fall through: the path may exist only in the overlay
-    }
-    for (const [overlayPath, content] of this.overlay) {
-      if (content === null) continue;
-      if (overlayPath.startsWith(absolutePath)) return true;
-    }
-    return false;
+    return safeStatSync(filePath.absolute, {
+      throwIfNoEntry: false,
+    })?.isDirectory() ?? false;
   }
 
   listDirectory (dirPath?: Filepath): Filepath[] {
     const basePath = dirPath?.absolute ?? '/';
-    const results = new Set<string>();
-
-    try {
-      // Filesystem entries
-      for (const entry of readdirSync(basePath)) {
-        results.add(basePath + entry);
-      }
-    } catch {
-      // Not a readable directory - ignore
-    }
-
-    // Overlay additions: non-deleted files directly under base
-    for (const [abs, content] of this.overlay) {
-      if (content === null) continue;
-      if (!abs.startsWith(basePath)) continue;
-      if (!abs.slice(basePath.length).includes('/')) results.add(abs);
-    }
-
-    // Remove overlay-deleted paths
-    for (const [overlayPath, content] of this.overlay) {
-      if (content === null) results.delete(overlayPath);
-    }
-
-    return [...results].sort().map(Filepath.from);
+    return safeReaddirSync(basePath)?.map((entry) => basePath + entry).sort().map(Filepath.from) ?? [];
   }
 
-  getEntryPoints (): Filepath[] {
+  getEntrypoints (): Filepath[] {
     return this.entryPoints.filter((fp) => this.exists(fp));
   }
+}
 
-  clone (): NodeProjectLayout {
-    const copy = new NodeProjectLayout([...this.entryPoints]);
-    for (const [overlayPath, content] of this.overlay) {
-      copy.overlay.set(overlayPath, content);
+// Wrap a function so that errors are logged to file and undefined is returned
+function logOnError<Args extends unknown[], R> (fn: (...args: Args) => R): (...args: Args) => R | undefined {
+  return (...args) => {
+    try {
+      return fn(...args);
+    } catch (e) {
+      fileLogger.error(e instanceof Error ? e : new Error(String(e)));
+      return undefined;
     }
-    return copy;
-  }
+  };
 }
+
+const safeReadFileSync = logOnError(readFileSync as (path: string, encoding: BufferEncoding) => string);
+const safeReaddirSync = logOnError(readdirSync as (path: string) => string[]);
+const safeStatSync = logOnError(
+  (path: string, opts: { throwIfNoEntry: false }) => statSync(path, opts),
+);

package/src/cli/connector.ts

@@ -10,7 +10,9 @@ import {
   Command,
 } from 'commander';
 import figures from 'figures';
-import logger from '../helpers/logger';
+import {
+  consoleLogger, fileLogger,
+} from '../helpers/logger';
 import OutputConsolePlugin from './outputPlugins/outputConsolePlugin';
 import OutputFilePlugin from './outputPlugins/outputFilePlugin';
 import {
@@ -37,6 +39,7 @@ export default async function connectionHandler (program: Command) {
       console.log(`  ${chalk.green(figures.main.tick)} Generated DBML file from database's connection: ${path.basename(opts.outFile)}`);
     }
   } catch (error) {
-    logger.error(error as Error | string);
+    consoleLogger.error(error as Error | string);
+    fileLogger.error(error as Error | string);
   }
 }

package/src/cli/export.ts

@@ -13,7 +13,9 @@ import figures from 'figures';
 import {
   NodeProjectLayout,
 } from '../NodeProjectLayout';
-import logger from '../helpers/logger';
+import {
+  consoleLogger, fileLogger,
+} from '../helpers/logger';
 import config from './config';
 import OutputConsolePlugin from './outputPlugins/outputConsolePlugin';
 import OutputFilePlugin from './outputPlugins/outputFilePlugin';
@@ -32,9 +34,8 @@ export default async function exportHandler (program: Command): Promise<void> {
   const opts = program.opts();
   const format = getFormatOpt(opts);
 
-  const entryPoints = inputPaths.map((p: string) => new Filepath(p));
-  const compiler = new Compiler();
-  compiler.layout = new NodeProjectLayout(entryPoints);
+  const entrypoints = inputPaths.map((p: string) => new Filepath(p));
+  const compiler = new Compiler(new NodeProjectLayout(entrypoints));
 
   const outputPlugin = opts.outFile
     ? new OutputFilePlugin(
@@ -49,25 +50,25 @@ export default async function exportHandler (program: Command): Promise<void> {
 
   let hasErrors = false;
 
-  for (const filepath of entryPoints) {
+  for (const filepath of entrypoints) {
     const result = compiler.interpretFile(filepath);
     const errors = result.getErrors();
 
     if (errors.length > 0) {
       hasErrors = true;
-      const isMultifile = compiler.reachableFiles(filepath).length > 1;
-      logger.error(
-        `\n    ${errors
-          .map((e) => {
-            const pos = e.nodeOrToken.startPos;
-            const line = pos.line + 1;
-            const col = pos.column + 1;
-            const location = chalk.cyan(isMultifile ? e.filepath.relativeTo(process.cwd()) : e.filepath.basename);
-            const position = chalk.yellow(`(${line},${col})`);
-            return `${location}${position}: ${e.message}`;
-          })
-          .join('\n    ')}`,
-      );
+      const isMultifile = compiler.reachableFiles(filepath).length > 1; // If this filepath can reach other files, it's mutifile
+      const msg = `\n    ${errors
+        .map((e) => {
+          const pos = e.nodeOrToken.startPos;
+          const line = pos.line + 1;
+          const col = pos.column + 1;
+          const location = chalk.cyan(isMultifile ? e.filepath.relativeTo(process.cwd()) : e.filepath.basename);
+          const position = chalk.yellow(`(${line},${col})`);
+          return `${location}${position}: ${e.message}`;
+        })
+        .join('\n    ')}`;
+      consoleLogger.error(msg);
+      fileLogger.error(msg);
       continue;
     }
 

package/src/cli/import.ts

@@ -13,7 +13,9 @@ import figures from 'figures';
 import {
   SyntaxError,
 } from '../errors';
-import logger from '../helpers/logger';
+import {
+  consoleLogger, fileLogger,
+} from '../helpers/logger';
 import config from './config';
 import OutputConsolePlugin from './outputPlugins/outputConsolePlugin';
 import OutputFilePlugin from './outputPlugins/outputFilePlugin';
@@ -44,9 +46,11 @@ export default async function importHandler (program: Command) {
     }
   } catch (error) {
     if (error instanceof CompilerError) {
-      logger.error(`\n    ${error.diags.map((diag) => new SyntaxError(diag.filepath ?? '', diag)).map(({
+      const msg = `\n    ${error.diags.map((diag) => new SyntaxError(diag.filepath ?? '', diag)).map(({
         message,
-      }) => message).join('\n    ')}`);
+      }) => message).join('\n    ')}`;
+      consoleLogger.error(msg);
+      fileLogger.error(msg);
       return;
     }
     throw error;

package/src/helpers/logger.ts

@@ -1,6 +1,5 @@
 import path from 'path';
 import chalk from 'chalk';
-import stripAnsi from 'strip-ansi';
 import {
   createLogger, format, transports,
 } from 'winston';
@@ -22,7 +21,7 @@ const fileFormat = printf((info) => {
   const {
     timestamp: ts, message, stack, rootError,
   } = info as any;
-  let logContent = `${ts}\n${stripAnsi(stack ?? message ?? '')}\n`;
+  let logContent = `${ts}\n${stack ?? message ?? ''}\n`;
   if (rootError) {
     logContent += '\nROOT_ERROR:';
     logContent += `\n${rootError.stack}`;
@@ -34,7 +33,7 @@ const fileFormat = printf((info) => {
   return logContent;
 });
 
-const consoleLogger = createLogger({
+export const consoleLogger = createLogger({
   format: combine(
     consoleFormat,
   ),
@@ -45,9 +44,10 @@ const consoleLogger = createLogger({
   ],
 });
 
-const fileLogger = createLogger({
+export const fileLogger = createLogger({
   format: combine(
     timestamp(),
+    format.uncolorize(),
     fileFormat,
   ),
   transports: [
@@ -57,22 +57,3 @@ const fileLogger = createLogger({
     }),
   ],
 });
-
-const logger = {
-  debug (msg: string) {
-    consoleLogger.debug(msg);
-  },
-  info (msg: string) {
-    consoleLogger.info(msg);
-  },
-  warn (msg: string) {
-    consoleLogger.warn(msg);
-  },
-
-  error (msg: Error | string) {
-    consoleLogger.error(msg);
-    fileLogger.error(msg);
-  },
-};
-
-export default logger;