Feature/http language support

.vscode/launch.json

@@ -404,6 +404,25 @@
       "type": "coreclr",
       "request": "attach",
       "processId": "${command:pickProcess}"
+    },
+    {
+      "name": "Launch Http",
+      "type": "coreclr",
+      "request": "launch",
+      "preLaunchTask": "build",
+      "program": "${workspaceFolder}/src/kiota/bin/Debug/net8.0/kiota.dll",
+      "args": [
+        "generate",
+        "--openapi",
+        "https://raw.githubusercontent.com/microsoftgraph/msgraph-sdk-powershell/dev/openApiDocs/v1.0/Mail.yml",
+        "--language",
+        "http",
+        "--output",
+        "${workspaceFolder}/samples/msgraph-mail/http",
+      ],
+      "cwd": "${workspaceFolder}/src/kiota",
+      "stopAtEntry": false,
+      "console": "internalConsole"
     }
   ]
 }

src/Kiota.Builder/Constants.cs

@@ -4,3 +4,11 @@ public static class Constants
     public const string DefaultOpenApiLabel = "default";
     public const string TempDirectoryName = "kiota";
 }
+
+public enum Authentication
+{
+    Basic,
+    Bearer,
+    OAuthV2,
+    APIKey,
+}

src/Kiota.Builder/GenerationLanguage.cs

@@ -11,4 +11,5 @@ public enum GenerationLanguage
     Ruby,
     CLI,
     Dart,
+    HTTP
 }

src/Kiota.Builder/KiotaBuilder.cs

@@ -26,6 +26,7 @@
 using Kiota.Builder.OpenApiExtensions;
 using Kiota.Builder.Plugins;
 using Kiota.Builder.Refiners;
+using Kiota.Builder.Settings;
 using Kiota.Builder.WorkspaceManagement;
 using Kiota.Builder.Writers;
 using Microsoft.Extensions.Logging;
@@ -46,6 +47,7 @@ public partial class KiotaBuilder
     private readonly ParallelOptions parallelOptions;
     private readonly HttpClient httpClient;
     private OpenApiDocument? openApiDocument;
+    private readonly SettingsFileManagementService settingsFileManagementService = new();
     internal void SetOpenApiDocument(OpenApiDocument document) => openApiDocument = document ?? throw new ArgumentNullException(nameof(document));
 
     public KiotaBuilder(ILogger<KiotaBuilder> logger, GenerationConfiguration config, HttpClient client, bool useKiotaConfig = false)
@@ -285,6 +287,11 @@ public async Task<bool> GenerateClientAsync(CancellationToken cancellationToken)
             sw.Start();
             await CreateLanguageSourceFilesAsync(config.Language, generatedCode, cancellationToken).ConfigureAwait(false);
             StopLogAndReset(sw, $"step {++stepId} - writing files - took");
+
+            if (config.Language == GenerationLanguage.HTTP && openApiDocument is not null)
+            {
+                await settingsFileManagementService.WriteSettingsFileAsync(config.OutputPath, openApiDocument, cancellationToken).ConfigureAwait(false);
+            }
             return stepId;
         }, cancellationToken).ConfigureAwait(false);
     }
@@ -554,6 +561,78 @@ public CodeNamespace CreateSourceModel(OpenApiUrlTreeNode? root)
         return rootNamespace;
     }
 
+    private void AddOperationSecurityRequirementToDOM(OpenApiOperation operation, CodeClass codeClass)
+    {
+        if (openApiDocument is null)
+        {
+            logger.LogWarning("OpenAPI document is null");
+            return;
+        }
+
+        if (operation.Security == null || !operation.Security.Any())
+            return;
+
+        var securitySchemes = openApiDocument.Components.SecuritySchemes;
+        foreach (var securityRequirement in operation.Security)
+        {
+            foreach (var scheme in securityRequirement.Keys)
+            {
+                var securityScheme = securitySchemes[scheme.Reference.Id];
+                switch (securityScheme.Type)
+                {
+                    case SecuritySchemeType.Http:
+                        AddHttpSecurity(codeClass, securityScheme);
+                        break;
+                    case SecuritySchemeType.ApiKey:
+                        AddApiKeySecurity(codeClass, securityScheme);
+                        break;
+                    case SecuritySchemeType.OAuth2:
+                        AddOAuth2Security(codeClass, securityScheme);
+                        break;
+                    default:
+                        logger.LogWarning("Unsupported security scheme type: {Type}", securityScheme.Type);
+                        break;
+                }
+            }
+        }
+    }
+
+    private void AddHttpSecurity(CodeClass codeClass, OpenApiSecurityScheme securityScheme)
+    {
+        codeClass.AddProperty(
+            new CodeProperty
+            {
+                Type = new CodeType { Name = Authentication.Basic.ToString(), IsExternal = true },
+                Kind = CodePropertyKind.Headers,
+                DefaultValue = $"{securityScheme.Scheme}Auth"
+            }
+        );
+    }
+
+    private void AddApiKeySecurity(CodeClass codeClass, OpenApiSecurityScheme securityScheme)
+    {
+        codeClass.AddProperty(
+            new CodeProperty
+            {
+                Type = new CodeType { Name = Authentication.APIKey.ToString(), IsExternal = true },
+                Kind = CodePropertyKind.Headers,
+                DefaultValue = $"{securityScheme.Scheme}Auth"
+            }
+        );
+    }
+
+    private void AddOAuth2Security(CodeClass codeClass, OpenApiSecurityScheme securityScheme)
+    {
+        codeClass.AddProperty(
+            new CodeProperty
+            {
+                Type = new CodeType { Name = Authentication.OAuthV2.ToString(), IsExternal = true },
+                Kind = CodePropertyKind.Headers,
+                DefaultValue = $"{securityScheme.Scheme}Auth"
+            }
+        );
+    }
+
     /// <summary>
     /// Manipulate CodeDOM for language specific issues
     /// </summary>
@@ -671,7 +750,14 @@ private void CreateRequestBuilderClass(CodeNamespace currentNamespace, OpenApiUr
             foreach (var operation in currentNode
                                     .PathItems[Constants.DefaultOpenApiLabel]
                                     .Operations)
+            {
+
                 CreateOperationMethods(currentNode, operation.Key, operation.Value, codeClass);
+                if (config.Language == GenerationLanguage.HTTP)
+                {
+                    AddOperationSecurityRequirementToDOM(operation.Value, codeClass);
+                }
+            }
         }
 
         if (rootNamespace != null)

src/Kiota.Builder/PathSegmenters/HttpPathSegmenter.cs

@@ -0,0 +1,13 @@
+using Kiota.Builder.CodeDOM;
+using Kiota.Builder.Extensions;
+
+namespace Kiota.Builder.PathSegmenters;
+public class HttpPathSegmenter(string rootPath, string clientNamespaceName) : CommonPathSegmenter(rootPath, clientNamespaceName)
+{
+    public override string FileSuffix => ".http";
+    public override string NormalizeNamespaceSegment(string segmentName) => segmentName.ToFirstCharacterUpperCase();
+    public override string NormalizeFileName(CodeElement currentElement)
+    {
+        return GetLastFileNameSegment(currentElement).ToFirstCharacterUpperCase();
+    }
+}

src/Kiota.Builder/Refiners/HttpRefiner.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Kiota.Builder.CodeDOM;
+using Kiota.Builder.Configuration;
+using Kiota.Builder.Extensions;
+
+namespace Kiota.Builder.Refiners;
+public class HttpRefiner(GenerationConfiguration configuration) : CommonLanguageRefiner(configuration)
+{
+    public override Task RefineAsync(CodeNamespace generatedCode, CancellationToken cancellationToken)
+    {
+        return Task.Run(() =>
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            CapitalizeNamespacesFirstLetters(generatedCode);
+            ReplaceIndexersByMethodsWithParameter(
+                generatedCode,
+                false,
+                static x => $"By{x.ToFirstCharacterUpperCase()}",
+                static x => x.ToFirstCharacterUpperCase(),
+                GenerationLanguage.HTTP);
+            cancellationToken.ThrowIfCancellationRequested();
+            ReplaceReservedNames(
+                generatedCode,
+                new HttpReservedNamesProvider(),
+                x => $"{x}_escaped");
+            RemoveCancellationParameter(generatedCode);
+            ConvertUnionTypesToWrapper(
+                generatedCode,
+                _configuration.UsesBackingStore,
+                static s => s
+            );
+            cancellationToken.ThrowIfCancellationRequested();
+            SetBaseUrlForRequestBuilderMethods(generatedCode, GetBaseUrl(generatedCode));
+            AddPathParameters(generatedCode);
+            // Remove unused code from the DOM e.g Models, BarrelInitializers, e.t.c
+            RemoveUnusedCodeElements(generatedCode);
+        }, cancellationToken);
+    }
+
+    private string? GetBaseUrl(CodeElement element)
+    {
+        return element.GetImmediateParentOfType<CodeNamespace>()
+                      .GetRootNamespace()?
+                      .FindChildByName<CodeClass>(_configuration.ClientClassName)?
+                      .Methods?
+                      .FirstOrDefault(static x => x.IsOfKind(CodeMethodKind.ClientConstructor))?
+                      .BaseUrl;
+    }
+
+    private static void CapitalizeNamespacesFirstLetters(CodeElement current)
+    {
+        if (current is CodeNamespace currentNamespace)
+            currentNamespace.Name = currentNamespace.Name.Split('.').Select(static x => x.ToFirstCharacterUpperCase()).Aggregate(static (x, y) => $"{x}.{y}");
+        CrawlTree(current, CapitalizeNamespacesFirstLetters);
+    }
+
+    private static void SetBaseUrlForRequestBuilderMethods(CodeElement current, string? baseUrl)
+    {
+        if (baseUrl is not null && current is CodeClass codeClass && codeClass.IsOfKind(CodeClassKind.RequestBuilder))
+        {
+            // Add a new property named BaseUrl and set its value to the baseUrl string
+            var baseUrlProperty = new CodeProperty
+            {
+                Name = "BaseUrl",
+                Kind = CodePropertyKind.Custom,
+                Access = AccessModifier.Private,
+                DefaultValue = baseUrl,
+                Type = new CodeType { Name = "string", IsExternal = true }
+            };
+            codeClass.AddProperty(baseUrlProperty);
+        }
+        CrawlTree(current, (element) => SetBaseUrlForRequestBuilderMethods(element, baseUrl));
+    }
+
+    private void RemoveUnusedCodeElements(CodeElement element)
+    {
+        if (!IsRequestBuilderClass(element) || IsBaseRequestBuilder(element) || IsRequestBuilderClassWithoutAnyHttpOperations(element))
+        {
+            var parentNameSpace = element.GetImmediateParentOfType<CodeNamespace>();
+            parentNameSpace?.RemoveChildElement(element);
+        }
+        CrawlTree(element, RemoveUnusedCodeElements);
+    }
+
+    private void AddPathParameters(CodeElement element)
+    {
+        var parent = element.GetImmediateParentOfType<CodeNamespace>().Parent;
+        while (parent is not null)
+        {
+            var codeIndexer = parent.GetChildElements(false)
+                .OfType<CodeClass>()
+                .FirstOrDefault()?
+                .GetChildElements(false)
+                .OfType<CodeMethod>()
+                .FirstOrDefault(static x => x.IsOfKind(CodeMethodKind.IndexerBackwardCompatibility));
+
+            if (codeIndexer is not null)
+            {
+                // Retrieve all the parameters of kind CodeParameterKind.Custom
+                var customParameters = codeIndexer.Parameters
+                    .Where(static param => param.IsOfKind(CodeParameterKind.Custom))
+                    .ToList();
+
+                // For each parameter:
+                foreach (var param in customParameters)
+                {
+                    // Create a new property of kind CodePropertyKind.PathParameters using the parameter and add it to the codeClass
+                    var pathParameterProperty = new CodeProperty
+                    {
+                        Name = param.Name,
+                        Kind = CodePropertyKind.PathParameters,
+                        Type = param.Type,
+                        Access = AccessModifier.Public,
+                        DefaultValue = param.DefaultValue,
+                        SerializationName = param.SerializationName,
+                        Documentation = param.Documentation
+                    };
+
+                    if (element is CodeClass codeClass)
+                        codeClass.AddProperty(pathParameterProperty);
+                }
+            }
+
+            parent = parent.Parent?.GetImmediateParentOfType<CodeNamespace>();
+        }
+        CrawlTree(element, AddPathParameters);
+    }
+
+    private static bool IsRequestBuilderClass(CodeElement element)
+    {
+        return element is CodeClass code && code.IsOfKind(CodeClassKind.RequestBuilder);
+    }
+
+    private bool IsBaseRequestBuilder(CodeElement element)
+    {
+        return element is CodeClass codeClass &&
+            codeClass.Name.Equals(_configuration.ClientClassName, StringComparison.Ordinal);
+    }
+
+    private static bool IsRequestBuilderClassWithoutAnyHttpOperations(CodeElement element)
+    {
+        return element is CodeClass codeClass && codeClass.IsOfKind(CodeClassKind.RequestBuilder) &&
+               !codeClass.Methods.Any(static method => method.IsOfKind(CodeMethodKind.RequestExecutor));
+    }
+}

src/Kiota.Builder/Refiners/HttpReservedNamesProvider.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+
+namespace Kiota.Builder.Refiners;
+public class HttpReservedNamesProvider : IReservedNamesProvider
+{
+    private readonly Lazy<HashSet<string>> _reservedNames = new(() => new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+    });
+    public HashSet<string> ReservedNames => _reservedNames.Value;
+}

src/Kiota.Builder/Refiners/ILanguageRefiner.cs

@@ -37,6 +37,9 @@ public static async Task RefineAsync(GenerationConfiguration config, CodeNamespa
             case GenerationLanguage.Swift:
                 await new SwiftRefiner(config).RefineAsync(generatedCode, cancellationToken).ConfigureAwait(false);
                 break;
+            case GenerationLanguage.HTTP:
+                await new HttpRefiner(config).RefineAsync(generatedCode, cancellationToken).ConfigureAwait(false);
+                break;
             case GenerationLanguage.Python:
                 await new PythonRefiner(config).RefineAsync(generatedCode, cancellationToken).ConfigureAwait(false);
                 break;

src/Kiota.Builder/Settings/ISettingsManagementService.cs

@@ -0,0 +1,28 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Services;
+
+namespace Kiota.Builder.Settings;
+/// <summary>
+/// A service that manages the settings file for http language snippets.
+/// </summary>
+public interface ISettingsManagementService
+{
+    /// <summary>
+    /// Gets the settings file for a Kiota project by crawling the directory tree.
+    /// </summary>
+    /// <param name="searchDirectory"></param>
+    /// <returns></returns>
+    string? GetDirectoryContainingSettingsFile(string searchDirectory);
+
+    /// <summary>
+    /// Writes the settings file to a directory.
+    /// </summary>
+    /// <param name="directoryPath"></param>
+    /// <param name="openApiDocument">OpenApi document</param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    Task WriteSettingsFileAsync(string directoryPath, OpenApiDocument openApiDocument, CancellationToken cancellationToken);
+}