Show CLI warnings & improve ER diagram generation

sample_dotnet/ExampleAPI/Context/BloggingContext.cs

@@ -11,16 +11,9 @@ public class BloggingContext : DbContext
 
     public DbSet<Tag> Tags { get; set; }
 
-    public string DbPath { get; private set; }
-
-    public BloggingContext()
-    {
-        DbPath = $"blogging.db";
-    }
-
     protected override void OnConfiguring(DbContextOptionsBuilder options)
     {
-        options.UseSqlite($"Data Source={DbPath}");
+        options.UseSqlite($"Data Source=blogging.db");
         options.LogTo(Console.WriteLine);
         options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
     }

src/actions/DBContextInfoCommandAction.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 
-import { CLI } from '../cli/CLI';
+import { EFOutputParser } from '../cli/EFOutputParser';
 import { getCommandsConfig } from '../config/config';
 import { TREE_VIEW_ID } from '../constants/constants';
 
@@ -42,14 +42,12 @@ export class DBContextInfoCommandAction extends TerminalAction {
           removeDataFromOutput: true,
           asJson: true,
         });
-        const output = CLI.getDataFromStdOut(await this.getOutput());
-        const uri = vscode.Uri.parse(
-          `${TextDocumentProvider.scheme}:${output}`,
-        );
+        const { data } = EFOutputParser.parse(await this.getOutput());
+        const uri = vscode.Uri.parse(`${TextDocumentProvider.scheme}:${data}`);
         const doc = await vscode.workspace.openTextDocument(uri);
         await vscode.languages.setTextDocumentLanguage(doc, 'json');
         await vscode.window.showTextDocument(doc, { preview: false });
-        return output;
+        return data;
       },
     );
   }

src/actions/GenerateERDAction.ts

@@ -4,7 +4,6 @@ import path from 'path';
 import fs from 'fs';
 import util from 'util';
 
-import { CLI } from '../cli/CLI';
 import { getCommandsConfig, getERDConfig } from '../config/config';
 import { TerminalAction } from './TerminalAction';
 import { DEFAULT_EFCORE_PROVIDERS, TREE_VIEW_ID } from '../constants/constants';
@@ -18,6 +17,7 @@ import type { Logger } from '../util/Logger';
 
 // @ts-ignore
 import mermaidTemplate from '../templates/DbContext.Mermaid.t4';
+import { EFOutputParser } from '../cli/EFOutputParser';
 
 const copyFile = util.promisify(fs.copyFile);
 const rename = util.promisify(fs.rename);
@@ -162,7 +162,7 @@ export class GenerateERDAction extends TerminalAction {
             },
           );
           const output = await this.getOutput();
-          const data = CLI.getDataFromStdOut(await this.getOutput());
+          const { data } = EFOutputParser.parse(output);
           const result = JSON.parse(data) as ScaffoldResult;
 
           const fileContents = fs.readFileSync(result.contextFile, 'utf-8');

src/actions/GenerateScriptAction.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 
-import { CLI } from '../cli/CLI';
+import { EFOutputParser } from '../cli/EFOutputParser';
 import { getCommandsConfig } from '../config/config';
 import { TREE_VIEW_ID } from '../constants/constants';
 import type { TerminalProvider } from '../terminal/TerminalProvider';
@@ -40,7 +40,7 @@ export class GenerateScriptAction extends TerminalAction {
           removeDataFromOutput: true,
         });
         const output = await this.getOutput();
-        const data = CLI.getDataFromStdOut(output);
+        const { data } = EFOutputParser.parse(output);
         const uri = vscode.Uri.parse(`${TextDocumentProvider.scheme}:${data}`);
         const doc = await vscode.workspace.openTextDocument(uri);
         await vscode.languages.setTextDocumentLanguage(doc, 'sql');

src/actions/ScaffoldAction.ts

@@ -1,6 +1,6 @@
 import type { Project } from 'nuget-deps-tree';
 import * as vscode from 'vscode';
-import { CLI } from '../cli/CLI';
+import { EFOutputParser } from '../cli/EFOutputParser';
 import { CommandProvider } from '../commands/CommandProvider';
 import { RefreshTreeCommand } from '../commands/RefreshTreeCommand';
 import { getCommandsConfig } from '../config/config';
@@ -136,10 +136,9 @@ export class ScaffoldAction extends TerminalAction {
             asJson: true,
           },
         );
-        const output = JSON.parse(
-          CLI.getDataFromStdOut(await this.getOutput()),
-        ) as ScaffoldResult;
 
+        const { data } = EFOutputParser.parse(await this.getOutput());
+        const output = JSON.parse(data) as ScaffoldResult;
         const uri = vscode.Uri.file(output.contextFile);
         const doc = await vscode.workspace.openTextDocument(uri);
         await vscode.window.showTextDocument(doc);

src/cli/CLI.ts

@@ -2,11 +2,8 @@ import type { ChildProcess } from 'child_process';
 import { spawn } from 'child_process';
 
 import { getEnvConfig } from '../config/config';
-import { TerminalColors } from '../terminal/TerminalColors';
 import type { Logger } from '../util/Logger';
-
-const NEWLINE_SEPARATOR = /\r\n|\r|\n/;
-const OUTPUT_PREFIX = /^([a-z]+:([\s]{4}|[\s]{3}))/;
+import { EFOutputParser } from './EFOutputParser';
 
 export type ExecOpts = {
   cmdArgs: string[];
@@ -29,67 +26,6 @@ export type ExecProcess = {
 export class CLI {
   constructor(private readonly logger: Logger) {}
 
-  public static getDataFromStdOut(output: string): string {
-    return this.stripPrefixFromStdOut(
-      output
-        .split(NEWLINE_SEPARATOR)
-        .filter(line => line.startsWith('data:'))
-        .join('\n'),
-    );
-  }
-
-  public static getErrorsFromStdOut(output: string): string {
-    return this.stripPrefixFromStdOut(
-      output
-        .split(NEWLINE_SEPARATOR)
-        .filter(line => line.startsWith('error:'))
-        .join('\n'),
-    );
-  }
-
-  private static filter(out: string, prefix: string) {
-    return out
-      .split(NEWLINE_SEPARATOR)
-      .filter(line => !line.trim().startsWith(prefix))
-      .join('\n');
-  }
-
-  public static filterInfoFromOutput(out: string): string {
-    return this.filter(out, 'info:');
-  }
-
-  public static filterDataFromOutput(out: string): string {
-    return this.filter(out, 'data:');
-  }
-
-  public static colorizeOutput(output: string): string {
-    return output
-      .split(NEWLINE_SEPARATOR)
-      .map(line => {
-        if (line.startsWith('warn:')) {
-          return (
-            line.replace(OUTPUT_PREFIX, `$1${TerminalColors.yellow}`) +
-            TerminalColors.reset
-          );
-        }
-        if (line.startsWith('error:')) {
-          return (
-            line.replace(OUTPUT_PREFIX, `$1${TerminalColors.red}`) +
-            TerminalColors.reset
-          );
-        }
-        return line;
-      })
-      .join('\n');
-  }
-
-  public static stripPrefixFromStdOut(output: string): string {
-    return output
-      .split(NEWLINE_SEPARATOR)
-      .map(line => line.replace(OUTPUT_PREFIX, ''))
-      .join('\n');
-  }
-
   private getInterpolatedArgs(
     args: string[],
     params: { [key: string]: string },
@@ -117,12 +53,14 @@ export class CLI {
 
     const args = interpolatedArgs.concat(additionalArgs);
 
+    const envConfig = getEnvConfig();
+
     const cmd = spawn(args[0], args.slice(1), {
       cwd,
       shell: true,
       env: {
         ...process.env,
-        ...getEnvConfig(),
+        ...envConfig,
       },
     });
 
@@ -149,10 +87,12 @@ export class CLI {
         });
 
         cmd?.on('exit', async code => {
-          const error = stderr || CLI.getErrorsFromStdOut(stdout);
+          const error = stderr || EFOutputParser.parse(stdout).errors;
           if (error || code !== 0) {
             handlers?.onStdOut?.(`Exited with code ${code}\n`);
-            const finalError = CLI.filterInfoFromOutput(error || stdout);
+            const finalError = EFOutputParser.filterInfoFromOutput(
+              error || stdout,
+            );
             rej(new Error(finalError));
           } else {
             res(stdout);

src/cli/EFOutputParser.ts

@@ -0,0 +1,89 @@
+import { TerminalColors } from '../terminal/TerminalColors';
+
+const NEWLINE_SEPARATOR = /\r\n|\r|\n/;
+const OUTPUT_PREFIX = /^([a-z]+:([\s]{1,4}))/;
+
+export class EFOutputParser {
+  private static filter(out: string, prefix: string) {
+    return out
+      .split(NEWLINE_SEPARATOR)
+      .filter(line => !line.trim().startsWith(prefix))
+      .join('\n');
+  }
+
+  public static filterInfoFromOutput(out: string): string {
+    return this.filter(out, 'info:');
+  }
+
+  public static filterDataFromOutput(out: string): string {
+    return this.filter(out, 'data:');
+  }
+
+  public static stripPrefixFromStdOut(output: string): string {
+    return output
+      .split(NEWLINE_SEPARATOR)
+      .map(line => line.replace(OUTPUT_PREFIX, ''))
+      .join('\n');
+  }
+
+  public static colorizeOutput(output: string): string {
+    return output
+      .split(NEWLINE_SEPARATOR)
+      .map(line => {
+        if (line.startsWith('warn:')) {
+          return (
+            line.replace(OUTPUT_PREFIX, `$1${TerminalColors.yellow}`) +
+            TerminalColors.reset
+          );
+        }
+        if (line.startsWith('error:')) {
+          return (
+            line.replace(OUTPUT_PREFIX, `$1${TerminalColors.red}`) +
+            TerminalColors.reset
+          );
+        }
+        return line;
+      })
+      .join('\n');
+  }
+
+  public static parse(output: string) {
+    let warnings = '';
+    let data = '';
+    let errors = '';
+    let matchedWarning = false;
+    let matchedError = false;
+
+    output.split(NEWLINE_SEPARATOR).forEach(line => {
+      if (matchedWarning && !OUTPUT_PREFIX.test(line)) {
+        matchedWarning = true;
+      } else {
+        matchedWarning = line.startsWith('warn:');
+      }
+
+      if (matchedError && !OUTPUT_PREFIX.test(line)) {
+        matchedError = true;
+      } else {
+        matchedError = line.startsWith('error:');
+      }
+
+      const matchedData = line.startsWith('data:');
+
+      const lineWithoutPrefix = line.replace(OUTPUT_PREFIX, '');
+
+      if (matchedWarning) {
+        warnings += lineWithoutPrefix;
+      } else if (matchedError) {
+        errors += lineWithoutPrefix;
+      } else if (matchedData) {
+        data += lineWithoutPrefix;
+      }
+    });
+
+    return {
+      warnings,
+      errors,
+      data,
+    };
+  }
+}

src/terminal/Terminal.ts

@@ -3,8 +3,9 @@ import type { ChildProcess } from 'child_process';
 
 import { EventWaiter } from '../util/EventWaiter';
 import type { ExecOpts, ExecProcess } from '../cli/CLI';
-import { CLI } from '../cli/CLI';
+import type { CLI } from '../cli/CLI';
 import { TerminalColors } from './TerminalColors';
+import { EFOutputParser } from '../cli/EFOutputParser';
 
 const NL = '\n';
 const CR = '\r';
@@ -39,11 +40,11 @@ export class Terminal implements vscode.Pseudoterminal {
       } else {
         let line = lineBuffer + buffer;
         lineBuffer = '';
-        line = CLI.colorizeOutput(line);
+        line = EFOutputParser.colorizeOutput(line);
         if (removeDataFromOutput) {
-          line = CLI.filterDataFromOutput(line);
+          line = EFOutputParser.filterDataFromOutput(line);
         }
-        this.write(CLI.stripPrefixFromStdOut(line));
+        this.write(EFOutputParser.stripPrefixFromStdOut(line));
       }
     };
   }

src/treeView/DbContextTreeItem.ts

@@ -3,12 +3,13 @@ import type { Migration } from '../types/Migration';
 import { getIconPath } from './iconProvider';
 import { MigrationTreeItem } from './MigrationTreeItem';
 import { TreeItem } from './TreeItem';
-import { CLI } from '../cli/CLI';
+import type { CLI } from '../cli/CLI';
 import { TreeItemCache } from './TreeItemCache';
 import { ContextValues } from './ContextValues';
 import type { ProjectFile } from '../types/ProjectFile';
 import { getCommandsConfig } from '../config/config';
 import type { Logger } from '../util/Logger';
+import { EFOutputParser } from '../cli/EFOutputParser';
 
 export const dbContextsCache = new TreeItemCache<MigrationTreeItem[]>();
 
@@ -58,10 +59,14 @@ export class DbContextTreeItem extends TreeItem {
           project: this.projectFile.name,
         },
       });
+      const stdOut = await output;
+      const { data, warnings } = EFOutputParser.parse(stdOut);
 
-      const migrations = JSON.parse(
-        CLI.getDataFromStdOut(await output),
-      ) as Migration[];
+      if (warnings) {
+        void vscode.window.showWarningMessage(warnings);
+      }
+
+      const migrations = JSON.parse(data) as Migration[];
 
       const children = migrations.map(
         migration =>