feature/generate client

src/Kiota.Builder/Configuration/GenerationConfiguration.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Linq;
 using System.Text.Json.Nodes;
+using Kiota.Builder.Extensions;
 using Kiota.Builder.Lock;
 using Microsoft.OpenApi.ApiManifest;
 
@@ -113,6 +114,10 @@ public StructuredMimeTypesCollection StructuredMimeTypes
     };
     public HashSet<string> IncludePatterns { get; set; } = new(0, StringComparer.OrdinalIgnoreCase);
     public HashSet<string> ExcludePatterns { get; set; } = new(0, StringComparer.OrdinalIgnoreCase);
+    /// <summary>
+    /// The overrides loaded from the api manifest when refreshing a client, as opposed to the user provided ones.
+    /// </summary>
+    public HashSet<string> PatternsOverride { get; set; } = new(0, StringComparer.OrdinalIgnoreCase);
     public bool ClearCache
     {
         get; set;
@@ -144,6 +149,7 @@ public object Clone()
             MaxDegreeOfParallelism = MaxDegreeOfParallelism,
             SkipGeneration = SkipGeneration,
             Operation = Operation,
+            PatternsOverride = new(PatternsOverride ?? Enumerable.Empty<string>(), StringComparer.OrdinalIgnoreCase),
         };
     }
     private static readonly StringIEnumerableDeepComparer comparer = new();
@@ -175,7 +181,7 @@ public ApiDependency ToApiDependency(string configurationHash, Dictionary<string
             Extensions = new() {
                 { KiotaHashManifestExtensionKey, JsonValue.Create(configurationHash)}
             },
-            Requests = templatesWithOperations.SelectMany(static x => x.Value.Select(y => new RequestInfo { Method = y.ToUpperInvariant(), UriTemplate = x.Key })).ToList(),
+            Requests = templatesWithOperations.SelectMany(static x => x.Value.Select(y => new RequestInfo { Method = y.ToUpperInvariant(), UriTemplate = x.Key.DeSanitizeUrlTemplateParameter() })).ToList(),
         };
         return dependency;
     }

src/Kiota.Builder/Extensions/OpenApiUrlTreeNodeExtensions.cs

@@ -266,6 +266,13 @@ public static string SanitizeParameterNameForUrlTemplate(this string original)
                     .Replace(".", "%2E", StringComparison.OrdinalIgnoreCase)
                     .Replace("~", "%7E", StringComparison.OrdinalIgnoreCase);// - . ~ are invalid uri template character but don't get encoded by Uri.EscapeDataString
     }
+    public static string DeSanitizeUrlTemplateParameter(this string original)
+    {
+        if (string.IsNullOrEmpty(original)) return original;
+        return Uri.UnescapeDataString(original.Replace("%2D", "-", StringComparison.OrdinalIgnoreCase)
+                    .Replace("%2E", ".", StringComparison.OrdinalIgnoreCase)
+                    .Replace("%7E", "~", StringComparison.OrdinalIgnoreCase));
+    }
     [GeneratedRegex(@"%[0-9A-F]{2}", RegexOptions.Singleline, 500)]
     private static partial Regex removePctEncodedCharacters();
     public static string SanitizeParameterNameForCodeSymbols(this string original, string replaceEncodedCharactersWith = "")

src/Kiota.Builder/KiotaBuilder.cs

@@ -321,6 +321,11 @@
     {
         var includePatterns = GetFilterPatternsFromConfiguration(config.IncludePatterns);
         var excludePatterns = GetFilterPatternsFromConfiguration(config.ExcludePatterns);
+        if (config.PatternsOverride.Count != 0)
+        { // loading the patterns from the manifest as we don't want to take the user input one and have new operation creep in from the description being updated since last generation
+            includePatterns = GetFilterPatternsFromConfiguration(config.PatternsOverride);
+            excludePatterns = [];
+        }
         if (includePatterns.Count == 0 && excludePatterns.Count == 0) return;
 
         var nonOperationIncludePatterns = includePatterns.Where(static x => x.Value.Count == 0).Select(static x => x.Key).ToList();
@@ -970,7 +975,7 @@
 
         if (!"string".Equals(parameter.Type.Name, StringComparison.OrdinalIgnoreCase) && config.IncludeBackwardCompatible)
         { // adding a second indexer for the string version of the parameter so we keep backward compatibility
             //TODO remove for v2
             var backCompatibleValue = (CodeIndexer)result[0].Clone();
             backCompatibleValue.Name += "-string";
             backCompatibleValue.IndexParameter.Type = DefaultIndexerParameterType;
@@ -1124,7 +1129,7 @@
             var suffix = $"{operationType}Response";
             var modelType = CreateModelDeclarations(currentNode, schema, operation, parentClass, suffix);
             if (modelType is not null && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp or GenerationLanguage.Go && modelType.Name.EndsWith(suffix, StringComparison.Ordinal))
             { //TODO remove for v2
                 var obsoleteTypeName = modelType.Name[..^suffix.Length] + "Response";
                 if (modelType is CodeType codeType &&
                     codeType.TypeDefinition is CodeClass codeClass)
@@ -1257,7 +1262,7 @@
             executorMethod.AddParameter(cancellationParam);// Add cancellation token parameter
 
             if (returnTypes.Item2 is not null && config.IncludeBackwardCompatible)
             { //TODO remove for v2
                 var additionalExecutorMethod = (CodeMethod)executorMethod.Clone();
                 additionalExecutorMethod.ReturnType = returnTypes.Item2;
                 additionalExecutorMethod.OriginalMethod = executorMethod;
@@ -2264,7 +2269,7 @@
         if (!parameterClass.ContainsPropertyWithWireName(prop.WireName))
         {
             if (addBackwardCompatibleParameter && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp or GenerationLanguage.Go)
             { //TODO remove for v2
                 var modernProp = (CodeProperty)prop.Clone();
                 modernProp.Name = $"{prop.Name}As{modernProp.Type.Name.ToFirstCharacterUpperCase()}";
                 modernProp.SerializationName = prop.WireName;

src/Kiota.Builder/OpenApiDocumentDownloadService.cs

@@ -48,7 +48,7 @@ public OpenApiDocumentDownloadService(HttpClient httpClient, ILogger logger)
         if (useKiotaConfig &&
             config.Operation is ClientOperation.Edit or ClientOperation.Add &&
             workspaceManagementService is not null &&
-            await workspaceManagementService.GetDescriptionCopyAsync(config.ClientClassName, inputPath, cancellationToken).ConfigureAwait(false) is { } descriptionStream)
+            await workspaceManagementService.GetDescriptionCopyAsync(config.ClientClassName, inputPath, config.CleanOutput, cancellationToken).ConfigureAwait(false) is { } descriptionStream)
         {
             Logger.LogInformation("loaded description from the workspace copy");
             input = descriptionStream;

src/Kiota.Builder/WorkspaceManagement/ApiClientConfiguration.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using Kiota.Builder.Configuration;
 using Kiota.Builder.Lock;
+using Microsoft.OpenApi.ApiManifest;
 
 namespace Kiota.Builder.WorkspaceManagement;
 
@@ -92,34 +93,13 @@ public ApiClientConfiguration(GenerationConfiguration config)
         OutputPath = config.OutputPath;
     }
     /// <summary>
-    /// Initializes a new instance of the <see cref="ApiClientConfiguration"/> class from an existing <see cref="KiotaLock"/> to enable migrations.
-    /// </summary>
-    /// <param name="kiotaLock">The kiota lock to migrate.</param>
-    /// <param name="relativeOutputPath">The relative output path to output folder from the configuration file.</param>
-    public ApiClientConfiguration(KiotaLock kiotaLock, string relativeOutputPath)
-    {
-        ArgumentNullException.ThrowIfNull(kiotaLock);
-        ArgumentNullException.ThrowIfNull(relativeOutputPath);
-        Language = kiotaLock.Language;
-        ClientNamespaceName = kiotaLock.ClientNamespaceName;
-        UsesBackingStore = kiotaLock.UsesBackingStore;
-        ExcludeBackwardCompatible = kiotaLock.ExcludeBackwardCompatible;
-        IncludeAdditionalData = kiotaLock.IncludeAdditionalData;
-        StructuredMimeTypes = kiotaLock.StructuredMimeTypes.ToList();
-        IncludePatterns = kiotaLock.IncludePatterns;
-        ExcludePatterns = kiotaLock.ExcludePatterns;
-        DescriptionLocation = kiotaLock.DescriptionLocation;
-        DisabledValidationRules = kiotaLock.DisabledValidationRules;
-        OutputPath = relativeOutputPath;
-    }
-    /// <summary>
     /// Updates the passed configuration with the values from the config file.
     /// </summary>
     /// <param name="config">Generation configuration to update.</param>
     /// <param name="clientName">Client name serving as class name.</param>
-    public void UpdateGenerationConfigurationFromApiClientConfiguration(GenerationConfiguration config, string clientName)
+    /// <param name="requests">The requests to use when updating an existing client.</param>
+    public void UpdateGenerationConfigurationFromApiClientConfiguration(GenerationConfiguration config, string clientName, IList<RequestInfo>? requests = default)
     {
-        //TODO lock the api manifest as well to have accurate path resolution
         ArgumentNullException.ThrowIfNull(config);
         ArgumentException.ThrowIfNullOrEmpty(clientName);
         config.ClientNamespaceName = ClientNamespaceName;
@@ -137,6 +117,12 @@ public void UpdateGenerationConfigurationFromApiClientConfiguration(GenerationCo
         config.ClientClassName = clientName;
         config.Serializers.Clear();
         config.Deserializers.Clear();
+        if (requests is { Count: > 0 })
+        {
+            config.PatternsOverride = requests.Where(static x => !x.Exclude && !string.IsNullOrEmpty(x.Method) && !string.IsNullOrEmpty(x.UriTemplate))
+                                            .Select(static x => $"/{x.UriTemplate}#{x.Method!.ToUpperInvariant()}")
+                                            .ToHashSet();
+        }
     }
 
     public object Clone()

src/Kiota.Builder/WorkspaceManagement/WorkspaceManagementService.cs

@@ -121,9 +121,9 @@ public async Task<bool> ShouldGenerateAsync(GenerationConfiguration inputConfig,
         }
 
     }
-    public async Task<Stream?> GetDescriptionCopyAsync(string clientName, string inputPath, CancellationToken cancellationToken = default)
+    public async Task<Stream?> GetDescriptionCopyAsync(string clientName, string inputPath, bool cleanOutput, CancellationToken cancellationToken = default)
     {
-        if (!UseKiotaConfig)
+        if (!UseKiotaConfig || cleanOutput)
             return null;
         return await descriptionStorageService.GetDescriptionAsync(clientName, new Uri(inputPath).GetFileExtension(), cancellationToken).ConfigureAwait(false);
     }

src/kiota/Handlers/BaseKiotaCommandHandler.cs

@@ -304,10 +304,10 @@ protected void DisplayInstallHint(LanguageInformation languageInformation, List<
                     languageDependencies.Select(x => "   " + string.Format(languageInformation.DependencyInstallCommand, x.Name, x.Version))).ToArray());
         }
     }
-    protected void DisplayCleanHint(string commandName)
+    protected void DisplayCleanHint(string commandName, string argumentName = "--clean-output")
     {
-        DisplayHint("Hint: to force the generation to overwrite an existing client pass the --clean-output switch.",
-                    $"Example: kiota {commandName} --clean-output");
+        DisplayHint($"Hint: to force the generation to overwrite an existing client pass the {argumentName} switch.",
+                    $"Example: kiota {commandName} {argumentName}");
     }
     protected void DisplayInfoAdvancedHint()
     {

src/kiota/Handlers/Client/GenerateHandler.cs

@@ -0,0 +1,92 @@
+using System;
+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.WorkspaceManagement;
+using Microsoft.Extensions.Logging;
+
+namespace kiota.Handlers.Client;
+
+internal class GenerateHandler : BaseKiotaCommandHandler
+{
+    public required Option<string> ClassOption
+    {
+        get; init;
+    }
+    public required Option<bool> RefreshOption
+    {
+        get; init;
+    }
+    public override async Task<int> InvokeAsync(InvocationContext context)
+    {
+        string className = context.ParseResult.GetValueForOption(ClassOption) ?? string.Empty;
+        bool refresh = context.ParseResult.GetValueForOption(RefreshOption);
+        CancellationToken cancellationToken = context.BindingContext.GetService(typeof(CancellationToken)) is CancellationToken token ? token : CancellationToken.None;
+        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, manifest) = await workspaceStorageService.GetWorkspaceConfigurationAsync(cancellationToken).ConfigureAwait(false);
+                if (config == null)
+                {
+                    DisplayError("The workspace configuration is missing, please run the init command first.");
+                    return 1;
+                }
+                var clientNameWasNotProvided = string.IsNullOrEmpty(className);
+                var clientEntries = config
+                                            .Clients
+                                            .Where(x => clientNameWasNotProvided || x.Key.Equals(className, StringComparison.OrdinalIgnoreCase))
+                                            .ToArray();
+                if (clientEntries.Length == 0 && !clientNameWasNotProvided)
+                {
+                    DisplayError($"No client found with the provided name {className}");
+                    return 1;
+                }
+                foreach (var clientEntry in clientEntries)
+                {
+                    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);
+                    generationConfiguration.ClearCache = refresh;
+                    generationConfiguration.CleanOutput = refresh;
+                    var builder = new KiotaBuilder(logger, generationConfiguration, httpClient, true);
+                    var result = await builder.GenerateClientAsync(cancellationToken).ConfigureAwait(false);
+                    if (result)
+                    {
+                        DisplaySuccess($"Update of {clientEntry.Key} client completed");
+                        var manifestPath = $"{GetAbsolutePath(WorkspaceConfigurationStorageService.ManifestFileName)}#{clientEntry.Key}";
+                        DisplayInfoHint(generationConfiguration.Language, string.Empty, manifestPath);
+                    }
+                    else
+                    {
+                        DisplayWarning($"Update of {clientEntry.Key} skipped, no changes detected");
+                        DisplayCleanHint("client generate", "--refresh");
+                    }
+                }
+                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
+            }
+        }
+        throw new System.NotImplementedException();
+    }
+}

src/kiota/Handlers/KiotaUpdateCommandHandler.cs

@@ -70,7 +70,7 @@ public override async Task<int> InvokeAsync(InvocationContext context)
                 DisplaySuccess($"Update of {locks.Length} clients completed successfully");
                 foreach (var configuration in configurations)
                     DisplayInfoHint(configuration.Language, configuration.OpenAPIFilePath, string.Empty);
-                if (results.Any(x => x))
+                if (Array.Exists(results, static x => x))
                     DisplayCleanHint("update");
                 return 0;
             }

src/kiota/KiotaClientCommands.cs

@@ -110,8 +110,27 @@ public static Command GetEditCommand()
     }
     public static Command GetGenerateCommand()
     {
-        var command = new Command("generate", "Generates one or all clients from the Kiota configuration");
-        //TODO map the handler
+        var clientNameOption = GetClientNameOption(false);
+        var logLevelOption = KiotaHost.GetLogLevelOption();
+        var refreshOption = GetRefreshOption();
+        var command = new Command("generate", "Generates one or all clients from the Kiota configuration")
+        {
+            clientNameOption,
+            logLevelOption,
+            refreshOption,
+        };
+        command.Handler = new GenerateHandler
+        {
+            ClassOption = clientNameOption,
+            LogLevelOption = logLevelOption,
+            RefreshOption = refreshOption,
+        };
         return command;
     }
+    private static Option<bool> GetRefreshOption()
+    {
+        var refresh = new Option<bool>("--refresh", "Refreshes the client OpenAPI description before generating the client");
+        refresh.AddAlias("--r");
+        return refresh;
+    }
 }

tests/Kiota.Builder.Tests/WorkspaceManagement/ApiClientConfigurationTests.cs

@@ -1,6 +1,7 @@
 using System;
 using Kiota.Builder.Configuration;
 using Kiota.Builder.WorkspaceManagement;
+using Microsoft.OpenApi.ApiManifest;
 using Xunit;
 
 namespace Kiota.Builder.Tests.WorkspaceManagement;
@@ -91,7 +92,18 @@ public void UpdatesGenerationConfigurationFromApiClientConfiguration()
             UsesBackingStore = true,
         };
         var generationConfiguration = new GenerationConfiguration();
-        clientConfiguration.UpdateGenerationConfigurationFromApiClientConfiguration(generationConfiguration, "client");
+        clientConfiguration.UpdateGenerationConfigurationFromApiClientConfiguration(generationConfiguration, "client", [
+            new RequestInfo
+            {
+                Method = "GET",
+                UriTemplate = "path/bar",
+            },
+            new RequestInfo
+            {
+                Method = "PATH",
+                UriTemplate = "path/baz",
+            },
+        ]);
         Assert.Equal(clientConfiguration.ClientNamespaceName, generationConfiguration.ClientNamespaceName);
         Assert.Equal(GenerationLanguage.CSharp, generationConfiguration.Language);
         Assert.Equal(clientConfiguration.DescriptionLocation, generationConfiguration.OpenAPIFilePath);
@@ -104,6 +116,7 @@ public void UpdatesGenerationConfigurationFromApiClientConfiguration()
         Assert.Equal(clientConfiguration.UsesBackingStore, generationConfiguration.UsesBackingStore);
         Assert.Empty(generationConfiguration.Serializers);
         Assert.Empty(generationConfiguration.Deserializers);
+        Assert.Equal(2, generationConfiguration.PatternsOverride.Count);
     }
 
 }