Add context menu option to generate snapshots for .bicepparam files

src/Bicep.LangServer/Handlers/BicepSnapshotCommandHandler.cs

@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Bicep.Core;
+using Bicep.Core.Diagnostics;
+using Bicep.Core.Emit;
+using Bicep.Core.Extensions;
+using Bicep.Core.Utils.Snapshots;
+using Bicep.IO.Abstraction;
+using Bicep.LanguageServer.CompilationManager;
+using Bicep.LanguageServer.Utils;
+using OmniSharp.Extensions.JsonRpc;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Extensions.LanguageServer.Protocol.Workspace;
+
+namespace Bicep.LanguageServer.Handlers
+{
+    // This handler is used to generate a snapshot (.snapshot.json) file for a given bicep parameters file.
+    // It returns snapshot generation succeeded/failed message, which can be displayed appropriately in IDE output window
+    public class BicepSnapshotCommandHandler : ExecuteTypedResponseCommandHandlerBase<DocumentUri, string>
+    {
+        private readonly ICompilationManager compilationManager;
+        private readonly IFileExplorer fileExplorer;
+        private readonly BicepCompiler bicepCompiler;
+
+        public BicepSnapshotCommandHandler(ICompilationManager compilationManager, IFileExplorer fileExplorer, BicepCompiler bicepCompiler, ISerializer serializer)
+            : base(LangServerConstants.SnapshotCommand, serializer)
+        {
+            this.compilationManager = compilationManager;
+            this.fileExplorer = fileExplorer;
+            this.bicepCompiler = bicepCompiler;
+        }
+
+        public override async Task<string> Handle(DocumentUri documentUri, CancellationToken cancellationToken)
+        {
+            string output = await GenerateSnapshotFileAndReturnOutputMessage(documentUri, cancellationToken);
+
+            return output;
+        }
+
+        private async Task<string> GenerateSnapshotFileAndReturnOutputMessage(DocumentUri documentUri, CancellationToken cancellationToken)
+        {
+            var bicepParamFileUri = documentUri.ToIOUri();
+            var snapshotFileUri = bicepParamFileUri.WithExtension(".snapshot.json");
+            var snapshotFile = this.fileExplorer.GetFile(snapshotFileUri);
+
+            var compilation = await new CompilationHelper(bicepCompiler, compilationManager).GetRefreshedCompilation(documentUri);
+            var paramsResult = compilation.Emitter.Parameters();
+
+            if (paramsResult.Success != true || paramsResult.Template?.Template is not { } templateContent || paramsResult.Parameters is not { } parametersContent)
+            {
+                var diagnosticsByFile = compilation.GetAllDiagnosticsByBicepFile();
+
+                return "Generating snapshot file failed. Please fix below errors:\n" + DiagnosticsHelper.GetDiagnosticsMessage(diagnosticsByFile);
+            }
+
+            try
+            {
+                var snapshot = await SnapshotHelper.GetSnapshot(
+                    targetScope: compilation.GetEntrypointSemanticModel().TargetScope,
+                    templateContent: templateContent,
+                    parametersContent: parametersContent,
+                    tenantId: null,
+                    subscriptionId: null,
+                    resourceGroup: null,
+                    location: null,
+                    deploymentName: null,
+                    cancellationToken: cancellationToken,
+                    externalInputs: []);
+
+                if (snapshot.Diagnostics.Length > 0)
+{
+                    var diagnosticsMessage = string.Join("\n", snapshot.Diagnostics.Select(d => $"  {d}"));
+                    return $"Snapshot generation completed with warnings:\n{diagnosticsMessage}\n\nSnapshot file created at {snapshotFileUri}";
+                }
+
+                var contents = SnapshotHelper.Serialize(snapshot);
+                await snapshotFile.WriteAllTextAsync(contents, cancellationToken);
+
+                return $"Snapshot generation succeeded. Created file {snapshotFileUri}";
+            }
+            catch (Exception ex)
+            {
+                return $"Snapshot generation failed: {ex.Message}";
+            }
+        }
+    }
+}

src/Bicep.LangServer/LangServerConstants.cs

@@ -12,6 +12,7 @@ public static class LangServerConstants
         public const string DecompileSaveCommand = "decompileSave";
         public const string GenerateParamsCommand = "generateParams";
         public const string BuildParamsCommand = "buildParams";
+        public const string SnapshotCommand = "snapshot";
         public const string DeployCompleteMethod = "deploymentComplete";
         public const string DeployStartCommand = "deploy/start";
         public const string DeployWaitForCompletionCommand = "deploy/waitForCompletion";

src/Bicep.LangServer/Server.cs

@@ -56,6 +56,7 @@ public Server(BicepLangServerOptions bicepLangServerOptions, Action<LanguageServ
                     .WithHandler<BicepBuildCommandHandler>()
                     .WithHandler<BicepGenerateParamsCommandHandler>()
                     .WithHandler<BicepBuildParamsCommandHandler>()
+                    .WithHandler<BicepSnapshotCommandHandler>()
                     .WithHandler<BicepDeploymentStartCommandHandler>()
                     // Base handler (ExecuteTypedResponseCommandHandlerBase) is serial. This blocks other commands on the client side.
                     // To avoid the above issue, we'll change the RequestProcessType to parallel

src/vscode-bicep/package.json

@@ -271,6 +271,12 @@
         "category": "Bicep",
         "icon": "$(output)"
       },
+      {
+        "command": "bicep.snapshot",
+        "title": "Generate Snapshot",
+        "category": "Bicep",
+        "icon": "$(file-code)"
+      },
       {
         "command": "bicep.internal.showModuleSourceFile",
         "title": "(Show a source file from a module)",
@@ -425,6 +431,11 @@
           "when": "resourceLangId == bicep-params",
           "group": "2_bicep_1_edit"
         },
+        {
+          "command": "bicep.snapshot",
+          "when": "resourceLangId == bicep-params",
+          "group": "2_bicep_1_edit"
+        },
         {
           "command": "bicep.decompileParams",
           "when": "resourceLangId == json || resourceLangId == jsonc",
@@ -487,6 +498,11 @@
           "when": "resourceLangId == bicep-params",
           "group": "2_bicep_1_edit"
         },
+        {
+          "command": "bicep.snapshot",
+          "when": "resourceLangId == bicep-params",
+          "group": "2_bicep_1_edit"
+        },
         {
           "command": "bicep.decompileParams",
           "when": "resourceLangId == json || resourceLangId == jsonc",
@@ -554,6 +570,11 @@
           "when": "resourceLangId == bicep-params",
           "group": "2_bicep_1_edit"
         },
+        {
+          "command": "bicep.snapshot",
+          "when": "resourceLangId == bicep-params",
+          "group": "2_bicep_1_edit"
+        },
         {
           "command": "bicep.decompileParams",
           "when": "resourceLangId == json || resourceLangId == jsonc",
@@ -620,6 +641,10 @@
           "command": "bicep.buildParams",
           "group": "0_bicep"
         },
+        {
+          "command": "bicep.snapshot",
+          "group": "0_bicep"
+        },
         {
           "command": "bicep.internal.showModuleSourceFile",
           "when": "never"

src/vscode-bicep/src/commands/snapshot.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { IActionContext, parseError } from "@microsoft/vscode-azext-utils";
+import vscode from "vscode";
+import { LanguageClient } from "vscode-languageclient/node";
+import { OutputChannelManager } from "../utils/OutputChannelManager";
+import { findOrCreateActiveBicepParamFile } from "./findOrCreateActiveBicepFile";
+import { Command } from "./types";
+
+export class SnapshotCommand implements Command {
+  public readonly id = "bicep.snapshot";
+  public constructor(
+    private readonly client: LanguageClient,
+    private readonly outputChannelManager: OutputChannelManager,
+  ) {}
+
+  public async execute(context: IActionContext, documentUri?: vscode.Uri | undefined): Promise<void> {
+    documentUri = await findOrCreateActiveBicepParamFile(
+      context,
+      documentUri,
+      "Choose which Bicep Parameters file to generate a snapshot from",
+    );
+
+    if (documentUri.scheme.toLowerCase() !== "file") {
+      this.client.error(
+        "Snapshot generation failed. The active file must be saved to your local filesystem.",
+        undefined,
+        true,
+      );
+      return;
+    }
+
+    try {
+      const snapshotOutput: string = await this.client.sendRequest("workspace/executeCommand", {
+        command: "snapshot",
+        arguments: [documentUri.toString()],
+      });
+      this.outputChannelManager.appendToOutputChannel(snapshotOutput);
+    } catch (err) {
+      this.client.error("Snapshot generation failed", parseError(err).message, true);
+    }
+  }
+}

src/vscode-bicep/src/extension.ts

@@ -18,6 +18,7 @@ import * as lsp from "vscode-languageclient/node";
 import { AzureUiManager } from "./azure/AzureUiManager";
 import { BuildCommand } from "./commands/build";
 import { BuildParamsCommand } from "./commands/buildParams";
+import { SnapshotCommand } from "./commands/snapshot";
 import { CommandManager } from "./commands/commandManager";
 import { CreateBicepConfigurationFile } from "./commands/createConfigurationFile";
 import { DecompileCommand } from "./commands/decompile";
@@ -147,6 +148,7 @@ export async function activate(extensionContext: ExtensionContext): Promise<void
             new BuildCommand(languageClient, outputChannelManager),
             new GenerateParamsCommand(languageClient, outputChannelManager),
             new BuildParamsCommand(languageClient, outputChannelManager),
+            new SnapshotCommand(languageClient, outputChannelManager),
             new CreateBicepConfigurationFile(languageClient),
             new DeployCommand(languageClient, outputChannelManager, azurePickers),
             new DecompileCommand(languageClient, outputChannelManager),