feat: Add support for composed types in Typescript

it/config.json

@@ -43,10 +43,6 @@
       }
     ],
     "Suppressions": [
-      {
-        "Language": "typescript",
-        "Rationale": "https://github.com/microsoft/kiota/issues/1812"
-      },
       {
         "Language": "ruby",
         "Rationale": "https://github.com/microsoft/kiota/issues/1816"
@@ -156,10 +152,6 @@
         "Language": "go",
         "Rationale": "https://github.com/microsoft/kiota/issues/3436"
       },
-      {
-        "Language": "typescript",
-        "Rationale": "https://github.com/microsoft/kiota/issues/1812"
-      },
       {
         "Language": "ruby",
         "Rationale": "https://github.com/microsoft/kiota/issues/2484"
@@ -170,10 +162,6 @@
       }
     ],
     "IdempotencySuppressions": [
-      {
-        "Language": "typescript",
-        "Rationale": "https://github.com/microsoft/kiota/issues/1812"
-      }
     ]
   },
   "apisguru::twilio.com:api": {
@@ -248,7 +236,7 @@
     "Suppressions": [
       {
         "Language": "typescript",
-        "Rationale": "https://github.com/microsoft/kiota/issues/1812"
+        "Rationale": "This document includes an intersection between objects and primitive values, which is not supported in the TypeScript language and results in compilation errors."
       },
       {
         "Language": "go",
@@ -280,10 +268,6 @@
         "Language": "python",
         "Rationale": "https://github.com/microsoft/kiota/issues/2842"
       },
-      {
-        "Language": "typescript",
-        "Rationale": "https://github.com/microsoft/kiota/issues/1812"
-      },
       {
         "Language": "ruby",
         "Rationale": "https://github.com/microsoft/kiota/issues/1816"
@@ -312,20 +296,12 @@
   },
   "apisguru::twitter.com:current": {
     "Suppressions": [
-      {
-        "Language": "typescript",
-        "Rationale": "https://github.com/microsoft/kiota/issues/1812"
-      },
       {
         "Language": "ruby",
         "Rationale": "https://github.com/microsoft/kiota/issues/1816"
       }
     ],
     "IdempotencySuppressions": [
-      {
-        "Language": "typescript",
-        "Rationale": "https://github.com/microsoft/kiota/issues/1812"
-      }
     ]
   },
   "apisguru::apis.guru": {

src/Kiota.Builder/CodeDOM/CodeMethod.cs

@@ -120,6 +120,27 @@
         method.AddParameter(parameter);
         return method;
     }
+    public static CodeMethod FromCodeFunctionAndInterface(CodeInterface codeInterface, CodeFunction function, CodeMethodKind kind)
+    {
+        ArgumentNullException.ThrowIfNull(codeInterface);
+        ArgumentNullException.ThrowIfNull(function);
+        ArgumentNullException.ThrowIfNull(kind);
+        var method = new CodeMethod
+        {
+            Name = function.OriginalLocalMethod.Name,
+            ReturnType = function.OriginalLocalMethod.ReturnType,
+            Kind = kind,
+            Access = function.OriginalLocalMethod.Access,
+            IsAsync = function.OriginalLocalMethod.IsAsync,
+            IsStatic = function.OriginalLocalMethod.IsStatic,
+            Documentation = function.OriginalLocalMethod.Documentation,
+            Parent = codeInterface.OriginalClass,
+        };
+
+        method.AddParameter(function.OriginalLocalMethod.Parameters.ToArray());
+
+        return method;
+    }
     public HttpMethod? HttpMethod
     {
         get; set;
@@ -345,7 +366,7 @@
 
     public void AddParameter(params CodeParameter[] methodParameters)
     {
         if (methodParameters == null || methodParameters.Any(static x => x == null))
             throw new ArgumentNullException(nameof(methodParameters));
         if (methodParameters.Length == 0)
             throw new ArgumentOutOfRangeException(nameof(methodParameters));

src/Kiota.Builder/Refiners/TypeScriptRefiner.cs

@@ -6,19 +6,30 @@
 using Kiota.Builder.CodeDOM;
 using Kiota.Builder.Configuration;
 using Kiota.Builder.Extensions;
+using static Kiota.Builder.Writers.TypeScript.TypeScriptConventionService;
 
 namespace Kiota.Builder.Refiners;
-public class TypeScriptRefiner : CommonLanguageRefiner, ILanguageRefiner
+public class TypeScriptRefiner(GenerationConfiguration configuration) : CommonLanguageRefiner(configuration), ILanguageRefiner
 {
     public static readonly string BackingStoreEnabledKey = "backingStoreEnabled";
-    public TypeScriptRefiner(GenerationConfiguration configuration) : base(configuration) { }
+
     public override Task Refine(CodeNamespace generatedCode, CancellationToken cancellationToken)
     {
         return Task.Run(() =>
         {
             cancellationToken.ThrowIfCancellationRequested();
             DeduplicateErrorMappings(generatedCode);
             RemoveMethodByKind(generatedCode, CodeMethodKind.RawUrlConstructor, CodeMethodKind.RawUrlBuilder);
+            // Invoke the ConvertUnionTypesToWrapper method to maintain a consistent CodeDOM structure. 
+            // Note that in the later stages, specifically within the GenerateModelCodeFile() function, the introduced wrapper interface is disregarded. 
+            // Instead, a ComposedType is created, which has its own writer, along with the associated Factory, Serializer, and Deserializer functions 
+            // that are incorporated into the CodeFile.
+            ConvertUnionTypesToWrapper(
+                generatedCode,
+                _configuration.UsesBackingStore,
+                s => s.ToFirstCharacterLowerCase(),
+                false
+            );
             ReplaceReservedNames(generatedCode, new TypeScriptReservedNamesProvider(), static x => $"{x}Escaped");
             ReplaceReservedExceptionPropertyNames(generatedCode, new TypeScriptExceptionsReservedNamesProvider(), static x => $"{x}Escaped");
             MoveRequestBuilderPropertiesToBaseType(generatedCode,
@@ -250,20 +261,128 @@ parentNamespace.Parent is CodeNamespace parentLevelNamespace &&
 
     private static CodeFile? GenerateModelCodeFile(CodeInterface codeInterface, CodeNamespace codeNamespace)
     {
-        var functions = codeNamespace.GetChildElements(true).OfType<CodeFunction>().Where(codeFunction =>
-            codeFunction.OriginalLocalMethod.Kind is CodeMethodKind.Deserializer or CodeMethodKind.Serializer &&
-                codeFunction.OriginalLocalMethod.Parameters
-                    .Any(x => x.Type.Name.Equals(codeInterface.Name, StringComparison.OrdinalIgnoreCase)) ||
-
-            codeFunction.OriginalLocalMethod.Kind is CodeMethodKind.Factory &&
-                        codeInterface.Name.EqualsIgnoreCase(codeFunction.OriginalMethodParentClass.Name) &&
-                        codeFunction.OriginalMethodParentClass.IsChildOf(codeNamespace)
-        ).ToArray();
+        var functions = GetSerializationAndFactoryFunctions(codeInterface, codeNamespace).ToArray();
 
         if (functions.Length == 0)
             return null;
-        return codeNamespace.TryAddCodeFile(codeInterface.Name, [codeInterface, .. functions]);
+
+        var composedType = GetOriginalComposedType(codeInterface);
+        var elements = composedType is null ? new List<CodeElement> { codeInterface }.Concat(functions) : GetCodeFileElementsForComposedType(codeInterface, codeNamespace, composedType, functions);
+
+        return codeNamespace.TryAddCodeFile(codeInterface.Name, elements.ToArray());
+    }
+
+    private static IEnumerable<CodeFunction> GetSerializationAndFactoryFunctions(CodeInterface codeInterface, CodeNamespace codeNamespace)
+    {
+        return codeNamespace.GetChildElements(true)
+            .OfType<CodeFunction>()
+            .Where(codeFunction =>
+                IsDeserializerOrSerializerFunction(codeFunction, codeInterface) ||
+                IsFactoryFunction(codeFunction, codeInterface, codeNamespace));
+    }
+
+    private static bool IsDeserializerOrSerializerFunction(CodeFunction codeFunction, CodeInterface codeInterface)
+    {
+        return codeFunction.OriginalLocalMethod.Kind is CodeMethodKind.Deserializer or CodeMethodKind.Serializer &&
+            codeFunction.OriginalLocalMethod.Parameters.Any(x => x.Type is CodeType codeType && codeType.TypeDefinition == codeInterface);
+    }
+
+    private static bool IsFactoryFunction(CodeFunction codeFunction, CodeInterface codeInterface, CodeNamespace codeNamespace)
+    {
+        return codeFunction.OriginalLocalMethod.Kind is CodeMethodKind.Factory &&
+            codeInterface.Name.EqualsIgnoreCase(codeFunction.OriginalMethodParentClass.Name) &&
+            codeFunction.OriginalMethodParentClass.IsChildOf(codeNamespace);
+    }
+
+    private static List<CodeElement> GetCodeFileElementsForComposedType(CodeInterface codeInterface, CodeNamespace codeNamespace, CodeComposedTypeBase composedType, CodeFunction[] functions)
+    {
+        var children = new List<CodeElement>(functions)
+        {
+            // Add the composed type, The writer will output the composed type as a type definition e.g export type Pet = Cat | Dog
+            composedType
+        };
+
+        ReplaceFactoryMethodForComposedType(composedType, children);
+        ReplaceSerializerMethodForComposedType(composedType, children);
+        ReplaceDeserializerMethodForComposedType(codeInterface, codeNamespace, composedType, children);
+
+        return children;
+    }
+
+    private static CodeFunction? FindFunctionOfKind(List<CodeElement> elements, CodeMethodKind kind)
+    {
+        return elements.OfType<CodeFunction>().FirstOrDefault(function => function.OriginalLocalMethod.IsOfKind(kind));
+    }
+
+    private static void RemoveUnusedDeserializerImport(List<CodeElement> children, CodeFunction factoryFunction)
+    {
+        if (FindFunctionOfKind(children, CodeMethodKind.Deserializer) is { } deserializerMethod)
+            factoryFunction.RemoveUsingsByDeclarationName(deserializerMethod.Name);
+    }
+
+    private static void ReplaceFactoryMethodForComposedType(CodeComposedTypeBase composedType, List<CodeElement> children)
+    {
+        if (FindFunctionOfKind(children, CodeMethodKind.Factory) is not { } function) return;
+
+        if (composedType is not null && IsComposedOfPrimitives(composedType))
+            function.OriginalLocalMethod.ReturnType = composedType;
+
+        // Remove the deserializer import statement if its not being used
+        if (composedType is CodeUnionType || composedType is not null && IsComposedOfPrimitives(composedType))
+        {
+            RemoveUnusedDeserializerImport(children, function);
+        }
     }
+
+    private static void ReplaceSerializerMethodForComposedType(CodeComposedTypeBase composedType, List<CodeElement> children)
+    {
+        if (FindFunctionOfKind(children, CodeMethodKind.Serializer) is not { } function) return;
+
+        // Add the key parameter if the composed type is a union of primitive values
+        if (IsComposedOfPrimitives(composedType))
+            function.OriginalLocalMethod.AddParameter(CreateKeyParameter());
+    }
+
+    private static void ReplaceDeserializerMethodForComposedType(CodeInterface codeInterface, CodeNamespace codeNamespace, CodeComposedTypeBase composedType, List<CodeElement> children)
+    {
+        if (FindFunctionOfKind(children, CodeMethodKind.Deserializer) is not { } deserializerMethod) return;
+
+        // For code union Deserializer is not required, however its needed for Object Intersection types
+        if (composedType is not CodeIntersectionType || IsComposedOfPrimitives(composedType))
+        {
+            children.Remove(deserializerMethod);
+            codeInterface.RemoveChildElement(deserializerMethod);
+            codeNamespace.RemoveChildElement(deserializerMethod);
+        }
+    }
+
+    private static CodeParameter CreateKeyParameter()
+    {
+        return new CodeParameter
+        {
+            Name = "key",
+            Type = new CodeType { Name = "string", IsExternal = true, IsNullable = false },
+            Optional = false,
+            Documentation = new()
+            {
+                DescriptionTemplate = "The name of the property to write in the serialization.",
+            },
+        };
+    }
+
+    public static CodeComposedTypeBase? GetOriginalComposedType(CodeElement element)
+    {
+        return element switch
+        {
+            CodeParameter param => GetOriginalComposedType(param.Type),
+            CodeType codeType when codeType.TypeDefinition is not null => GetOriginalComposedType(codeType.TypeDefinition),
+            CodeClass codeClass => codeClass.OriginalComposedType,
+            CodeInterface codeInterface => codeInterface.OriginalClass.OriginalComposedType,
+            CodeComposedTypeBase composedType => composedType,
+            _ => null,
+        };
+    }
+
     private static readonly CodeUsing[] navigationMetadataUsings = [
         new CodeUsing
         {
@@ -739,9 +858,9 @@ private static void AddInterfaceParamToSerializer(CodeInterface modelInterface,
 
         method.AddParameter(new CodeParameter
         {
-            Name = ReturnFinalInterfaceName(modelInterface),
+            Name = GetFinalInterfaceName(modelInterface),
             DefaultValue = "{}",
-            Type = new CodeType { Name = ReturnFinalInterfaceName(modelInterface), TypeDefinition = modelInterface },
+            Type = new CodeType { Name = GetFinalInterfaceName(modelInterface), TypeDefinition = modelInterface },
             Kind = CodeParameterKind.DeserializationTarget,
         });
 
@@ -752,7 +871,7 @@ private static void AddInterfaceParamToSerializer(CodeInterface modelInterface,
                 Name = modelInterface.Parent.Name,
                 Declaration = new CodeType
                 {
-                    Name = ReturnFinalInterfaceName(modelInterface),
+                    Name = GetFinalInterfaceName(modelInterface),
                     TypeDefinition = modelInterface
                 }
             });
@@ -783,7 +902,7 @@ private static void RenameModelInterfacesAndRemoveClasses(CodeElement currentEle
     {
         if (currentElement is CodeInterface modelInterface && modelInterface.IsOfKind(CodeInterfaceKind.Model) && modelInterface.Parent is CodeNamespace parentNS)
         {
-            var finalName = ReturnFinalInterfaceName(modelInterface);
+            var finalName = GetFinalInterfaceName(modelInterface);
             if (!finalName.Equals(modelInterface.Name, StringComparison.Ordinal))
             {
                 if (parentNS.FindChildByName<CodeClass>(finalName, false) is CodeClass existingClassToRemove)
@@ -803,11 +922,11 @@ private static void RenameCodeInterfaceParamsInSerializers(CodeFunction codeFunc
     {
         if (codeFunction.OriginalLocalMethod.Parameters.FirstOrDefault(static x => x.Type is CodeType codeType && codeType.TypeDefinition is CodeInterface) is CodeParameter param && param.Type is CodeType codeType && codeType.TypeDefinition is CodeInterface paramInterface)
         {
-            param.Name = ReturnFinalInterfaceName(paramInterface);
+            param.Name = GetFinalInterfaceName(paramInterface);
         }
     }
 
-    private static string ReturnFinalInterfaceName(CodeInterface codeInterface)
+    private static string GetFinalInterfaceName(CodeInterface codeInterface)
     {
         return codeInterface.OriginalClass.Name.ToFirstCharacterUpperCase();
     }
@@ -927,7 +1046,7 @@ private static void SetTypeAsModelInterface(CodeInterface interfaceElement, Code
             Name = interfaceElement.Name,
             TypeDefinition = interfaceElement,
         };
-        requestBuilder.RemoveUsingsByDeclarationName(ReturnFinalInterfaceName(interfaceElement));
+        requestBuilder.RemoveUsingsByDeclarationName(GetFinalInterfaceName(interfaceElement));
         if (!requestBuilder.Usings.Any(x => x.Declaration?.TypeDefinition == elemType.TypeDefinition))
         {
             requestBuilder.AddUsing(new CodeUsing
@@ -971,7 +1090,7 @@ private static CodeInterface CreateModelInterface(CodeClass modelClass, Func<Cod
             Kind = CodeInterfaceKind.Model,
             Documentation = modelClass.Documentation,
             Deprecation = modelClass.Deprecation,
-            OriginalClass = modelClass
+            OriginalClass = modelClass,
         };
 
         var modelInterface = modelClass.Parent is CodeClass modelParentClass ?
@@ -996,7 +1115,7 @@ private static void ProcessModelClassDeclaration(CodeClass modelClass, CodeInter
             var parentInterface = CreateModelInterface(baseClass, tempInterfaceNamingCallback);
             var codeType = new CodeType
             {
-                Name = ReturnFinalInterfaceName(parentInterface),
+                Name = GetFinalInterfaceName(parentInterface),
                 TypeDefinition = parentInterface,
             };
             modelInterface.StartBlock.AddImplements(codeType);

src/Kiota.Builder/Writers/LanguageWriter.cs

@@ -158,6 +158,12 @@ public void Write<T>(T code) where T : CodeElement
                 case CodeConstant codeConstant:
                     ((ICodeElementWriter<CodeConstant>)elementWriter).WriteCodeElement(codeConstant, this);
                     break;
+                case CodeUnionType codeUnionType:
+                    ((ICodeElementWriter<CodeUnionType>)elementWriter).WriteCodeElement(codeUnionType, this);
+                    break;
+                case CodeIntersectionType codeIntersectionType:
+                    ((ICodeElementWriter<CodeIntersectionType>)elementWriter).WriteCodeElement(codeIntersectionType, this);
+                    break;
             }
         else if (code is not CodeClass &&
                 code is not BlockDeclaration &&

src/Kiota.Builder/Writers/TypeScript/CodeComposedTypeBaseWriter.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Linq;
+using Kiota.Builder.CodeDOM;
+using Kiota.Builder.Extensions;
+
+namespace Kiota.Builder.Writers.TypeScript;
+
+public abstract class CodeComposedTypeBaseWriter<TCodeComposedTypeBase>(TypeScriptConventionService conventionService) : BaseElementWriter<TCodeComposedTypeBase, TypeScriptConventionService>(conventionService) where TCodeComposedTypeBase : CodeComposedTypeBase
+{
+    public abstract string TypesDelimiter
+    {
+        get;
+    }
+
+    public override void WriteCodeElement(TCodeComposedTypeBase codeElement, LanguageWriter writer)
+    {
+        ArgumentNullException.ThrowIfNull(codeElement);
+        ArgumentNullException.ThrowIfNull(writer);
+
+        if (!codeElement.Types.Any())
+            throw new InvalidOperationException("CodeComposedTypeBase should be comprised of one or more types.");
+
+        var codeUnionString = string.Join($" {TypesDelimiter} ", codeElement.Types.Select(x => conventions.GetTypeString(x, codeElement)));
+
+        writer.WriteLine($"export type {codeElement.Name.ToFirstCharacterUpperCase()} = {codeUnionString};");
+    }
+}