Add reset / squash migrations feature. Fixes #46

Author: badsyntax

README.md

@@ -17,6 +17,7 @@ A VS Code extension to manage Entity Framework migrations.
 - List migrations by [`DbContext`](https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.dbcontext)
 - Add / Remove / Run / Undo migrations
 - Show migration applied status
+- Reset (Squash) Migrations
 - Export `DbContext` as SQL script
 - View `DbContext` information
 - [Scaffold](https://learn.microsoft.com/en-us/ef/core/cli/dotnet#dotnet-ef-dbcontext-scaffold) `DbContext` & entity types

package.json

@@ -50,6 +50,14 @@
           "dark": "icons/trash_dark.svg"
         }
       },
+      {
+        "command": "entityframework.resetMigrations",
+        "title": "Reset Migrations to Here",
+        "icon": {
+          "light": "icons/reply_light.svg",
+          "dark": "icons/reply_dark.svg"
+        }
+      },
       {
         "command": "entityframework.dbContextInfo",
         "title": "Information",
@@ -157,6 +165,10 @@
           "command": "entityframework.removeMigrations",
           "when": "false"
         },
+        {
+          "command": "entityframework.resetMigrations",
+          "when": "false"
+        },
         {
           "command": "entityframework.dbContextInfo",
           "when": "false"
@@ -204,6 +216,11 @@
           "when": "viewItem =~ /^migration-.*\\|?can-remove\\|?.*$/",
           "group": "context@2"
         },
+        {
+          "command": "entityframework.resetMigrations",
+          "when": "viewItem =~ /^migration-.*\\|?can-reset\\|?.*$/",
+          "group": "context@3"
+        },
         {
           "command": "entityframework.runMigration",
           "when": "viewItem =~ /^migration-.*\\|?can-apply\\|?.*$/",

src/actions/AddMigrationAction.ts

@@ -17,6 +17,7 @@ export class AddMigrationAction extends TerminalAction {
     private readonly workspaceRoot: string,
     private readonly dbContext: string,
     private readonly project: string,
+    private readonly migrationName?: string,
   ) {
     super(
       terminalProvider,
@@ -30,11 +31,13 @@ export class AddMigrationAction extends TerminalAction {
   }
 
   public async run() {
-    const migrationName = await vscode.window.showInputBox({
-      title: 'Enter Migration Name',
-      prompt: 'EG: MigrationName',
-      ignoreFocusOut: true,
-    });
+    const migrationName =
+      this.migrationName ||
+      (await vscode.window.showInputBox({
+        title: 'Enter Migration Name',
+        prompt: 'EG: MigrationName',
+        ignoreFocusOut: true,
+      }));
     if (!migrationName) {
       return '';
     }

src/actions/RemoveMigrationAction.ts

@@ -30,7 +30,7 @@ export class RemoveMigrationAction extends TerminalAction {
   }
 
   public async run() {
-    return vscode.window.withProgress(
+    return await vscode.window.withProgress(
       {
         title: 'Removing Migration...',
         location: { viewId: TREE_VIEW_ID },

src/actions/RemoveMigrationsAction.ts

@@ -2,6 +2,10 @@ import * as vscode from 'vscode';
 import { CommandProvider } from '../commands/CommandProvider';
 import { RefreshTreeCommand } from '../commands/RefreshTreeCommand';
 import type { TerminalProvider } from '../terminal/TerminalProvider';
+import {
+  dbContextsCache,
+  DbContextTreeItem,
+} from '../treeView/DbContextTreeItem';
 import type { MigrationTreeItem } from '../treeView/MigrationTreeItem';
 import type { IAction } from './IAction';
 import { RemoveMigrationAction } from './RemoveMigrationAction';
@@ -12,11 +16,23 @@ export class RemoveMigrationsAction implements IAction {
     private readonly workspaceRoot: string,
     private readonly dbContext: string,
     private readonly project: string,
-    private readonly migrationsToRemove: MigrationTreeItem[],
+    private readonly item: MigrationTreeItem,
   ) {}
 
   public async run() {
-    for (let i = 0; i < this.migrationsToRemove.length; i++) {
+    const migrations = dbContextsCache.get(
+      DbContextTreeItem.getCacheId(
+        this.workspaceRoot,
+        this.project,
+        this.dbContext,
+      ),
+    );
+    const index = (migrations || []).indexOf(this.item);
+    if (index === -1) {
+      return;
+    }
+    const migrationsToRemove = migrations?.slice(index) || [];
+    for (let i = 0; i < migrationsToRemove.length; i++) {
       await new RemoveMigrationAction(
         this.terminalProvider,
         this.workspaceRoot,
@@ -25,7 +41,7 @@ export class RemoveMigrationsAction implements IAction {
         false,
       ).run();
     }
-    if (this.migrationsToRemove.length > 0) {
+    if (migrationsToRemove.length > 0) {
       await vscode.commands.executeCommand(
         CommandProvider.getCommandName(RefreshTreeCommand.commandName),
         false,

src/actions/ResetMigrationsAction.ts

@@ -0,0 +1,76 @@
+import * as vscode from 'vscode';
+import { UndoMigrationCommand } from '../commands/UndoMigrationCommand';
+import type { TerminalProvider } from '../terminal/TerminalProvider';
+import {
+  dbContextsCache,
+  DbContextTreeItem,
+} from '../treeView/DbContextTreeItem';
+import type { MigrationTreeItem } from '../treeView/MigrationTreeItem';
+import { AddMigrationAction } from './AddMigrationAction';
+import type { IAction } from './IAction';
+import { RemoveMigrationAction } from './RemoveMigrationAction';
+
+export class ResetMigrationsAction implements IAction {
+  constructor(
+    private readonly terminalProvider: TerminalProvider,
+    private readonly workspaceRoot: string,
+    private readonly dbContext: string,
+    private readonly project: string,
+    private readonly item: MigrationTreeItem,
+  ) {}
+
+  public async run() {
+    const migrations = dbContextsCache.get(
+      DbContextTreeItem.getCacheId(
+        this.workspaceRoot,
+        this.project,
+        this.dbContext,
+      ),
+    );
+    const index = (migrations || []).indexOf(this.item);
+    if (index === -1) {
+      return;
+    }
+    const migrationsToReset = migrations?.slice(index) || [];
+    if (!migrationsToReset.length) {
+      return;
+    }
+    const options = ['Yes', 'Cancel'] as const;
+    const answer = await vscode.window.showInformationMessage(
+      'Any manual migration modifications will be lost! Are you sure you want to do this?',
+      ...options,
+    );
+    if (answer === 'Cancel') {
+      return;
+    }
+    const migrationName = await vscode.window.showInputBox({
+      title: 'Enter Migration Name',
+      prompt: 'EG: MigrationName',
+      ignoreFocusOut: true,
+    });
+    if (!migrationName) {
+      return '';
+    }
+    await new UndoMigrationCommand(
+      this.terminalProvider,
+      this.item,
+      false,
+    ).run();
+    for (let i = 0; i < migrationsToReset.length; i++) {
+      await new RemoveMigrationAction(
+        this.terminalProvider,
+        this.workspaceRoot,
+        this.dbContext,
+        this.project,
+        false,
+      ).run();
+    }
+    await new AddMigrationAction(
+      this.terminalProvider,
+      this.workspaceRoot,
+      this.dbContext,
+      this.project,
+      migrationName,
+    ).run();
+  }
+}

src/actions/RunMigrationAction.ts

@@ -17,6 +17,7 @@ export class RunMigrationAction extends TerminalAction {
     private readonly dbContext: string,
     private readonly project: string,
     migrationId: string,
+    private readonly refresh?: boolean,
   ) {
     super(
       terminalProvider,
@@ -51,10 +52,12 @@ export class RunMigrationAction extends TerminalAction {
         );
         dbContextsCache.clear(cacheId);
 
-        await vscode.commands.executeCommand(
-          CommandProvider.getCommandName(RefreshTreeCommand.commandName),
-          false,
-        );
+        if (this.refresh) {
+          await vscode.commands.executeCommand(
+            CommandProvider.getCommandName(RefreshTreeCommand.commandName),
+            false,
+          );
+        }
 
         return output;
       },

src/commands/CommandProvider.ts

@@ -18,6 +18,7 @@ import { RefreshDbContextTreeCommand } from './RefreshDbContextTreeCommand';
 import { RefreshProjectTreeCommand } from './RefreshProjectTreeCommand';
 import { RefreshTreeCommand } from './RefreshTreeCommand';
 import { RemoveMigrationsCommand } from './RemoveMigrationsCommand';
+import { ResetMigrationsCommand } from './ResetMigrationsCommand';
 import { RunMigrationCommand } from './RunMigrationCommand';
 import { ScaffoldCommand } from './ScaffoldCommand';
 import { UndoMigrationCommand } from './UndoMigrationCommand';
@@ -42,6 +43,12 @@ export class CommandProvider extends Disposable {
         return new RemoveMigrationsCommand(terminalProvider, item);
       },
     );
+    this.registerCommand(
+      ResetMigrationsCommand.commandName,
+      (item?: MigrationTreeItem) => {
+        return new ResetMigrationsCommand(terminalProvider, item);
+      },
+    );
     this.registerCommand(
       RunMigrationCommand.commandName,
       (item?: MigrationTreeItem) =>

src/commands/RemoveMigrationsCommand.ts

@@ -1,9 +1,5 @@
 import { RemoveMigrationsAction } from '../actions/RemoveMigrationsAction';
 import type { TerminalProvider } from '../terminal/TerminalProvider';
-import {
-  dbContextsCache,
-  DbContextTreeItem,
-} from '../treeView/DbContextTreeItem';
 import { type MigrationTreeItem } from '../treeView/MigrationTreeItem';
 import { Command } from './Command';
 
@@ -21,24 +17,12 @@ export class RemoveMigrationsCommand extends Command {
     if (!this.item) {
       return;
     }
-    const migrations = dbContextsCache.get(
-      DbContextTreeItem.getCacheId(
-        this.item.workspaceRoot,
-        this.item.projectFile.name,
-        this.item.dbContext,
-      ),
-    );
-    const index = (migrations || []).indexOf(this.item);
-    if (index === -1) {
-      return;
-    }
-    const migrationsToRemove = migrations?.slice(index) || [];
     return new RemoveMigrationsAction(
       this.terminalProvider,
       this.item.workspaceRoot,
       this.item.dbContext,
       this.item.projectFile.name,
-      migrationsToRemove,
+      this.item,
     ).run();
   }
 }

src/commands/ResetMigrationsCommand.ts

@@ -0,0 +1,29 @@
+import { ResetMigrationsAction } from '../actions/ResetMigrationsAction';
+import type { TerminalProvider } from '../terminal/TerminalProvider';
+
+import { type MigrationTreeItem } from '../treeView/MigrationTreeItem';
+import { Command } from './Command';
+
+export class ResetMigrationsCommand extends Command {
+  public static commandName = 'resetMigrations';
+
+  constructor(
+    private readonly terminalProvider: TerminalProvider,
+    private readonly item?: MigrationTreeItem,
+  ) {
+    super();
+  }
+
+  public async run() {
+    if (!this.item) {
+      return;
+    }
+    return new ResetMigrationsAction(
+      this.terminalProvider,
+      this.item.workspaceRoot,
+      this.item.dbContext,
+      this.item.projectFile.name,
+      this.item,
+    ).run();
+  }
+}

src/commands/RunMigrationCommand.ts

@@ -23,6 +23,7 @@ export class RunMigrationCommand extends Command {
       this.item.dbContext,
       this.item.projectFile.name,
       this.item.migration.id,
+      true,
     ).run();
   }
 }

src/commands/UndoMigrationCommand.ts

@@ -13,6 +13,7 @@ export class UndoMigrationCommand extends Command {
   constructor(
     private readonly terminalProvider: TerminalProvider,
     private readonly item?: MigrationTreeItem,
+    private readonly refresh?: boolean,
   ) {
     super();
   }
@@ -31,12 +32,13 @@ export class UndoMigrationCommand extends Command {
       const index = migrations.indexOf(this.item);
       const migrationId =
         index === 0 ? '0' : migrations[index - 1].migration.id;
-      return new RunMigrationAction(
+      return await new RunMigrationAction(
         this.terminalProvider,
         this.item.workspaceRoot,
         this.item.dbContext,
         this.item.projectFile.name,
         migrationId,
+        this.refresh,
       ).run();
     }
   }

src/treeView/DbContextTreeItem.ts

@@ -82,7 +82,7 @@ export class DbContextTreeItem extends TreeItem {
     } catch (e) {
       const msg = `Unable to get migrations: ${(e as Error).message}`.trim();
       this.logger.error(msg);
-      await vscode.window.showErrorMessage(msg, 'OK');
+      void vscode.window.showErrorMessage(msg, 'OK');
       return [];
     }
   }

src/treeView/MigrationTreeItem.ts

@@ -31,11 +31,17 @@ export class MigrationTreeItem extends TreeItem {
 
 function getMigrationContextValue(migration: Migration): string {
   const states: Array<
-    'can-apply' | 'can-undo' | 'can-remove' | 'applied' | 'not-applied'
+    | 'can-apply'
+    | 'can-undo'
+    | 'can-remove'
+    | 'applied'
+    | 'not-applied'
+    | 'can-reset'
   > = [];
   if (migration.applied) {
     states.push('applied');
     states.push('can-undo');
+    states.push('can-reset');
   } else {
     states.push('can-remove');
     states.push('can-apply');

src/treeView/ProjectTreeItem.ts

@@ -82,7 +82,7 @@ export class ProjectTreeItem extends TreeItem {
     } catch (e) {
       const msg = `Unable to get dbContexts: ${(e as Error).message}`.trim();
       this.logger.error(msg);
-      await vscode.window.showErrorMessage(msg, 'OK');
+      void vscode.window.showErrorMessage(msg, 'OK');
       return [];
     }
   }

src/util/InputWizard.ts

@@ -86,7 +86,7 @@ export class InputWizard {
         inputValues.push(inputVal);
       }
     } catch (e) {
-      await vscode.window.showErrorMessage('Invalid input');
+      void vscode.window.showErrorMessage('Invalid input');
       return [];
     }
     return inputValues;