Task: create regeneration commands

vscode/microsoft-kiota/src/commands/editPathsCommand.ts

@@ -1,5 +1,5 @@
 import { extensionId, treeViewId } from "../constants";
-import { ClientOrPluginProperties } from "../kiotaInterop";
+import { getWorkspaceGenerationContext } from "../handlers/workspaceGenerationContextHandler";
 import { OpenApiTreeProvider } from "../openApiTreeProvider";
 import { updateTreeViewIcons } from "../util";
 import { openTreeViewWithProgress } from "../utilities/progress";
@@ -18,13 +18,14 @@ export class EditPathsCommand extends Command {
  return `${extensionId}.editPaths`;
  }
 
- public async execute({ clientKey, clientObject }: { clientKey: string, clientObject: ClientOrPluginProperties }): Promise<void> {
- await this.loadEditPaths(clientKey, clientObject);
+ public async execute(): Promise<void> {
+ await this.loadEditPaths();
  this._openApiTreeProvider.resetInitialState();
  await updateTreeViewIcons(treeViewId, false, true);
  }
 
- private async loadEditPaths(clientKey: string, clientObject: ClientOrPluginProperties) {
- await openTreeViewWithProgress(() => this._openApiTreeProvider.loadEditPaths(clientKey, clientObject));
+ private async loadEditPaths() {
+ const { clientOrPluginKey, clientOrPluginObject } = getWorkspaceGenerationContext();
+ await openTreeViewWithProgress(() => this._openApiTreeProvider.loadEditPaths(clientOrPluginKey, clientOrPluginObject));
  }
 }

vscode/microsoft-kiota/src/commands/generate/generateClientCommand.ts

@@ -12,7 +12,7 @@ import { generatePlugin } from "../../generatePlugin";
 import { getLanguageInformation, getLanguageInformationForDescription } from "../../getLanguageInformation";
 import { setGenerationConfiguration } from "../../handlers/configurationHandler";
 import { clearDeepLinkParams, getDeepLinkParams } from "../../handlers/deepLinkParamsHandler";
-import { setWorkspaceGenerationType } from "../../handlers/workspaceGenerationTypeHandler";
+import { setWorkspaceGenerationContext } from "../../handlers/workspaceGenerationContextHandler";
 import { ConsumerOperation, generationLanguageToString, getLogEntriesForLevel, KiotaLogEntry, LogLevel } from "../../kiotaInterop";
 import { OpenApiTreeProvider } from "../../openApiTreeProvider";
 import { GenerateState, generateSteps } from "../../steps";
@@ -95,7 +95,7 @@ export class GenerateClientCommand extends Command {
  }
 
  const settings = getExtensionSettings(extensionId);
- setWorkspaceGenerationType(config.generationType as string);
+ setWorkspaceGenerationContext({ generationType: config.generationType as string });
  let result;
  switch (generationType) {
  case GenerationType.Client:

vscode/microsoft-kiota/src/commands/regenerate/regenerate.service.ts

@@ -0,0 +1,117 @@
+import TelemetryReporter from "@vscode/extension-telemetry";
+import * as vscode from "vscode";
+import { ExtensionContext } from "vscode";
+
+import { extensionId } from "../../constants";
+import { KiotaGenerationLanguage, KiotaPluginType } from "../../enums";
+import { ExtensionSettings } from "../../extensionSettings";
+import { generateClient } from "../../generateClient";
+import { generatePlugin } from "../../generatePlugin";
+import { ClientObjectProperties, ClientOrPluginProperties, ConsumerOperation, getLogEntriesForLevel, LogLevel, PluginObjectProperties } from "../../kiotaInterop";
+import { OpenApiTreeProvider } from "../../openApiTreeProvider";
+import { parseGenerationLanguage, parsePluginType } from "../../util";
+import { exportLogsAndShowErrors } from "../../utilities/logging";
+import { checkForSuccess } from "../generate/generation-util";
+
+export class RegenerateService {
+ private _context: ExtensionContext;
+ private _openApiTreeProvider: OpenApiTreeProvider;
+ private _clientKey: string;
+ private _clientObject: ClientOrPluginProperties;
+
+ public constructor(context: ExtensionContext, openApiTreeProvider: OpenApiTreeProvider,
+ clientKey: string, clientObject: ClientOrPluginProperties) {
+ this._context = context;
+ this._openApiTreeProvider = openApiTreeProvider;
+ this._clientKey = clientKey;
+ this._clientObject = clientObject;
+ }
+
+ async regenerateClient(settings: ExtensionSettings, selectedPaths?: string[]): Promise<void> {
+ const clientObjectItem = this._clientObject as ClientObjectProperties;
+ const language =
+ typeof clientObjectItem.language === "string"
+ ? parseGenerationLanguage(clientObjectItem.language)
+ : KiotaGenerationLanguage.CSharp;
+ await vscode.window.withProgress({
+ location: vscode.ProgressLocation.Notification,
+ cancellable: false,
+ title: vscode.l10n.t("Re-generating client...")
+ }, async (progress, _) => {
+ const result = await generateClient(
+ this._context,
+ clientObjectItem.descriptionLocation ? clientObjectItem.descriptionLocation : this._openApiTreeProvider.descriptionUrl,
+ clientObjectItem.outputPath,
+ language,
+ selectedPaths ? selectedPaths : clientObjectItem.includePatterns,
+ clientObjectItem.excludePatterns ? clientObjectItem.excludePatterns : [],
+ this._clientKey,
+ clientObjectItem.clientNamespaceName,
+ clientObjectItem.usesBackingStore ? clientObjectItem.usesBackingStore : settings.backingStore,
+ true, // clearCache
+ true, // cleanOutput
+ clientObjectItem.excludeBackwardCompatible ? clientObjectItem.excludeBackwardCompatible : settings.excludeBackwardCompatible,
+ clientObjectItem.disabledValidationRules ? clientObjectItem.disabledValidationRules : settings.disableValidationRules,
+ settings.languagesSerializationConfiguration[language].serializers,
+ settings.languagesSerializationConfiguration[language].deserializers,
+ clientObjectItem.structuredMimeTypes ? clientObjectItem.structuredMimeTypes : settings.structuredMimeTypes,
+ clientObjectItem.includeAdditionalData ? clientObjectItem.includeAdditionalData : settings.includeAdditionalData,
+ ConsumerOperation.Edit
+ );
+ if (result) {
+ const isSuccess = await checkForSuccess(result);
+ if (!isSuccess) {
+ await exportLogsAndShowErrors(result);
+ }
+ void vscode.window.showInformationMessage(`Client ${this._clientKey} re-generated successfully.`);
+ }
+ return result;
+ });
+
+ this._openApiTreeProvider.resetInitialState();
+ }
+
+ async regeneratePlugin(settings: ExtensionSettings, selectedPaths?: string[]) {
+ const pluginObjectItem = this._clientObject as PluginObjectProperties;
+ const pluginTypes = Array.isArray(pluginObjectItem.types) ? parsePluginType(pluginObjectItem.types) : [KiotaPluginType.ApiPlugin];
+ await vscode.window.withProgress({
+ location: vscode.ProgressLocation.Notification,
+ cancellable: false,
+ title: vscode.l10n.t("Re-generating plugin...")
+ }, async (progress, _) => {
+ const start = performance.now();
+ const result = await generatePlugin(
+ this._context,
+ pluginObjectItem.descriptionLocation ? pluginObjectItem.descriptionLocation : this._openApiTreeProvider.descriptionUrl,
+ pluginObjectItem.outputPath,
+ pluginTypes,
+ selectedPaths ? selectedPaths : pluginObjectItem.includePatterns,
+ [],
+ this._clientKey,
+ settings.clearCache,
+ false,
+ settings.disableValidationRules,
+ ConsumerOperation.Edit
+ );
+ const duration = performance.now() - start;
+ const errorsCount = result ? getLogEntriesForLevel(result, LogLevel.critical, LogLevel.error).length : 0;
+
+ const reporter = new TelemetryReporter(this._context.extension.packageJSON.telemetryInstrumentationKey);
+ reporter.sendRawTelemetryEvent(`${extensionId}.re-generatePlugin.completed`, {
+ "pluginType": pluginTypes.toString(),
+ "errorsCount": errorsCount.toString(),
+ }, {
+ "duration": duration,
+ });
+ if (result) {
+ const isSuccess = await checkForSuccess(result);
+ if (!isSuccess) {
+ await exportLogsAndShowErrors(result);
+ }
+ void vscode.window.showInformationMessage(`Plugin ${this._clientKey} re-generated successfully.`);
+ }
+ return result;
+ });
+ this._openApiTreeProvider.resetInitialState();
+ }
+}

vscode/microsoft-kiota/src/commands/regenerate/regenerateButtonCommand.ts

@@ -0,0 +1,67 @@
+import * as vscode from "vscode";
+import { ExtensionContext } from "vscode";
+
+import { extensionId, treeViewId } from "../../constants";
+import { getExtensionSettings } from "../../extensionSettings";
+import { getGenerationConfiguration, setGenerationConfiguration } from "../../handlers/configurationHandler";
+import { getWorkspaceGenerationContext } from "../../handlers/workspaceGenerationContextHandler";
+import { OpenApiTreeProvider } from "../../openApiTreeProvider";
+import { isClientType, isPluginType } from "../../util";
+import { confirmOverride } from "../../utilities/regeneration";
+import { Command } from "../Command";
+import { RegenerateService } from "./regenerate.service";
+
+export class RegenerateButtonCommand extends Command {
+ private _context: ExtensionContext;
+ private _openApiTreeProvider: OpenApiTreeProvider;
+
+ constructor(context: ExtensionContext, openApiTreeProvider: OpenApiTreeProvider) {
+ super();
+ this._context = context;
+ this._openApiTreeProvider = openApiTreeProvider;
+ }
+
+ public getName(): string {
+ return `${treeViewId}.regenerateButton`;
+ }
+
+ public async execute(): Promise<void> {
+ const configuration = getGenerationConfiguration();
+ let { generationType, clientOrPluginKey, clientOrPluginObject } = getWorkspaceGenerationContext();
+ const regenerate = await confirmOverride();
+ if (!regenerate) {
+ return;
+ }
+
+ if (!clientOrPluginKey || clientOrPluginKey === '') {
+ clientOrPluginKey = configuration.clientClassName || configuration.pluginName || '';
+ }
+
+ if (!configuration) {
+ setGenerationConfiguration({
+ outputPath: clientOrPluginObject.outputPath,
+ clientClassName: clientOrPluginKey,
+ });
+ }
+
+ const settings = getExtensionSettings(extensionId);
+ const selectedPaths = this._openApiTreeProvider.getSelectedPaths();
+ if (selectedPaths.length === 0) {
+ await vscode.window.showErrorMessage(
+ vscode.l10n.t("No endpoints selected, select endpoints first")
+ );
+ return;
+ }
+
+ const configObject = clientOrPluginObject || configuration;
+ const regenerateService = new RegenerateService(this._context, this._openApiTreeProvider, clientOrPluginKey, configObject);
+
+ if (isClientType(generationType)) {
+ await regenerateService.regenerateClient(settings, selectedPaths);
+ }
+ if (isPluginType(generationType)) {
+ await regenerateService.regeneratePlugin(settings, selectedPaths);
+ }
+ }
+
+}

vscode/microsoft-kiota/src/commands/regenerate/regenerateCommand.ts

@@ -0,0 +1,53 @@
+import * as vscode from "vscode";
+import { ExtensionContext } from "vscode";
+
+import { extensionId, KIOTA_WORKSPACE_FILE } from "../../constants";
+import { getExtensionSettings } from "../../extensionSettings";
+import { getWorkspaceGenerationContext } from "../../handlers/workspaceGenerationContextHandler";
+import { OpenApiTreeProvider } from "../../openApiTreeProvider";
+import { isClientType, isPluginType } from "../../util";
+import { confirmOverride } from "../../utilities/regeneration";
+import { Command } from "../Command";
+import { RegenerateService } from "./regenerate.service";
+
+export class RegenerateCommand extends Command {
+ private _context: ExtensionContext;
+ private _openApiTreeProvider: OpenApiTreeProvider;
+
+ constructor(context: ExtensionContext, openApiTreeProvider: OpenApiTreeProvider) {
+ super();
+ this._context = context;
+ this._openApiTreeProvider = openApiTreeProvider;
+ }
+
+ public getName(): string {
+ return `${extensionId}.regenerate`;
+ }
+
+ public async execute(): Promise<void> {
+ const regenerate = await confirmOverride();
+ if (!regenerate) {
+ return;
+ }
+
+ const settings = getExtensionSettings(extensionId);
+ const workspaceJson = vscode.workspace.textDocuments.find(doc => doc.fileName.endsWith(KIOTA_WORKSPACE_FILE));
+ if (workspaceJson && workspaceJson.isDirty) {
+ await vscode.window.showInformationMessage(
+ vscode.l10n.t("Please save the workspace.json file before re-generation."),
+ vscode.l10n.t("OK")
+ );
+ return;
+ }
+
+ const { generationType, clientOrPluginKey, clientOrPluginObject } = getWorkspaceGenerationContext();
+ const regenerateService = new RegenerateService(this._context, this._openApiTreeProvider, clientOrPluginKey, clientOrPluginObject);
+ if (isClientType(generationType)) {
+ await regenerateService.regenerateClient(settings);
+ }
+ if (isPluginType(generationType)) {
+ await regenerateService.regeneratePlugin(settings);
+ }
+ }
+
+}