feature/request builders proxy

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Fixed a bug where scalar error mappings would be generated even though it's not supported by the http request adapter. [#4018](https://github.com/microsoft/kiota/issues/4018)
+- Switched to proxy generation for TypeScript, leading to about ~44% bundle sizes reduction. [#3642](https://github.com/microsoft/kiota/issues/3642)
 
 ## [1.10.1] - 2024-01-12
 

src/Kiota.Builder/CodeDOM/CodeBlock.cs

@@ -157,6 +157,10 @@ public IEnumerable<T> FindChildrenByName<T>(string childName) where T : ICodeEle
         return Enumerable.Empty<T>();
     }
     public T? FindChildByName<T>(string childName, bool findInChildElements = true) where T : ICodeElement
+    {
+        return FindChildByName<T>(childName, findInChildElements ? uint.MaxValue : 1);
+    }
+    public T? FindChildByName<T>(string childName, uint maxDepth) where T : ICodeElement
     {
         ArgumentException.ThrowIfNullOrEmpty(childName);
 
@@ -165,10 +169,10 @@ public IEnumerable<T> FindChildrenByName<T>(string childName) where T : ICodeEle
 
         if (InnerChildElements.TryGetValue(childName, out var result) && result is T castResult)
             return castResult;
-        if (findInChildElements)
+        if (--maxDepth > 0)
             foreach (var childElement in InnerChildElements.Values.OfType<IBlock>())
             {
-                var childResult = childElement.FindChildByName<T>(childName);
+                var childResult = childElement.FindChildByName<T>(childName, maxDepth);
                 if (childResult != null)
                     return childResult;
             }
@@ -196,7 +200,7 @@ public void RemoveUsings(params CodeUsing[] codeUsings)
     }
     public void RemoveUsingsByDeclarationName(params string[] names)
     {
-        if (names == null || names.Any(x => string.IsNullOrEmpty(x)))
+        if (names == null || names.Any(string.IsNullOrEmpty))
             throw new ArgumentNullException(nameof(names));
         var namesAsHashSet = names.ToHashSet(StringComparer.OrdinalIgnoreCase);
         foreach (var usingToRemove in usings.Keys.Where(x => !string.IsNullOrEmpty(x.Declaration?.Name) && namesAsHashSet.Contains(x.Declaration!.Name)))

src/Kiota.Builder/CodeDOM/CodeConstant.cs

@@ -4,24 +4,39 @@
 
 namespace Kiota.Builder.CodeDOM;
 
-public class CodeConstant : CodeTerminalWithKind<CodeConstantKind>
+public class CodeConstant : CodeTerminalWithKind<CodeConstantKind>, IDocumentedElement
 {
+    public BlockDeclaration StartBlock { get; set; } = new();
+    public void AddUsing(params CodeUsing[] codeUsings) => StartBlock.AddUsings(codeUsings);
     public CodeElement? OriginalCodeElement
     {
         get;
         set;
     }
+#pragma warning disable CA1056 // URI-like properties should not be strings
+    public string? UriTemplate
+    {
+        get; init;
+    }
+    /// <inheritdoc/>
+    public CodeDocumentation Documentation
+    {
+        get; set;
+    } = new();
+#pragma warning restore CA1056 // URI-like properties should not be strings
     public static CodeConstant? FromQueryParametersMapping(CodeInterface source)
     {
         ArgumentNullException.ThrowIfNull(source);
         if (source.Kind is not CodeInterfaceKind.QueryParameters) throw new InvalidOperationException("Cannot create a query parameters constant from a non query parameters interface");
         if (!source.Properties.Any(static x => !string.IsNullOrEmpty(x.SerializationName))) return default;
-        return new CodeConstant
+        var result = new CodeConstant
         {
             Name = $"{source.Name.ToFirstCharacterLowerCase()}Mapper",
             Kind = CodeConstantKind.QueryParametersMapper,
             OriginalCodeElement = source,
         };
+        result.Documentation.Description = "Mapper for query parameters from symbol name to serialization name represented as a constant.";
+        return result;
     }
     public static CodeConstant? FromCodeEnum(CodeEnum source)
     {
@@ -33,9 +48,80 @@ public CodeElement? OriginalCodeElement
             OriginalCodeElement = source,
         };
     }
+    internal const string UriTemplateSuffix = "UriTemplate";
+    internal const string RequestsMetadataSuffix = "RequestsMetadata";
+    internal const string NavigationMetadataSuffix = "NavigationMetadata";
+    public static CodeConstant? FromRequestBuilderClassToUriTemplate(CodeClass codeClass)
+    {
+        ArgumentNullException.ThrowIfNull(codeClass);
+        if (codeClass.Kind != CodeClassKind.RequestBuilder) return default;
+        if (codeClass.Properties.FirstOrDefaultOfKind(CodePropertyKind.UrlTemplate) is not CodeProperty urlTemplateProperty) throw new InvalidOperationException($"Couldn't find the url template property for class {codeClass.Name}");
+        var result = new CodeConstant
+        {
+            Name = $"{codeClass.Name.ToFirstCharacterLowerCase()}{UriTemplateSuffix}",
+            Kind = CodeConstantKind.UriTemplate,
+            UriTemplate = urlTemplateProperty.DefaultValue,
+            OriginalCodeElement = codeClass
+        };
+        result.Documentation.Description = "Uri template for the request builder.";
+        return result;
+    }
+    public static CodeConstant? FromRequestBuilderToNavigationMetadata(CodeClass codeClass, CodeUsing[]? usingsToAdd = default)
+    {
+        ArgumentNullException.ThrowIfNull(codeClass);
+        if (codeClass.Kind != CodeClassKind.RequestBuilder) return default;
+        if (!(codeClass.Properties.Any(static x => x.Kind is CodePropertyKind.RequestBuilder) ||
+            codeClass.Methods.Any(static x => x.Kind is CodeMethodKind.IndexerBackwardCompatibility or CodeMethodKind.RequestBuilderWithParameters)))
+            return default;
+        var result = new CodeConstant
+        {
+            Name = $"{codeClass.Name.ToFirstCharacterLowerCase()}{NavigationMetadataSuffix}",
+            Kind = CodeConstantKind.NavigationMetadata,
+            OriginalCodeElement = codeClass,
+        };
+        result.Documentation.Description = "Metadata for all the navigation properties in the request builder.";
+        if (usingsToAdd is { Length: > 0 } usingsToAddList)
+            result.AddUsing(usingsToAddList);
+        return result;
+    }
+    public static CodeConstant? FromRequestBuilderToRequestsMetadata(CodeClass codeClass, CodeUsing[]? usingsToAdd = default)
+    {
+        ArgumentNullException.ThrowIfNull(codeClass);
+        if (codeClass.Kind != CodeClassKind.RequestBuilder) return default;
+        if (!codeClass.Methods.Any(static x => x.Kind is CodeMethodKind.RequestExecutor or CodeMethodKind.RequestGenerator))
+            return default;
+        var result = new CodeConstant
+        {
+            Name = $"{codeClass.Name.ToFirstCharacterLowerCase()}{RequestsMetadataSuffix}",
+            Kind = CodeConstantKind.RequestsMetadata,
+            OriginalCodeElement = codeClass,
+        };
+        result.Documentation.Description = "Metadata for all the requests in the request builder.";
+        if (usingsToAdd is { Length: > 0 } usingsToAddList)
+            result.AddUsing(usingsToAddList);
+        return result;
+    }
 }
 public enum CodeConstantKind
 {
+    /// <summary>
+    /// Mapper for query parameters from symbol name to serialization name represented as a constant.
+    /// </summary>
     QueryParametersMapper,
+    /// <summary>
+    /// Enum mapping keys represented as a constant.
+    /// </summary>
     EnumObject,
+    /// <summary>
+    /// Uri template for the request builder.
+    /// </summary>
+    UriTemplate,
+    /// <summary>
+    /// Indexer methods, builders with parameters, and request builder properties represented as a single constant for proxy generation.
+    /// </summary>
+    NavigationMetadata,
+    /// <summary>
+    /// Request generators and executors represented as a single constant for proxy generation.
+    /// </summary>
+    RequestsMetadata,
 }

src/Kiota.Builder/CodeDOM/CodeFile.cs

@@ -9,6 +9,7 @@ public class CodeFile : CodeBlock<CodeFileDeclaration, CodeFileBlockEnd>
     public IEnumerable<CodeInterface> Interfaces => InnerChildElements.Values.OfType<CodeInterface>().OrderBy(static x => x.Name, StringComparer.Ordinal);
     public IEnumerable<CodeClass> Classes => InnerChildElements.Values.OfType<CodeClass>().OrderBy(static x => x.Name, StringComparer.Ordinal);
     public IEnumerable<CodeEnum> Enums => InnerChildElements.Values.OfType<CodeEnum>().OrderBy(static x => x.Name, StringComparer.Ordinal);
+    public IEnumerable<CodeConstant> Constants => InnerChildElements.Values.OfType<CodeConstant>().OrderBy(static x => x.Name, StringComparer.Ordinal);
 
     public IEnumerable<T> AddElements<T>(params T[] elements) where T : CodeElement
     {

src/Kiota.Builder/CodeDOM/CodeInterface.cs

@@ -1,19 +1,66 @@
-namespace Kiota.Builder.CodeDOM;
+using System;
+using System.Linq;
+
+namespace Kiota.Builder.CodeDOM;
 
 public enum CodeInterfaceKind
 {
     Custom,
     Model,
     QueryParameters,
-    RequestConfiguration
+    RequestBuilder,
 }
 
-public class CodeInterface : ProprietableBlock<CodeInterfaceKind, InterfaceDeclaration>, ITypeDefinition
+public class CodeInterface : ProprietableBlock<CodeInterfaceKind, InterfaceDeclaration>, ITypeDefinition, IDeprecableElement
 {
     public CodeClass? OriginalClass
     {
         get; set;
     }
+    public DeprecationInformation? Deprecation
+    {
+        get; set;
+    }
+
+    public static CodeInterface FromRequestBuilder(CodeClass codeClass, CodeUsing[]? usingsToAdd = default)
+    {
+        ArgumentNullException.ThrowIfNull(codeClass);
+        if (codeClass.Kind != CodeClassKind.RequestBuilder) throw new InvalidOperationException($"Cannot create a request builder interface from a non request builder class");
+        var result = new CodeInterface
+        {
+            Name = codeClass.Name,
+            Kind = CodeInterfaceKind.RequestBuilder,
+            OriginalClass = codeClass,
+            Documentation = codeClass.Documentation,
+            Deprecation = codeClass.Deprecation,
+        };
+
+        if (codeClass.Methods
+                .Where(static x => x.Kind is CodeMethodKind.RequestGenerator or
+                                            CodeMethodKind.RequestExecutor or
+                                            CodeMethodKind.IndexerBackwardCompatibility or
+                                            CodeMethodKind.RequestBuilderWithParameters)
+                .Select(static x => (CodeMethod)x.Clone()).ToArray() is { Length: > 0 } methods)
+            result.AddMethod(methods);
+        if (codeClass.Properties
+                .Where(static x => x.Kind is CodePropertyKind.RequestBuilder)
+                .Select(static x => (CodeProperty)x.Clone()).ToArray() is { Length: > 0 } properties)
+            result.AddProperty(properties);
+
+        if (codeClass.Usings.ToArray() is { Length: > 0 } usings)
+        {
+            foreach (var usingToCopy in usings.Where(static x => x.Declaration?.TypeDefinition is CodeInterface or CodeClass { Kind: CodeClassKind.RequestBuilder }))
+            {
+                usingToCopy.IsErasable = true;
+            }
+            result.AddUsing(usings);
+        }
+        if (usingsToAdd is { Length: > 0 } usingsToAddList)
+            result.AddUsing(usingsToAddList);
+        if (codeClass.StartBlock.Inherits is not null)
+            result.StartBlock.AddImplements(codeClass.StartBlock.Inherits);
+        return result;
+    }
 }
 public class InterfaceDeclaration : ProprietableBlockDeclaration
 {

src/Kiota.Builder/CodeDOM/IBlock.cs

@@ -9,6 +9,7 @@ namespace Kiota.Builder.CodeDOM;
 public interface IBlock
 {
     T? FindChildByName<T>(string childName, bool findInChildElements = true) where T : ICodeElement;
+    T? FindChildByName<T>(string childName, uint maxDepth) where T : ICodeElement;
     IEnumerable<T> FindChildrenByName<T>(string childName) where T : ICodeElement;
     void AddUsing(params CodeUsing[] codeUsings);
     CodeElement? Parent

src/Kiota.Builder/Extensions/StringExtensions.cs

@@ -280,5 +280,5 @@ public static string CleanupXMLString(this string? original)
     /// <param name="b">The second string</param>
     /// <returns></returns>
     public static bool EqualsIgnoreCase(this string? a, string? b)
-        => String.Equals(a, b, StringComparison.OrdinalIgnoreCase);
+        => string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
 }

src/Kiota.Builder/PathSegmenters/TypeScriptPathSegmenter.cs

@@ -21,7 +21,7 @@ public override string NormalizeFileName(CodeElement currentElement)
             CodeFile currentFile when modelsNamespace is not null &&
                         currentElement.GetImmediateParentOfType<CodeNamespace>() is CodeNamespace currentNamespace &&
                         !(modelsNamespace.IsParentOf(currentNamespace) || modelsNamespace == currentNamespace) &&
-                        !currentFile.Classes.Any(static x => x.Kind is CodeClassKind.RequestBuilder && x.Methods.Any(static y => y.Kind is CodeMethodKind.ClientConstructor))
+                        !currentFile.Interfaces.Any(static x => x.Kind is CodeInterfaceKind.RequestBuilder && x.OriginalClass is not null && x.OriginalClass.Methods.Any(static y => y.Kind is CodeMethodKind.ClientConstructor))
                     => IndexFileName,
             _ => GetDefaultFileName(currentElement),
         };