Typescript Adding model interface, serializer and deserializer functions and remove model classes

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Added typescript interfaces for models and request config params. [#1013](https://github.com/microsoft/kiota/issues/1013) and [#1521](https://github.com/microsoft/kiota/issues/1521)
 - Added automatic loading of the lock file for the extension so quick edits of clients are supported.
 - Added trimming of derived types that are not being used by the client. [#2543](https://github.com/microsoft/kiota/issues/2543)
 - Added support for merging schemas of AllOf > 2. [#2438](https://github.com/microsoft/kiota/issues/2438)

src/Kiota.Builder/CodeDOM/CodeInterface.cs

@@ -4,6 +4,8 @@ public enum CodeInterfaceKind
 {
     Custom,
     Model,
+    QueryParameters,
+    RequestConfiguration
 }
 
 public class CodeInterface : ProprietableBlock<CodeInterfaceKind, InterfaceDeclaration>, ITypeDefinition

src/Kiota.Builder/CodeDOM/CodeNamespace.cs

@@ -68,6 +68,8 @@ public CodeNamespace GetRootNamespace()
     public IEnumerable<CodeNamespace> Namespaces => InnerChildElements.Values.OfType<CodeNamespace>();
     public IEnumerable<CodeClass> Classes => InnerChildElements.Values.OfType<CodeClass>();
     public IEnumerable<CodeEnum> Enums => InnerChildElements.Values.OfType<CodeEnum>();
+    public IEnumerable<CodeFunction> Functions => InnerChildElements.Values.OfType<CodeFunction>();
+    public IEnumerable<CodeInterface> Interfaces => InnerChildElements.Values.OfType<CodeInterface>();
     public CodeNamespace? FindNamespaceByName(string nsName)
     {
         ArgumentException.ThrowIfNullOrEmpty(nsName);

src/Kiota.Builder/CodeDOM/CodeProperty.cs

@@ -40,7 +40,7 @@ public enum CodePropertyKind
     SerializationHint,
 }
 
-public class CodeProperty : CodeTerminalWithKind<CodePropertyKind>, IDocumentedElement, IAlternativeName
+public class CodeProperty : CodeTerminalWithKind<CodePropertyKind>, IDocumentedElement, IAlternativeName, ICloneable
 {
     public bool ReadOnly { get; set; } = false;
     public AccessModifier Access { get; set; } = AccessModifier.Public;
@@ -135,3 +135,4 @@ public object Clone()
         return property;
     }
 }
+

src/Kiota.Builder/CodeRenderers/TypeScriptCodeRenderer.cs

@@ -8,6 +8,6 @@ public class TypeScriptCodeRenderer : CodeRenderer
     public TypeScriptCodeRenderer(GenerationConfiguration configuration) : base(configuration) { }
     public override bool ShouldRenderNamespaceFile(CodeNamespace codeNamespace)
     {
-        return codeNamespace.Classes.Any(static c => c.IsOfKind(CodeClassKind.Model));
+        return codeNamespace.Interfaces.Any();
     }
 }

src/Kiota.Builder/Extensions/StringExtensions.cs

@@ -229,4 +229,13 @@ private static string NormalizeSymbolsAfterCleanup(string original)
     /// <returns></returns>
     public static string CleanupXMLString(this string? original)
         => SecurityElement.Escape(original) ?? string.Empty;
+
+    /// <summary>
+    /// Checks if 2 strings are equal, case insensitive
+    /// </summary>
+    /// <param name="a">The first or current string</param>
+    /// <param name="b">The second string</param>
+    /// <returns></returns>
+    public static bool EqualsIgnoreCase(this string? a, string? b)
+        => String.Equals(a, b, StringComparison.OrdinalIgnoreCase);
 }

src/Kiota.Builder/Refiners/CommonLanguageRefiner.cs

@@ -405,6 +405,7 @@ currentProperty.Type is CodeType propertyType &&
 
         CrawlTree(current, x => ReplaceReservedNames(x, provider, replacement, codeElementExceptions, shouldReplaceCallback));
     }
+
     private static void ReplaceReservedEnumNames(CodeEnum currentEnum, IReservedNamesProvider provider, Func<string, string> replacement)
     {
         currentEnum.Options

src/Kiota.Builder/Refiners/TypeScriptReservedNamesProvider.cs

@@ -29,6 +29,7 @@ public class TypeScriptReservedNamesProvider : IReservedNamesProvider
         "instanceOf",
         "new",
         "null",
+        "package",
         "return",
         "super",
         "switch",

src/Kiota.Builder/Writers/LanguageWriter.cs

@@ -70,7 +70,15 @@ internal void WriteLine(string line, bool includeIndent = true)
     {
         writer?.WriteLine(includeIndent ? GetIndent() + line : line);
     }
+    internal void WriteLines(IEnumerable<string> lines)
+    {
+        WriteLinesInternal(lines);
+    }
     internal void WriteLines(params string[] lines)
+    {
+        WriteLinesInternal(lines);
+    }
+    private void WriteLinesInternal(IEnumerable<string> lines)
     {
         foreach (var line in lines)
         {

src/Kiota.Builder/Writers/Php/PhpConventionService.cs

@@ -244,7 +244,7 @@ internal void AddParametersAssignment(LanguageWriter writer, CodeTypeBase pathPa
         if (parameters.Any())
             writer.WriteLines(parameters.Select(p =>
                 $"${TempDictionaryVarName}['{p.Item2}'] = {p.Item3};"
-            ).ToArray());
+            ));
     }
 
     private static bool IsSymbolDuplicated(string symbol, CodeElement targetElement)

src/Kiota.Builder/Writers/Python/PythonConventionService.cs

@@ -36,7 +36,7 @@ internal void AddParametersAssignment(LanguageWriter writer, CodeTypeBase? pathP
         if (parameters.Any())
             writer.WriteLines(parameters.Select(p =>
                 $"{TempDictionaryVarName}[\"{p.Item2}\"] = {p.Item3}"
-            ).ToArray());
+            ));
     }
 
     public override string GetAccessModifier(AccessModifier access)

src/Kiota.Builder/Writers/Swift/CodeEnumWriter.cs

@@ -19,8 +19,7 @@ public override void WriteCodeElement(CodeEnum codeElement, LanguageWriter write
         writer.StartBlock($"public enum {codeElement.Name.ToFirstCharacterUpperCase()} : String {{"); //TODO docs
         writer.WriteLines(codeElement.Options
                         .Select(static x => x.Name.ToFirstCharacterUpperCase())
-                        .Select(static (x, idx) => $"case {x}")
-                        .ToArray());
+                        .Select(static (x, idx) => $"case {x}"));
         //TODO static parse function?
         //enum and ns are closed by the code block end writer
     }

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

@@ -1,31 +1,55 @@
 
 
 using System;
-
+using System.Collections.Generic;
+using System.Linq;
 using Kiota.Builder.CodeDOM;
 using Kiota.Builder.Extensions;
 
 namespace Kiota.Builder.Writers.TypeScript;
 
 public class CodeFunctionWriter : BaseElementWriter<CodeFunction, TypeScriptConventionService>
 {
-    private readonly CodeUsingWriter _codeUsingWriter;
     public CodeFunctionWriter(TypeScriptConventionService conventionService, string clientNamespaceName) : base(conventionService)
     {
         _codeUsingWriter = new(clientNamespaceName);
     }
+    private readonly CodeUsingWriter _codeUsingWriter;
+    private static readonly HashSet<string> customSerializationWriters = new(StringComparer.OrdinalIgnoreCase) { "writeObjectValue", "writeCollectionOfObjectValues" };
 
     public override void WriteCodeElement(CodeFunction codeElement, LanguageWriter writer)
     {
         ArgumentNullException.ThrowIfNull(codeElement);
         if (codeElement.OriginalLocalMethod == null) throw new InvalidOperationException($"{nameof(codeElement.OriginalLocalMethod)} should not be null");
         ArgumentNullException.ThrowIfNull(writer);
         if (codeElement.Parent is not CodeNamespace) throw new InvalidOperationException("the parent of a function should be a namespace");
-
-        var returnType = conventions.GetTypeString(codeElement.OriginalLocalMethod.ReturnType, codeElement);
         _codeUsingWriter.WriteCodeElement(codeElement.StartBlock.Usings, codeElement.GetImmediateParentOfType<CodeNamespace>(), writer);
+        var codeMethod = codeElement.OriginalLocalMethod;
+
+        var returnType = codeMethod.Kind != CodeMethodKind.Factory ? conventions.GetTypeString(codeMethod.ReturnType, codeElement) : string.Empty;
         CodeMethodWriter.WriteMethodPrototypeInternal(codeElement.OriginalLocalMethod, writer, returnType, false, conventions, true);
+
         writer.IncreaseIndent();
+
+        switch (codeMethod.Kind)
+        {
+            case CodeMethodKind.Deserializer:
+                WriteDeserializerFunction(codeElement, writer);
+                break;
+            case CodeMethodKind.Serializer:
+                WriteSerializerFunction(codeElement, writer);
+                break;
+            case CodeMethodKind.Factory:
+                WriteDiscriminatorFunction(codeElement, writer);
+                break;
+            default: throw new InvalidOperationException("Invalid code method kind");
+        }
+    }
+
+    private void WriteDiscriminatorFunction(CodeFunction codeElement, LanguageWriter writer)
+    {
+        var returnType = conventions.GetTypeString(codeElement.OriginalLocalMethod.ReturnType, codeElement);
+
         CodeMethodWriter.WriteDefensiveStatements(codeElement.OriginalLocalMethod, writer);
         WriteFactoryMethodBody(codeElement, returnType, writer);
     }
@@ -46,17 +70,179 @@ private void WriteFactoryMethodBody(CodeFunction codeElement, string returnType,
             writer.IncreaseIndent();
             foreach (var mappedType in codeElement.OriginalMethodParentClass.DiscriminatorInformation.DiscriminatorMappings)
             {
-                var typeName = conventions.GetTypeString(mappedType.Value, codeElement, false, writer);
                 writer.WriteLine($"case \"{mappedType.Key}\":");
                 writer.IncreaseIndent();
-                writer.WriteLine($"return new {typeName.ToFirstCharacterUpperCase()}();");
+                writer.WriteLine($"return {getDeserializationFunction(codeElement, mappedType.Value.Name.ToFirstCharacterUpperCase())};");
                 writer.DecreaseIndent();
             }
             writer.CloseBlock();
             writer.CloseBlock();
             writer.CloseBlock();
         }
+        var s = getDeserializationFunction(codeElement, returnType);
+        writer.WriteLine($"return {s.ToFirstCharacterLowerCase()};");
+    }
+
+    private string getDeserializationFunction(CodeElement codeElement, string returnType)
+    {
+        if (codeElement.Parent is not CodeNamespace codeNamespace)
+        {
+            throw new InvalidOperationException($"{codeElement.Name} does not have a parent namespace");
+        }
+        var parent = codeNamespace.FindChildByName<CodeFunction>($"deserializeInto{returnType}");
+
+        return conventions.GetTypeString(new CodeType { TypeDefinition = parent }, codeElement, false);
+    }
+
+    private void WriteSerializerFunction(CodeFunction codeElement, LanguageWriter writer)
+    {
+        var param = codeElement.OriginalLocalMethod.Parameters.FirstOrDefault(static x => x.Type is CodeType type && type.TypeDefinition is CodeInterface);
+        if (param == null || param.Type is not CodeType codeType || codeType.TypeDefinition is not CodeInterface codeInterface)
+            throw new InvalidOperationException("Interface parameter not found for code interface");
+
+        writer.IncreaseIndent();
+
+        if (codeInterface.StartBlock.Implements.FirstOrDefault(static x => x.TypeDefinition is CodeInterface) is CodeType inherits)
+        {
+            writer.WriteLine($"serialize{inherits.TypeDefinition!.Name.ToFirstCharacterUpperCase()}(writer, {param.Name.ToFirstCharacterLowerCase()})");
+        }
+
+        foreach (var otherProp in codeInterface.Properties.Where(static x => x.IsOfKind(CodePropertyKind.Custom) && !x.ExistsInBaseType && !x.ReadOnly))
+        {
+            WritePropertySerializer(codeInterface.Name.ToFirstCharacterLowerCase(), otherProp, writer, codeElement);
+        }
+
+        if (codeInterface.GetPropertyOfKind(CodePropertyKind.AdditionalData) is CodeProperty additionalDataProperty)
+            writer.WriteLine($"writer.writeAdditionalData({codeInterface.Name.ToFirstCharacterLowerCase()}.{additionalDataProperty.Name.ToFirstCharacterLowerCase()});");
+        writer.DecreaseIndent();
+    }
+
+    private static bool IsCodePropertyCollectionOfEnum(CodeProperty property)
+    {
+        return property.Type is CodeType cType && cType.IsCollection && cType.TypeDefinition is CodeEnum;
+    }
+
+    private void WritePropertySerializer(string modelParamName, CodeProperty codeProperty, LanguageWriter writer, CodeFunction codeFunction)
+    {
+        var isCollectionOfEnum = IsCodePropertyCollectionOfEnum(codeProperty);
+        var spreadOperator = isCollectionOfEnum ? "..." : string.Empty;
+        var codePropertyName = codeProperty.Name.ToFirstCharacterLowerCase();
+        var propTypeName = conventions.GetTypeString(codeProperty.Type, codeProperty.Parent!, false);
+
+        var serializationName = GetSerializationMethodName(codeProperty.Type);
+
+        if (customSerializationWriters.Contains(serializationName) && codeProperty.Type is CodeType propType && propType.TypeDefinition is not null)
+        {
+            var serializeName = getSerializerAlias(propType, codeFunction, $"serialize{propType.TypeDefinition.Name}");
+            writer.WriteLine($"writer.{serializationName}<{propTypeName}>(\"{codeProperty.WireName}\", {modelParamName}.{codePropertyName}, {serializeName});");
+        }
+        else
+        {
+            if (!string.IsNullOrWhiteSpace(spreadOperator))
+            {
+                writer.WriteLine($"if({modelParamName}.{codePropertyName})");
+            }
+            writer.WriteLine($"writer.{serializationName}(\"{codeProperty.WireName}\", {spreadOperator}{modelParamName}.{codePropertyName});");
+        }
+    }
+
+    private string GetSerializationMethodName(CodeTypeBase propType)
+    {
+        var propertyType = conventions.TranslateType(propType);
+        if (!string.IsNullOrEmpty(propertyType) && propType is CodeType currentType && GetSerializationMethodNameForCodeType(currentType, propertyType) is string result && !String.IsNullOrWhiteSpace(result))
+        {
+            return result;
+        }
+        return propertyType switch
+        {
+            "string" or "boolean" or "number" or "Guid" or "Date" or "DateOnly" or "TimeOnly" or "Duration" => $"write{propertyType.ToFirstCharacterUpperCase()}Value",
+            _ => $"writeObjectValue",
+        };
+    }
+
+    private static string? GetSerializationMethodNameForCodeType(CodeType propType, string propertyType)
+    {
+        if (propType.TypeDefinition is CodeEnum currentEnum)
+            return $"writeEnumValue<{currentEnum.Name.ToFirstCharacterUpperCase()}>";
+        else if (propType.CollectionKind != CodeTypeBase.CodeTypeCollectionKind.None)
+        {
+            if (propType.TypeDefinition == null)
+                return $"writeCollectionOfPrimitiveValues<{propertyType.ToFirstCharacterLowerCase()}>";
+            else
+                return "writeCollectionOfObjectValues";
+        }
+        return null;
+    }
+
+    private void WriteDeserializerFunction(CodeFunction codeFunction, LanguageWriter writer)
+    {
+        if (codeFunction.OriginalLocalMethod.Parameters.FirstOrDefault() is CodeParameter param && param.Type is CodeType codeType && codeType.TypeDefinition is CodeInterface codeInterface)
+        {
+            var properties = codeInterface.Properties.Where(static x => x.Kind == CodePropertyKind.Custom && !x.ExistsInBaseType);
+
+            writer.StartBlock("return {");
+            if (codeInterface.StartBlock.Implements.FirstOrDefault(x => x.TypeDefinition is CodeInterface) is CodeType type && type.TypeDefinition is CodeInterface inherits)
+            {
+                writer.WriteLine($"...deserializeInto{inherits?.Name.ToFirstCharacterUpperCase()}({param.Name.ToFirstCharacterLowerCase()}),");
+            }
+
+            foreach (var otherProp in properties)
+            {
+                var keyName = !string.IsNullOrWhiteSpace(otherProp.SerializationName) ? otherProp.SerializationName.ToFirstCharacterLowerCase() : otherProp.Name.ToFirstCharacterLowerCase();
+                writer.WriteLine($"\"{keyName}\": n => {{ {param.Name.ToFirstCharacterLowerCase()}.{otherProp.Name.ToFirstCharacterLowerCase()} = n.{GetDeserializationMethodName(otherProp.Type, codeFunction)}; }},");
+            }
+
+            writer.CloseBlock();
+        }
+        else
+            throw new InvalidOperationException($"Model interface for deserializer function {codeFunction.Name} is not available");
+    }
 
-        writer.WriteLine($"return new {returnType.ToFirstCharacterUpperCase()}();");
+    private string GetDeserializationMethodName(CodeTypeBase propType, CodeFunction codeFunction)
+    {
+        var isCollection = propType.CollectionKind != CodeTypeBase.CodeTypeCollectionKind.None;
+        var propertyType = conventions.GetTypeString(propType, codeFunction, false);
+        if (!string.IsNullOrEmpty(propertyType) && propType is CodeType currentType)
+        {
+            if (currentType.TypeDefinition is CodeEnum currentEnum)
+                return $"getEnumValue{(currentEnum.Flags || isCollection ? "s" : string.Empty)}<{currentEnum.Name.ToFirstCharacterUpperCase()}>({propertyType.ToFirstCharacterUpperCase()})";
+            else if (isCollection)
+                if (currentType.TypeDefinition == null)
+                    return $"getCollectionOfPrimitiveValues<{propertyType.ToFirstCharacterLowerCase()}>()";
+                else
+                {
+                    return $"getCollectionOfObjectValues<{propertyType.ToFirstCharacterUpperCase()}>({GetFactoryMethodName(propType, codeFunction.OriginalLocalMethod)})";
+                }
+        }
+        return propertyType switch
+        {
+            "string" or "boolean" or "number" or "Guid" or "Date" or "DateOnly" or "TimeOnly" or "Duration" => $"get{propertyType.ToFirstCharacterUpperCase()}Value()",
+            _ => $"getObjectValue<{propertyType.ToFirstCharacterUpperCase()}>({GetFactoryMethodName(propType, codeFunction.OriginalLocalMethod)})"
+        };
+    }
+
+    private string GetFactoryMethodName(CodeTypeBase targetClassType, CodeMethod currentElement)
+    {
+        if (conventions.TranslateType(targetClassType) is string targetClassName)
+        {
+            var resultName = $"create{targetClassName.ToFirstCharacterUpperCase()}FromDiscriminatorValue";
+            if (conventions.GetTypeString(targetClassType, currentElement, false) is string returnType && targetClassName.EqualsIgnoreCase(returnType)) return resultName;
+            if (targetClassType is CodeType currentType &&
+                currentType.TypeDefinition is CodeInterface definitionClass &&
+                definitionClass.GetImmediateParentOfType<CodeNamespace>() is CodeNamespace parentNamespace &&
+                parentNamespace.FindChildByName<CodeFunction>(resultName) is CodeFunction factoryMethod)
+            {
+                var methodName = conventions.GetTypeString(new CodeType { Name = resultName, TypeDefinition = factoryMethod }, currentElement, false);
+                return methodName.ToFirstCharacterUpperCase();// static function is aliased
+            }
+        }
+        throw new InvalidOperationException($"Unable to find factory method for {targetClassType}");
+    }
+
+    private string? getSerializerAlias(CodeType propType, CodeFunction codeFunction, string propertySerializerName)
+    {
+        if (propType.TypeDefinition?.Parent is not CodeNamespace parentNameSpace) return string.Empty;
+        var serializationFunction = parentNameSpace.FindChildByName<CodeFunction>(propertySerializerName);
+        return conventions.GetTypeString(new CodeType { TypeDefinition = serializationFunction }, codeFunction, false);
     }
 }