Merge pull request #13 from badsyntax/cli-improvements

Improve cli, add logger

Author: badsyntax

README.md

@@ -4,13 +4,13 @@
 
 A VS Code extension to manage Entity Framework migrations.
 
-## Features
-
 ![Entity Framework Migrations](images/treeview-screenshot.png)
 
-- List migrations by [DbContext](https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.dbcontext)
+## Features
+
+- List migrations by project [DbContext](https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.dbcontext)
 - Add/remove/run/undo migrations
-- Export [DbContext](https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.dbcontext) as SQL script
+- Export project [DbContext](https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.dbcontext) as SQL script
 
 ## Requirements
 

package.json

@@ -241,9 +241,31 @@
               "\"$project\"",
               "--context",
               "\"$dbContext\""
+            ],
+            "listDbContexts": [
+              "dotnet",
+              "ef",
+              "dbcontext",
+              "list",
+              "--project",
+              "\"$project\"",
+              "--no-color",
+              "--json"
+            ],
+            "listMigrations": [
+              "dotnet",
+              "ef",
+              "migrations",
+              "list",
+              "--context",
+              "\"$context\"",
+              "--project",
+              "\"$project\"",
+              "--no-color",
+              "--json"
             ]
           },
-          "description": "Environment vars when interacting with Entity Framework."
+          "description": "Environment variables when interacting with Entity Framework."
         }
       }
     }

src/actions/GenerateScriptAction.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
+import { CLI } from '../cli/CLI';
 
-import { getDataFromStdOut } from '../cli/ef';
 import { getCommandsConfig } from '../config/config';
 import type { TerminalProvider } from '../terminal/TerminalProvider';
 import { TerminalAction } from './TerminalAction';
@@ -24,7 +24,7 @@ export class GenerateScriptAction extends TerminalAction {
   }
 
   public async run() {
-    const output = getDataFromStdOut(await super.run());
+    const output = CLI.getDataFromStdOut(await super.run());
     const uri = vscode.Uri.parse('ef-script:' + output);
     const doc = await vscode.workspace.openTextDocument(uri);
     await vscode.languages.setTextDocumentLanguage(doc, 'sql');

src/actions/TerminalAction.ts

@@ -1,3 +1,4 @@
+import { CLI } from '../cli/CLI';
 import type { TerminalProvider } from '../terminal/TerminalProvider';
 import type { IAction } from './IAction';
 
@@ -11,15 +12,7 @@ export abstract class TerminalAction implements IAction {
 
   public async run(params = this.params): Promise<string> {
     const terminal = this.terminalProvider.provideTerminal();
-    terminal.setCmdARgs(
-      this.getInterpolatedArgs(params).concat(['--prefix-output']),
-    );
+    terminal.setCmdArgs(CLI.getInterpolatedArgs(this.args, params));
     return await terminal.exec(this.workingFolder);
   }
-
-  private getInterpolatedArgs(params = this.params) {
-    return this.args.map(arg =>
-      arg.replace(/\$[\w]+/, a => params[a.slice(1)] || a),
-    );
-  }
 }

src/cli/CLI.ts

@@ -0,0 +1,101 @@
+import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+import { spawn } from 'node:child_process';
+
+import { getEnvConfig } from '../config/config';
+import type { Logger } from '../util/logger';
+
+const NEWLINE_SEPARATOR = /\r\n|\r|\n/;
+const STDOUT_PREFIX = /^[a-z]+:    /;
+
+export class CLI {
+  constructor(private readonly logger: Logger) {}
+
+  public static getInterpolatedArgs(
+    args: string[],
+    params: { [key: string]: string },
+  ) {
+    return args.map(arg =>
+      arg.replace(/\$[\w]+/, a => params[a.slice(1)] || a),
+    );
+  }
+
+  public static getDataFromStdOut(output: string): string {
+    return this.removePrefixFromStdOut(
+      output
+        .split(NEWLINE_SEPARATOR)
+        .filter(line => line.startsWith('data:'))
+        .join('\n'),
+    );
+  }
+
+  public static getErrorsFromStdOut(output: string): string {
+    return this.removePrefixFromStdOut(
+      output
+        .split(NEWLINE_SEPARATOR)
+        .filter(line => line.startsWith('error:'))
+        .join('\n'),
+    );
+  }
+
+  public static removePrefixFromStdOut(output: string): string {
+    return output
+      .split(NEWLINE_SEPARATOR)
+      .map(line => line.replace(STDOUT_PREFIX, ''))
+      .join('\n');
+  }
+
+  public exec(
+    cmdArgs: string[],
+    cwd: string,
+    handlers?: {
+      onStdOut?: (buffer: string) => void;
+      onStdErr?: (buffer: string) => void;
+    },
+  ): {
+    cmd: ChildProcessWithoutNullStreams;
+    output: Promise<string>;
+  } {
+    this.logger.info(cmdArgs.join(' '));
+
+    const args = cmdArgs.concat(['--prefix-output']);
+
+    const cmd = spawn(args[0], args.slice(1), {
+      cwd,
+      env: {
+        ...process.env,
+        ...getEnvConfig(),
+      },
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    return {
+      cmd,
+      output: new Promise((res, rej) => {
+        cmd?.stdout.on('data', buffer => {
+          const data = buffer.toString();
+          stdout += data;
+          handlers?.onStdOut?.(data);
+        });
+
+        cmd?.stderr.on('data', buffer => {
+          const data = buffer.toString();
+          stderr += data;
+          handlers?.onStdErr?.(data);
+        });
+
+        cmd?.on('exit', async code => {
+          const error = stderr || CLI.getErrorsFromStdOut(stdout);
+          if (error || code !== 0) {
+            const finalError = error || stdout;
+            this.logger.error(finalError);
+            rej(new Error(finalError));
+          } else {
+            res(stdout);
+          }
+        });
+      }),
+    };
+  }
+}

src/cli/ef.ts

@@ -10,6 +10,8 @@ type CommandsConfig = {
   removeMigration: string[];
   runMigration: string[];
   generateScript: string[];
+  listDbContexts: string[];
+  listMigrations: string[];
 };
 
 export function getEnvConfig() {
@@ -26,5 +28,7 @@ export function getCommandsConfig() {
       removeMigration: [],
       runMigration: [],
       generateScript: [],
+      listDbContexts: [],
+      listMigrations: [],
     });
 }

src/config/config.ts

@@ -1,3 +1,5 @@
 export const EXTENSION_NAMESPACE = 'entityframework';
 
 export const TERMINAL_NAME = 'ef-migrations';
+
+export const OUTPUT_CHANNEL_ID = 'Entity Framework Migrations';

src/constants/constants.ts

@@ -1,4 +1,4 @@
-import type * as vscode from 'vscode';
+import * as vscode from 'vscode';
 
 import { TreeDataProvider } from './treeView/TreeDataProvider';
 import { CommandProvider } from './commands/CommandProvider';
@@ -7,16 +7,25 @@ import { Terminal } from './terminal/Terminal';
 import { TerminalProvider } from './terminal/TerminalProvider';
 import { ScriptFileProvider } from './util/ScriptFileProvider';
 import { ProjectFilesProvider } from './solution/ProjectFilesProvider';
+import { Logger } from './util/logger';
+import { OUTPUT_CHANNEL_ID } from './constants/constants';
+import { CLI } from './cli/CLI';
 
 const subscriptions: vscode.Disposable[] = [];
 
 export async function activate(_context: vscode.ExtensionContext) {
+  const logger = new Logger();
+  logger.setLoggingChannel(
+    vscode.window.createOutputChannel(OUTPUT_CHANNEL_ID),
+  );
+
+  const cli = new CLI(logger);
   const projectFiles = await ProjectFilesProvider.getProjectFiles();
   const scriptFileProvider = new ScriptFileProvider();
   const migrationTreeItemDecorationProvider =
     new MigrationTreeItemDecorationProvider();
-  const treeDataProvider = new TreeDataProvider(projectFiles);
-  const terminalProvider = new TerminalProvider(new Terminal());
+  const treeDataProvider = new TreeDataProvider(projectFiles, cli);
+  const terminalProvider = new TerminalProvider(new Terminal(cli));
   const commandProvider = new CommandProvider(
     treeDataProvider,
     terminalProvider,

src/extension.ts

@@ -1,16 +1,16 @@
 import * as vscode from 'vscode';
-import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { type ChildProcessWithoutNullStreams } from 'node:child_process';
 
 import { EventWaiter } from '../util/EventWaiter';
-import { getEnvConfig } from '../config/config';
-import { getErrorsFromStdOut, removePrefixFromStdOut } from '../cli/ef';
+import { CLI } from '../cli/CLI';
 
 const NL = '\n';
 const CR = '\r';
 const nlRegExp = new RegExp(`${NL}([^${CR}]|$)`, 'g');
 
 export class Terminal implements vscode.Pseudoterminal {
   private cmdArgs: string[] = [];
+  private cmdParams: { [key: string]: string } = {};
   private cmd: ChildProcessWithoutNullStreams | undefined;
 
   private readonly writeEmitter = new vscode.EventEmitter<string>();
@@ -23,58 +23,33 @@ export class Terminal implements vscode.Pseudoterminal {
 
   private readonly waitForOpen = new EventWaiter<undefined>(this.onDidOpen);
 
-  constructor() {}
+  constructor(private readonly cli: CLI) {}
 
   public async open(): Promise<void> {
     this.openEmitter.fire(undefined);
   }
 
   public async close(): Promise<void> {}
 
-  public setCmdARgs(cmdArgs: string[]) {
+  public setCmdArgs(cmdArgs: string[]) {
     this.cmdArgs = cmdArgs;
   }
 
   public async exec(cwd: string): Promise<string> {
     await this.waitForOpen.wait();
 
-    let stdout = '';
-    let stderr = '';
+    this.write(this.cmdArgs.join(' ') + '\n');
 
-    this.cmd = spawn(this.cmdArgs[0], this.cmdArgs.slice(1), {
-      cwd,
-      env: {
-        ...process.env,
-        ...getEnvConfig(),
+    const { cmd, output } = this.cli.exec(this.cmdArgs, cwd, {
+      onStdOut: (buffer: string) => {
+        this.write(CLI.removePrefixFromStdOut(buffer));
+      },
+      onStdErr: (buffer: string) => {
+        this.write(CLI.removePrefixFromStdOut(buffer));
       },
     });
-
-    return new Promise(res => {
-      // --prefix-output is an internal flag that is added to all commands
-      const argsWithoutPrefixOutput = this.cmdArgs.slice(0, -1);
-      this.write(argsWithoutPrefixOutput.join(' ') + '\n');
-
-      this.cmd?.stdout.on('data', data => {
-        const dataString = data.toString();
-        stdout += dataString;
-        this.write(removePrefixFromStdOut(dataString));
-      });
-
-      this.cmd?.stderr.on('data', data => {
-        const dataString = data.toString();
-        stderr += dataString;
-        this.write(removePrefixFromStdOut(dataString));
-      });
-
-      this.cmd?.on('exit', async _code => {
-        this.cmd = undefined;
-        const error = stderr || getErrorsFromStdOut(stdout);
-        if (error) {
-          await vscode.window.showErrorMessage(error);
-        }
-        res(stdout);
-      });
-    });
+    this.cmd = cmd;
+    return await output;
   }
 
   public async handleInput(data: string): Promise<void> {