Improve Event Grid Local Development Experience

package.json

@@ -350,6 +350,12 @@
                 "command": "azureFunctions.viewProperties",
                 "title": "%azureFunctions.viewProperties%",
                 "category": "Azure Functions"
+            },
+            {
+                "command": "azureFunctions.eventGrid.sendMockRequest",
+                "title": "%azureFunctions.eventGrid.sendMockRequest%",
+                "category": "Azure Functions",
+                "icon": "$(notebook-execute)"
             }
         ],
         "submenus": [
@@ -687,6 +693,13 @@
                     "when": "resourceFilename==function.json",
                     "group": "zzz_binding@1"
                 }
+            ],
+            "editor/title": [
+                {
+                    "command": "azureFunctions.eventGrid.sendMockRequest",
+                    "when": "resourceFilename=~/.*.eventgrid.json$/",
+                    "group": "navigation@1"
+                }
             ]
         },
         "jsonValidation": [

package.nls.json

@@ -105,6 +105,7 @@
     "azureFunctions.viewCommitInGitHub": "View Commit in GitHub",
     "azureFunctions.viewDeploymentLogs": "View Deployment Logs",
     "azureFunctions.viewProperties": "View Properties",
+    "azureFunctions.eventGrid.sendMockRequest": "Save and execute...",
     "azureFunctions.walkthrough.functionsStart.create.description": "If you're just getting started, you will need to create an Azure Functions project. Follow along with the [Visual Studio Code developer guide](https://aka.ms/functions-getstarted-vscode) for step-by-step instructions.\n[Create New Project](command:azureFunctions.createNewProject)",
     "azureFunctions.walkthrough.functionsStart.create.title": "Create a new Azure Functions project",
     "azureFunctions.walkthrough.functionsStart.description": "Learn about Azure Functions and the Azure Functions extension for Visual Studio Code",

src/commands/executeFunction/eventGrid/EventGridCodeLensProvider.ts

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { CodeLens, Range, type CodeLensProvider } from 'vscode';
+import { localize } from '../../../localize';
+
+export class EventGridCodeLensProvider implements CodeLensProvider {
+    public provideCodeLenses(): CodeLens[] {
+        const firstLineLens = new CodeLens(new Range(0, 0, 0, 0));
+
+        firstLineLens.command = {
+            title: localize('saveExecute', 'Save and execute'),
+            command: 'azureFunctions.eventGrid.sendMockRequest',
+        };
+
+        return [firstLineLens];
+    }
+}

src/commands/executeFunction/eventGrid/EventGridExecuteFunctionContext.ts

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { type IActionContext } from "@microsoft/vscode-azext-utils";
+import { type EventGridSource } from "./eventGridSources";
+
+
+export interface EventGridExecuteFunctionContext extends IActionContext {
+    eventSource?: EventGridSource;
+    selectedFileName?: string;
+    selectedFileUrl?: string;
+    fileOpened?: boolean;
+}
+

src/commands/executeFunction/eventGrid/EventGridFileOpenStep.ts

@@ -0,0 +1,95 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzExtFsExtra, AzureWizardExecuteStep, nonNullProp } from "@microsoft/vscode-azext-utils";
+import * as os from 'os';
+import * as path from "path";
+import * as vscode from 'vscode';
+import { type Progress } from "vscode";
+import { ext } from "../../../extensionVariables";
+import { localize } from "../../../localize";
+import { feedUtils } from "../../../utils/feedUtils";
+import { type EventGridExecuteFunctionContext } from "./EventGridExecuteFunctionContext";
+
+export class EventGridFileOpenStep extends AzureWizardExecuteStep<EventGridExecuteFunctionContext> {
+    public priority: number;
+
+    public async execute(context: EventGridExecuteFunctionContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined; }>): Promise<void> {
+        const eventSource = nonNullProp(context, 'eventSource');
+        const selectedFileName = nonNullProp(context, 'selectedFileName');
+        const selectedFileUrl = nonNullProp(context, 'selectedFileUrl');
+
+        // Get selected contents of sample request
+        const downloadingMsg: string = localize('downloadingSample', 'Downloading sample request...');
+        progress.report({ message: downloadingMsg });
+        const selectedFileContent = await feedUtils.getJsonFeed(context, selectedFileUrl);
+
+        // Create a temp file with the sample request & open in new window
+        const openingFileMsg: string = localize('openingFile', 'Opening file...');
+        progress.report({ message: openingFileMsg });
+        const tempFilePath: string = await createTempSampleFile(eventSource, selectedFileName, selectedFileContent);
+        const document: vscode.TextDocument = await vscode.workspace.openTextDocument(tempFilePath);
+        await vscode.window.showTextDocument(document, {
+            preview: false,
+        });
+        ext.fileToFunctionNodeMap.set(document.fileName, nonNullProp(ext, 'currentExecutingFunctionNode'));
+        context.fileOpened = true;
+
+        // Request will be sent when the user clicks on the button or on the codelens link
+        // Show the message only once per workspace
+        if (!ext.context.workspaceState.get('didShowEventGridFileOpenMsg')) {
+            const doneMsg = localize('modifyFile', "You can modify the file and then click the 'Save and execute' button to send the request.");
+            void vscode.window.showInformationMessage(doneMsg);
+            await ext.context.workspaceState.update('didShowEventGridFileOpenMsg', true);
+        }
+
+
+        // Set a listener to delete the temp file after it's closed
+        void new Promise<void>((resolve, reject) => {
+            const disposable = vscode.workspace.onDidCloseTextDocument(async (closedDocument) => {
+                if (closedDocument.fileName === document.fileName) {
+                    try {
+                        ext.fileToFunctionNodeMap.delete(document.fileName);
+                        await AzExtFsExtra.deleteResource(tempFilePath);
+                        resolve();
+                    } catch (error) {
+                        reject(error);
+                    } finally {
+                        disposable.dispose();
+                    }
+                }
+            });
+        });
+    }
+
+    public shouldExecute(context: EventGridExecuteFunctionContext): boolean {
+        return !context.fileOpened
+    }
+
+}
+
+async function createTempSampleFile(eventSource: string, fileName: string, contents: {}): Promise<string> {
+    const samplesDirPath = await getSamplesDirPath(eventSource);
+    const sampleFileName = fileName.replace(/\.json$/, '.eventgrid.json');
+    const filePath: string = path.join(samplesDirPath, sampleFileName);
+
+    await AzExtFsExtra.writeJSON(filePath, contents);
+
+    return filePath;
+}
+
+async function getSamplesDirPath(eventSource: string): Promise<string> {
+    const baseDir: string = path.join(os.tmpdir(), 'vscode', 'azureFunctions', 'eventGridSamples');
+
+    // Create the path to the directory
+    const dirPath = path.join(baseDir, eventSource);
+
+    // Create the directory if it doesn't already exist
+    await AzExtFsExtra.ensureDir(dirPath);
+
+    // Return the path to the directory
+    return dirPath;
+}
+

src/commands/executeFunction/eventGrid/EventGridSourceStep.ts

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzureWizardPromptStep, type IAzureQuickPickItem } from "@microsoft/vscode-azext-utils";
+import { localize } from "../../../localize";
+import { type EventGridExecuteFunctionContext } from "./EventGridExecuteFunctionContext";
+import { supportedEventGridSourceLabels, supportedEventGridSources, type EventGridSource } from "./eventGridSources";
+
+export class EventGridSourceStep extends AzureWizardPromptStep<EventGridExecuteFunctionContext> {
+    public hideStepCount: boolean = false;
+
+    public async prompt(context: EventGridExecuteFunctionContext): Promise<void> {
+        // Prompt for event source
+        const eventGridSourcePicks: IAzureQuickPickItem<EventGridSource | undefined>[] = supportedEventGridSources.map((source: EventGridSource) => {
+            return {
+                label: supportedEventGridSourceLabels.get(source) || source,
+                data: source,
+            };
+        });
+        const eventSource: EventGridSource =
+            (
+                await context.ui.showQuickPick(eventGridSourcePicks, {
+                    placeHolder: localize('selectEventSource', 'Select the event source'),
+                    stepName: 'eventGridSource',
+                })
+            ).data ?? 'Microsoft.Storage';
+
+        context.eventSource = eventSource;
+    }
+
+    public shouldPrompt(context: EventGridExecuteFunctionContext): boolean {
+        return !context.eventSource;
+    }
+}

src/commands/executeFunction/eventGrid/EventGridTypeStep.ts

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzureWizardPromptStep, type IAzureQuickPickItem } from "@microsoft/vscode-azext-utils";
+import { localize } from "../../../localize";
+import { feedUtils } from "../../../utils/feedUtils";
+import { type EventGridExecuteFunctionContext } from "./EventGridExecuteFunctionContext";
+
+const sampleFilesUrl =
+    'https://api.github.com/repos/Azure/azure-rest-api-specs/contents/specification/eventgrid/data-plane/' +
+    '{eventSource}' +
+    '/stable/2018-01-01/examples/cloud-events-schema/';
+
+type FileMetadata = {
+    name: string;
+    path: string;
+    sha: string;
+    size: number;
+    url: string;
+    html_url: string;
+    git_url: string;
+    download_url: string;
+    type: string;
+    _links: {
+        self: string;
+        git: string;
+        html: string;
+    };
+};
+
+export class EventGridTypeStep extends AzureWizardPromptStep<EventGridExecuteFunctionContext> {
+    public hideStepCount: boolean = false;
+
+    public async prompt(context: EventGridExecuteFunctionContext): Promise<void> {
+        if (!context.eventSource) {
+            throw new Error('Event source is required');
+        }
+
+        // Get sample files for event source
+        const samplesUrl = sampleFilesUrl.replace('{eventSource}', context.eventSource);
+        const sampleFiles: FileMetadata[] = await feedUtils.getJsonFeed(context, samplesUrl);
+        const fileNames: string[] = sampleFiles.map((fileMetadata) => fileMetadata.name);
+
+        // Prompt for event type
+        const eventTypePicks: IAzureQuickPickItem<string | undefined>[] = fileNames.map((name: string) => ({
+            data: name,
+            // give human-readable name for event type from file name
+            label: name
+                .replace(/\.json$/, '')
+                .split('_')
+                .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+                .join(' '),
+        }));
+
+        context.selectedFileName =
+            (
+                await context.ui.showQuickPick(eventTypePicks, {
+                    placeHolder: localize('selectEventType', 'Select the event type'),
+                    stepName: 'eventType',
+                })
+            ).data ?? 'blob_created.json';
+
+        context.selectedFileUrl = sampleFiles.find((fileMetadata) => fileMetadata.name === context.selectedFileName)?.download_url || sampleFiles[0].download_url;
+
+    }
+
+    public shouldPrompt(context: EventGridExecuteFunctionContext): boolean {
+        return !context.selectedFileName;
+    }
+}

src/commands/executeFunction/eventGrid/eventGridSources.ts

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Sources here were obtained as the names of sources found on
+ * the EventGrid samples in the azure-rest-api-specs repository:
+ * https://github.com/Azure/azure-rest-api-specs/tree/master/specification/eventgrid/data-plane
+ */
+
+export type EventGridSource =
+    | 'Microsoft.ApiManagement'
+    | 'Microsoft.AppConfiguration'
+    | 'Microsoft.AVS'
+    | 'Microsoft.Cache'
+    | 'Microsoft.Communication'
+    | 'Microsoft.ContainerRegistry'
+    | 'Microsoft.ContainerService'
+    | 'Microsoft.DataBox'
+    | 'Microsoft.Devices'
+    | 'Microsoft.EventHub'
+    | 'Microsoft.HealthcareApis'
+    | 'Microsoft.KeyVault'
+    | 'Microsoft.MachineLearningServices'
+    | 'Microsoft.Maps'
+    | 'Microsoft.Media'
+    | 'Microsoft.PolicyInsights'
+    | 'Microsoft.ResourceNotification'
+    | 'Microsoft.Resources'
+    | 'Microsoft.ServiceBus'
+    | 'Microsoft.SignalRService'
+    | 'Microsoft.Storage'
+    | 'Microsoft.Web'
+    | string;
+
+export const supportedEventGridSources: EventGridSource[] = [
+    'Microsoft.ApiManagement',
+    'Microsoft.AppConfiguration',
+    'Microsoft.AVS',
+    'Microsoft.Cache',
+    'Microsoft.Communication',
+    'Microsoft.ContainerRegistry',
+    'Microsoft.ContainerService',
+    'Microsoft.DataBox',
+    'Microsoft.Devices',
+    'Microsoft.EventHub',
+    'Microsoft.HealthcareApis',
+    'Microsoft.KeyVault',
+    'Microsoft.MachineLearningServices',
+    'Microsoft.Maps',
+    'Microsoft.Media',
+    'Microsoft.PolicyInsights',
+    'Microsoft.ResourceNotification',
+    'Microsoft.Resources',
+    'Microsoft.ServiceBus',
+    'Microsoft.SignalRService',
+    'Microsoft.Storage',
+    'Microsoft.Web',
+];
+
+export const supportedEventGridSourceLabels: Map<EventGridSource, string> = new Map([
+    ['Microsoft.Storage', 'Blob Storage'],
+    ['Microsoft.EventHub', 'Event Hubs'],
+    ['Microsoft.ServiceBus', 'Service Bus'],
+    ['Microsoft.ContainerRegistry', 'Container Registry'],
+    ['Microsoft.ApiManagement', 'API Management'],
+    ['Microsoft.Resources', 'Resources'],
+    ['Microsoft.HealthcareApis', 'Health Data Services'],
+]);

src/commands/executeFunction/eventGrid/executeEventGridFunction.ts

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzureWizard, type AzureWizardExecuteStep, type AzureWizardPromptStep, type IActionContext } from '@microsoft/vscode-azext-utils';
+import { localize } from '../../../localize';
+import { type FunctionTreeItemBase } from '../../../tree/FunctionTreeItemBase';
+import { type IFunction } from '../../../workspace/LocalFunction';
+import { type EventGridExecuteFunctionContext } from './EventGridExecuteFunctionContext';
+import { EventGridFileOpenStep } from './EventGridFileOpenStep';
+import { EventGridSourceStep } from './EventGridSourceStep';
+import { EventGridTypeStep } from './EventGridTypeStep';
+
+export async function executeEventGridFunction(context: IActionContext, _node: FunctionTreeItemBase | IFunction): Promise<void> {
+    const title: string = localize('executeEGFunction', 'Execute Event Grid Function');
+
+    const promptSteps: AzureWizardPromptStep<EventGridExecuteFunctionContext>[] = [
+        new EventGridSourceStep(),
+        new EventGridTypeStep(),
+    ];
+
+    const executeSteps: AzureWizardExecuteStep<EventGridExecuteFunctionContext>[] = [
+        new EventGridFileOpenStep(),
+    ];
+
+    const wizardContext: EventGridExecuteFunctionContext = {
+        ...context,
+        eventSource: undefined,
+        selectedFileName: undefined,
+        selectedFileUrl: undefined,
+        fileOpened: false,
+    };
+
+    const wizard: AzureWizard<EventGridExecuteFunctionContext> = new AzureWizard(wizardContext, {
+        title,
+        promptSteps,
+        executeSteps,
+        showLoadingPrompt: true,
+    });
+
+    await wizard.prompt();
+    await wizard.execute();
+}