adds kiota client edit command

.vscode/launch.json

@@ -266,7 +266,7 @@
       "stopAtEntry": false
     },
     {
-      "name": "Launch Migrate",
+      "name": "Launch Client Migrate",
       "type": "coreclr",
       "request": "launch",
       "preLaunchTask": "build",
@@ -279,6 +279,41 @@
         "KIOTA_CONFIG_PREVIEW": "true"
       }
     },
+    {
+      "name": "Launch Client Generate",
+      "type": "coreclr",
+      "request": "launch",
+      "preLaunchTask": "build",
+      "program": "${workspaceFolder}/src/kiota/bin/Debug/net8.0/kiota.dll",
+      "args": ["client", "generate"],
+      "cwd": "${workspaceFolder}/samples/msgraph-mail/dotnet",
+      "console": "internalConsole",
+      "stopAtEntry": false,
+      "env": {
+        "KIOTA_CONFIG_PREVIEW": "true"
+      }
+    },
+    {
+      "name": "Launch Client Edit",
+      "type": "coreclr",
+      "request": "launch",
+      "preLaunchTask": "build",
+      "program": "${workspaceFolder}/src/kiota/bin/Debug/net8.0/kiota.dll",
+      "args": [
+        "client",
+        "edit",
+        "--client-name",
+        "GraphClient",
+        "--additional-data",
+        "true"
+      ],
+      "cwd": "${workspaceFolder}/samples/msgraph-mail/dotnet",
+      "console": "internalConsole",
+      "stopAtEntry": false,
+      "env": {
+        "KIOTA_CONFIG_PREVIEW": "true"
+      }
+    },
     {
       "name": "Launch Login (github - device)",
       "type": "coreclr",

CHANGELOG.md

@@ -9,6 +9,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+### Changed
+
+## [1.12.0] - 2024-03-06
+
+### Added
+
+- Added support for the new kiota config commands under a feature flag. [#3356](https://github.com/microsoft/kiota/issues/3356)
 - Added the init command as part of the experience revamp of [#3356](https://github.com/microsoft/kiota/issues/3356)
 - Added uri-form encoded serialization for Python. [#2075](https://github.com/microsoft/kiota/issues/2075)
 - Added support for multipart form data request body in Python. [#3030](https://github.com/microsoft/kiota/issues/3030)
@@ -1272,3 +1279,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 
 
+

src/Kiota.Builder/Kiota.Builder.csproj

@@ -44,9 +44,9 @@
     <PackageReference Include="Microsoft.Kiota.Serialization.Json" Version="1.1.8" />
     <PackageReference Include="Microsoft.Kiota.Serialization.Text" Version="1.1.4" />
     <PackageReference Include="Microsoft.kiota.Serialization.Multipart" Version="1.1.3" />
-    <PackageReference Include="Microsoft.OpenApi" Version="1.6.13" />
+    <PackageReference Include="Microsoft.OpenApi" Version="1.6.14" />
     <PackageReference Include="Microsoft.OpenApi.ApiManifest" Version="0.5.4-preview" />
-    <PackageReference Include="Microsoft.OpenApi.Readers" Version="1.6.13" />
+    <PackageReference Include="Microsoft.OpenApi.Readers" Version="1.6.14" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
     <PackageReference Include="YamlDotNet" Version="15.1.2" />
     <ProjectReference Include="..\Kiota.Generated\KiotaGenerated.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />

src/Kiota.Builder/WorkspaceManagement/ApiClientConfiguration.cs

@@ -3,7 +3,6 @@
 using System.IO;
 using System.Linq;
 using Kiota.Builder.Configuration;
-using Kiota.Builder.Lock;
 using Microsoft.OpenApi.ApiManifest;
 
 namespace Kiota.Builder.WorkspaceManagement;

src/Kiota.Builder/WorkspaceManagement/DescriptionStorageService.cs

@@ -59,4 +59,10 @@ public void RemoveDescription(string clientName, string extension = "yml")
         if (File.Exists(descriptionFilePath))
             File.Delete(descriptionFilePath);
     }
+    public void Clean()
+    {
+        var kiotaDirectoryPath = Path.Combine(TargetDirectory, DescriptionsSubDirectoryRelativePath);
+        if (Path.Exists(kiotaDirectoryPath))
+            Directory.Delete(kiotaDirectoryPath, true);
+    }
 }

src/Kiota.Builder/WorkspaceManagement/WorkspaceManagementService.cs

@@ -143,6 +143,8 @@ public async Task RemoveClientAsync(string clientName, bool cleanOutput = false,
         manifest?.ApiDependencies.Remove(clientName);
         await workspaceConfigurationStorageService.UpdateWorkspaceConfigurationAsync(wsConfig, manifest, cancellationToken).ConfigureAwait(false);
         descriptionStorageService.RemoveDescription(clientName);
+        if (wsConfig.Clients.Count == 0)
+            descriptionStorageService.Clean();
     }
     private static readonly JsonSerializerOptions options = new()
     {
@@ -226,22 +228,19 @@ public async Task<IEnumerable<string>> MigrateFromLockFileAsync(string clientNam
             }
             var (stream, _) = await openApiDocumentDownloadService.LoadStreamAsync(generationConfiguration.OpenAPIFilePath, generationConfiguration, null, false, cancellationToken).ConfigureAwait(false);
 #pragma warning disable CA2007 // Consider calling ConfigureAwait on the awaited task
-            await using var msForOpenAPIDocument = new MemoryStream(); // openapi.net doesn't honour leave open
             await using var ms = new MemoryStream();
 #pragma warning restore CA2007 // Consider calling ConfigureAwait on the awaited task
-            await stream.CopyToAsync(msForOpenAPIDocument, cancellationToken).ConfigureAwait(false);
-            msForOpenAPIDocument.Seek(0, SeekOrigin.Begin);
-            await msForOpenAPIDocument.CopyToAsync(ms, cancellationToken).ConfigureAwait(false);
+            await stream.CopyToAsync(ms, cancellationToken).ConfigureAwait(false);
             ms.Seek(0, SeekOrigin.Begin);
-            msForOpenAPIDocument.Seek(0, SeekOrigin.Begin);
-            var document = await openApiDocumentDownloadService.GetDocumentFromStreamAsync(msForOpenAPIDocument, generationConfiguration, false, cancellationToken).ConfigureAwait(false);
+            var document = await openApiDocumentDownloadService.GetDocumentFromStreamAsync(ms, generationConfiguration, false, cancellationToken).ConfigureAwait(false);
             if (document is null)
             {
                 Logger.LogError("The client {ClientName} could not be migrated because the OpenAPI document could not be loaded", generationConfiguration.ClientClassName);
                 clientsGenerationConfigurations.Remove(generationConfiguration);
                 continue;
             }
             generationConfiguration.ApiRootUrl = document.GetAPIRootUrl(generationConfiguration.OpenAPIFilePath);
+            ms.Seek(0, SeekOrigin.Begin);
             await descriptionStorageService.UpdateDescriptionAsync(generationConfiguration.ClientClassName, ms, new Uri(generationConfiguration.OpenAPIFilePath).GetFileExtension(), cancellationToken).ConfigureAwait(false);
 
             var clientConfiguration = new ApiClientConfiguration(generationConfiguration);

src/kiota/Handlers/BaseKiotaCommandHandler.cs

@@ -20,6 +20,12 @@ namespace kiota.Handlers;
 
 internal abstract class BaseKiotaCommandHandler : ICommandHandler, IDisposable
 {
+    protected static void DefaultSerializersAndDeserializers(GenerationConfiguration generationConfiguration)
+    { // needed until we have rollup packages
+        var defaultGenerationConfiguration = new GenerationConfiguration();
+        generationConfiguration.Serializers = defaultGenerationConfiguration.Serializers;
+        generationConfiguration.Deserializers = defaultGenerationConfiguration.Deserializers;
+    }
     protected TempFolderCachingAccessTokenProvider GetGitHubDeviceStorageService(ILogger logger) => new()
     {
         Logger = logger,

src/kiota/Handlers/Client/AddHandler.cs

@@ -81,10 +81,10 @@ public override async Task<int> InvokeAsync(InvocationContext context)
         bool skipGeneration = context.ParseResult.GetValueForOption(SkipGenerationOption);
         string className = context.ParseResult.GetValueForOption(ClassOption) ?? string.Empty;
         string namespaceName = context.ParseResult.GetValueForOption(NamespaceOption) ?? string.Empty;
-        List<string> includePatterns = context.ParseResult.GetValueForOption(IncludePatternsOption) ?? new List<string>();
-        List<string> excludePatterns = context.ParseResult.GetValueForOption(ExcludePatternsOption) ?? new List<string>();
-        List<string> disabledValidationRules = context.ParseResult.GetValueForOption(DisabledValidationRulesOption) ?? new List<string>();
-        List<string> structuredMimeTypes = context.ParseResult.GetValueForOption(StructuredMimeTypesOption) ?? new List<string>();
+        List<string> includePatterns = context.ParseResult.GetValueForOption(IncludePatternsOption) ?? [];
+        List<string> excludePatterns = context.ParseResult.GetValueForOption(ExcludePatternsOption) ?? [];
+        List<string> disabledValidationRules = context.ParseResult.GetValueForOption(DisabledValidationRulesOption) ?? [];
+        List<string> structuredMimeTypes = context.ParseResult.GetValueForOption(StructuredMimeTypesOption) ?? [];
         CancellationToken cancellationToken = context.BindingContext.GetService(typeof(CancellationToken)) is CancellationToken token ? token : CancellationToken.None;
         AssignIfNotNullOrEmpty(output, (c, s) => c.OutputPath = s);
         AssignIfNotNullOrEmpty(openapi, (c, s) => c.OpenAPIFilePath = s);

src/kiota/Handlers/Client/EditHandler.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Kiota.Builder;
+using Kiota.Builder.Configuration;
+using Kiota.Builder.Extensions;
+using Kiota.Builder.WorkspaceManagement;
+using Microsoft.Extensions.Logging;
+
+namespace kiota.Handlers.Client;
+
+internal class EditHandler : BaseKiotaCommandHandler
+{
+    public required Option<string> ClassOption
+    {
+        get; init;
+    }
+    public required Option<bool?> BackingStoreOption
+    {
+        get; init;
+    }
+    public required Option<string> OutputOption
+    {
+        get; init;
+    }
+    public required Option<GenerationLanguage?> LanguageOption
+    {
+        get; init;
+    }
+    public required Option<string> DescriptionOption
+    {
+        get; init;
+    }
+    public required Option<string> NamespaceOption
+    {
+        get; init;
+    }
+    public required Option<bool?> AdditionalDataOption
+    {
+        get; init;
+    }
+    public required Option<List<string>> DisabledValidationRulesOption
+    {
+        get; init;
+    }
+    public required Option<List<string>> StructuredMimeTypesOption
+    {
+        get; init;
+    }
+    public required Option<bool?> ExcludeBackwardCompatibleOption
+    {
+        get;
+        set;
+    }
+    public required Option<List<string>> IncludePatternsOption
+    {
+        get; init;
+    }
+    public required Option<List<string>> ExcludePatternsOption
+    {
+        get; init;
+    }
+    public required Option<bool> SkipGenerationOption
+    {
+        get; init;
+    }
+
+    public override async Task<int> InvokeAsync(InvocationContext context)
+    {
+        string output = context.ParseResult.GetValueForOption(OutputOption) ?? string.Empty;
+        GenerationLanguage? language = context.ParseResult.GetValueForOption(LanguageOption);
+        string openapi = context.ParseResult.GetValueForOption(DescriptionOption) ?? string.Empty;
+        bool? backingStore = context.ParseResult.GetValueForOption(BackingStoreOption);
+        bool? excludeBackwardCompatible = context.ParseResult.GetValueForOption(ExcludeBackwardCompatibleOption);
+        bool? includeAdditionalData = context.ParseResult.GetValueForOption(AdditionalDataOption);
+        bool skipGeneration = context.ParseResult.GetValueForOption(SkipGenerationOption);
+        string className = context.ParseResult.GetValueForOption(ClassOption) ?? string.Empty;
+        string namespaceName = context.ParseResult.GetValueForOption(NamespaceOption) ?? string.Empty;
+        List<string>? includePatterns = context.ParseResult.GetValueForOption(IncludePatternsOption);
+        List<string>? excludePatterns = context.ParseResult.GetValueForOption(ExcludePatternsOption);
+        List<string>? disabledValidationRules = context.ParseResult.GetValueForOption(DisabledValidationRulesOption);
+        List<string>? structuredMimeTypes = context.ParseResult.GetValueForOption(StructuredMimeTypesOption);
+        CancellationToken cancellationToken = context.BindingContext.GetService(typeof(CancellationToken)) is CancellationToken token ? token : CancellationToken.None;
+
+        Configuration.Generation.SkipGeneration = skipGeneration;
+        Configuration.Generation.Operation = ClientOperation.Edit;
+
+        var (loggerFactory, logger) = GetLoggerAndFactory<KiotaBuilder>(context, Configuration.Generation.OutputPath);
+        using (loggerFactory)
+        {
+            await CheckForNewVersionAsync(logger, cancellationToken).ConfigureAwait(false);
+            logger.AppendInternalTracing();
+            logger.LogTrace("configuration: {configuration}", JsonSerializer.Serialize(Configuration, KiotaConfigurationJsonContext.Default.KiotaConfiguration));
+
+            try
+            {
+                var workspaceStorageService = new WorkspaceConfigurationStorageService(Directory.GetCurrentDirectory());
+                var (config, _) = await workspaceStorageService.GetWorkspaceConfigurationAsync(cancellationToken).ConfigureAwait(false);
+                if (config == null)
+                {
+                    DisplayError("The workspace configuration is missing, please run the init command first.");
+                    return 1;
+                }
+                if (!config.Clients.TryGetValue(className, out var clientConfiguration))
+                {
+                    DisplayError($"No client found with the provided name {className}");
+                    return 1;
+                }
+                clientConfiguration.UpdateGenerationConfigurationFromApiClientConfiguration(Configuration.Generation, className);
+                if (language.HasValue)
+                    Configuration.Generation.Language = language.Value;
+                if (backingStore.HasValue)
+                    Configuration.Generation.UsesBackingStore = backingStore.Value;
+                if (excludeBackwardCompatible.HasValue)
+                    Configuration.Generation.ExcludeBackwardCompatible = excludeBackwardCompatible.Value;
+                if (includeAdditionalData.HasValue)
+                    Configuration.Generation.IncludeAdditionalData = includeAdditionalData.Value;
+                AssignIfNotNullOrEmpty(output, (c, s) => c.OutputPath = s);
+                AssignIfNotNullOrEmpty(openapi, (c, s) => c.OpenAPIFilePath = s);
+                AssignIfNotNullOrEmpty(className, (c, s) => c.ClientClassName = s);
+                AssignIfNotNullOrEmpty(namespaceName, (c, s) => c.ClientNamespaceName = s);
+                if (includePatterns is { Count: > 0 })
+                    Configuration.Generation.IncludePatterns = includePatterns.Select(static x => x.TrimQuotes()).ToHashSet(StringComparer.OrdinalIgnoreCase);
+                if (excludePatterns is { Count: > 0 })
+                    Configuration.Generation.ExcludePatterns = excludePatterns.Select(static x => x.TrimQuotes()).ToHashSet(StringComparer.OrdinalIgnoreCase);
+                if (disabledValidationRules is { Count: > 0 })
+                    Configuration.Generation.DisabledValidationRules = disabledValidationRules
+                                                                            .Select(static x => x.TrimQuotes())
+                                                                            .SelectMany(static x => x.Split(',', StringSplitOptions.RemoveEmptyEntries))
+                                                                            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+                if (structuredMimeTypes is { Count: > 0 })
+                    Configuration.Generation.StructuredMimeTypes = new(structuredMimeTypes.SelectMany(static x => x.Split(' ', StringSplitOptions.RemoveEmptyEntries))
+                                                                    .Select(static x => x.TrimQuotes()));
+
+                DefaultSerializersAndDeserializers(Configuration.Generation);
+                var builder = new KiotaBuilder(logger, Configuration.Generation, httpClient, true);
+                var result = await builder.GenerateClientAsync(cancellationToken).ConfigureAwait(false);
+                if (result)
+                    DisplaySuccess("Generation completed successfully");
+                else if (skipGeneration)
+                {
+                    DisplaySuccess("Generation skipped as --skip-generation was passed");
+                    DisplayGenerateCommandHint();
+                }
+                else
+                {
+                    DisplayWarning("Generation skipped as no changes were detected");
+                    DisplayCleanHint("client generate", "--refresh");
+                }
+                var manifestPath = $"{GetAbsolutePath(WorkspaceConfigurationStorageService.ManifestFileName)}#{Configuration.Generation.ClientClassName}";
+                DisplayInfoHint(Configuration.Generation.Language, string.Empty, manifestPath);
+                DisplayGenerateAdvancedHint(includePatterns ?? [], excludePatterns ?? [], string.Empty, manifestPath, "client edit");
+                return 0;
+            }
+            catch (Exception ex)
+            {
+#if DEBUG
+                logger.LogCritical(ex, "error adding the client: {exceptionMessage}", ex.Message);
+                throw; // so debug tools go straight to the source of the exception when attached
+#else
+                logger.LogCritical("error adding the client: {exceptionMessage}", ex.Message);
+                return 1;
+#endif
+            }
+        }
+    }
+}

src/kiota/Handlers/Client/GenerateHandler.cs

@@ -58,8 +58,10 @@ public override async Task<int> InvokeAsync(InvocationContext context)
                     var generationConfiguration = new GenerationConfiguration();
                     var requests = !refresh && manifest is not null && manifest.ApiDependencies.TryGetValue(clientEntry.Key, out var value) ? value.Requests : [];
                     clientEntry.Value.UpdateGenerationConfigurationFromApiClientConfiguration(generationConfiguration, clientEntry.Key, requests);
+                    DefaultSerializersAndDeserializers(generationConfiguration);
                     generationConfiguration.ClearCache = refresh;
                     generationConfiguration.CleanOutput = refresh;
+                    generationConfiguration.Operation = ClientOperation.Generate;
                     var builder = new KiotaBuilder(logger, generationConfiguration, httpClient, true);
                     var result = await builder.GenerateClientAsync(cancellationToken).ConfigureAwait(false);
                     if (result)

src/kiota/Handlers/Client/RemoveHandler.cs

@@ -31,6 +31,7 @@ public override async Task<int> InvokeAsync(InvocationContext context)
                 await CheckForNewVersionAsync(logger, cancellationToken).ConfigureAwait(false);
                 var workspaceManagementService = new WorkspaceManagementService(logger, httpClient, true);
                 await workspaceManagementService.RemoveClientAsync(className, cleanOutput, cancellationToken).ConfigureAwait(false);
+                DisplaySuccess($"Client {className} removed successfully!");
                 return 0;
             }
             catch (Exception ex)