adds typescript support

.vscode/launch.json

@@ -14,11 +14,11 @@
             "args": ["--openapi",
                  "C:/sources/github/msgraph-sdk-powershell/openApiDocs/v1.0/mail.yml",
                  "--language",
-                 "java",
+                 "typescript",
                  "-o",
-                 "C:/Users/vibiret/Desktop/graphjavav4/utilities/src/main/java/graphjavav4/utilities",
+                 "C:/Users/vibiret/Desktop/graphtypescriptv4/src",
                  "-n",
-                 "graphjavav4.utilities" ],
+                 "graphtypescriptv4.utilities" ],
             "cwd": "${workspaceFolder}/src/kiota",
             // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
             "console": "internalConsole",

src/kiota.core/CodeDOM/CodeBlock.cs

@@ -8,9 +8,9 @@ namespace kiota.core
     /// </summary>
     public class CodeBlock : CodeElement
     {
-        public CodeElement StartBlock;
+        public BlockDeclaration StartBlock = new BlockDeclaration();
         public List<CodeElement> InnerChildElements = new List<CodeElement>();
-        public CodeElement EndBlock;
+        public BlockEnd EndBlock = new BlockEnd();
 
         public override string Name
         {
@@ -24,5 +24,19 @@ public override IList<CodeElement> GetChildElements()
             elements.Add(EndBlock);
             return elements;
         }
+        public void AddUsing(params CodeUsing[] codeUsings)
+        {
+            StartBlock.Usings.AddRange(codeUsings);
+        }
+        public class BlockDeclaration : CodeTerminal
+        {
+            public override string Name { get; set; }
+            public List<CodeUsing> Usings = new List<CodeUsing>();
+        }
+
+        public class BlockEnd : CodeTerminal
+        {
+
+        }
     }
 }

src/kiota.core/CodeDOM/CodeClass.cs

@@ -53,7 +53,7 @@ public void AddInnerClass(CodeClass codeClass)
             this.InnerChildElements.Add(codeClass);
         }
 
-        public class Declaration : CodeTerminal
+        public class Declaration : BlockDeclaration
         {
             /// <summary>
             /// Class name
@@ -66,7 +66,7 @@ public override string Name
             public CodeType Type;
         }
 
-        public class End : CodeTerminal
+        public class End : BlockEnd
         {
         }
     }

src/kiota.core/CodeDOM/CodeNamespace.cs

@@ -8,46 +8,21 @@ namespace kiota.core
     public class CodeNamespace : CodeBlock
     {
         private string name;
-
-        public CodeNamespace()
-        {
-            StartBlock = new Declaration();
-            EndBlock = new End();
-        }
         public override string Name
         {
             get { return name;
             }
             set {
                 name = value;
-                StartBlock = new Declaration() { Name = name };
+                if(StartBlock == null)
+                    StartBlock = new BlockDeclaration();
+                StartBlock.Name = name;
             }
         }
 
         public void AddClass(CodeClass codeClass)
         {
             this.InnerChildElements.Add(codeClass);
         }
-        public void AddUsing(CodeUsing codeUsing)
-        {
-            ((Declaration)this.StartBlock).Usings.Add(codeUsing);
-        }
-        public void AddUsing(IEnumerable<CodeUsing> codeUsings)
-        {
-            foreach (var codeUsing in codeUsings)
-            {
-                ((Declaration)this.StartBlock).Usings.Add(codeUsing);
-            }
-        }
-        public class Declaration : CodeTerminal
-        {
-            public override string Name { get; set; }
-            public List<CodeUsing> Usings = new List<CodeUsing>();
-        }
-
-        public class End : CodeTerminal
-        {
-
-        }
     }
 }

src/kiota.core/CodeDOM/CodeType.cs

@@ -8,6 +8,12 @@ public override string Name
         {
             get; set;
         }
+        public CodeClass TypeDefinition
+        {
+            get;
+            set;
+        }
+
         public bool ActionOf = false;
 
         public OpenApiSchema Schema;

src/kiota.core/CodeRenderer.cs

@@ -35,7 +35,7 @@ public static async Task RenderCodeNamespaceToFilePerClassAsync(LanguageWriter w
                 if (codeClass is not null)
                 {
                     var codeNamespace = new CodeNamespace() { Name = root.Name };
-                    codeNamespace.AddUsing(((CodeNamespace.Declaration)root.StartBlock).Usings);
+                    codeNamespace.AddUsing(root.StartBlock.Usings.ToArray());
                     codeNamespace.AddClass(codeClass);
                     await RenderCodeNamespaceToSingleFileAsync(writer, codeNamespace, Path.Combine(outputPath, codeClass.Name + writer.GetFileSuffix()));
                 }

src/kiota.core/KiotaBuilder.cs

@@ -138,6 +138,10 @@ public void ApplyLanguageRefinement(GenerationLanguage language, CodeNamespace g
                 case GenerationLanguage.CSharp:
                     generatedCode.AddUsing(new CodeUsing() { Name = "System" });
                     generatedCode.AddUsing(new CodeUsing() { Name = "System.Threading.Tasks" });
+                    AddInnerClasses(generatedCode);
+                    break;
+                case GenerationLanguage.TypeScript:
+                    AddRelativeImports(generatedCode);
                     break;
                 default:
                     break; //Do nothing
@@ -147,6 +151,28 @@ public void ApplyLanguageRefinement(GenerationLanguage language, CodeNamespace g
             logger.LogInformation("{timestamp}ms: Language refinement applied", stopwatch.ElapsedMilliseconds);
         }
 
+        private void AddRelativeImports(CodeElement current) {
+            if(current is CodeClass currentClass) {
+                currentClass.AddUsing(current
+                                    .GetChildElements()
+                                    .OfType<CodeProperty>()
+                                    .Select(x =>x.Type.Name)
+                                    .Distinct()
+                                    .Select(x => new CodeUsing{Name = x})
+                                    .ToArray());
+            }
+            foreach(var childClass in current.GetChildElements().OfType<CodeClass>())
+                AddRelativeImports(childClass);
+        }
+        private void AddInnerClasses(CodeElement current) {
+            if(current is CodeClass currentClass) {
+                foreach(var parameter in current.GetChildElements().OfType<CodeMethod>().SelectMany(x =>x.Parameters).Where(x => x.Type.ActionOf))
+                    currentClass.AddInnerClass(parameter.Type.TypeDefinition);
+            }
+            foreach(var childClass in current.GetChildElements().OfType<CodeClass>())
+                AddInnerClasses(childClass);
+        }
+
         /// <summary>
         /// Iterate through Url Space and create request builder classes for each node in the tree
         /// </summary>
@@ -164,6 +190,9 @@ public async Task CreateLanguageSourceFilesAsync(GenerationLanguage language, Co
                 case GenerationLanguage.Java:
                     languageWriter = new JavaWriter();
                     break;
+                case GenerationLanguage.TypeScript:
+                    languageWriter = new TypeScriptWriter();
+                    break;
                 default:
                     throw new ArgumentException($"{language} language currently not supported.");
             }
@@ -222,7 +251,6 @@ private void CreateClass(CodeNamespace codeNamespace, OpenApiUrlSpaceNode node)
                 foreach(var operation in node.PathItem.Operations)
                 {
                     var parameterClass = CreateOperationParameter(node, operation);
-                    codeClass.AddInnerClass(parameterClass);
 
                     var method = CreateOperationMethod(operation.Key, operation.Value, parameterClass);
                     logger.LogDebug("Creating method {name} of {type}", method.Name, method.ReturnType);
@@ -284,7 +312,7 @@ private CodeMethod CreateOperationMethod(OperationType operationType, OpenApiOpe
             var methodParameter = new CodeParameter()
             {
                 Name = "q",
-                Type = new CodeType() { Name = parameterClass.Name, ActionOf = true }
+                Type = new CodeType() { Name = parameterClass.Name, ActionOf = true, TypeDefinition = parameterClass }
             };
             method.AddParameter(methodParameter);
             return method;

src/kiota.core/Writers/CSharpWriter.cs

@@ -6,13 +6,13 @@ namespace kiota.core
     public class CSharpWriter : LanguageWriter
     {
 
-        public override void WriteNamespaceEnd(CodeNamespace.End code)
+        public override void WriteNamespaceEnd(CodeNamespace.BlockEnd code)
         {
             DecreaseIndent();
             WriteLine("}");
         }
 
-        public override void WriteNamespaceDeclaration(CodeNamespace.Declaration code)
+        public override void WriteNamespaceDeclaration(CodeNamespace.BlockDeclaration code)
         {
             foreach (var codeUsing in code.Usings)
             {

src/kiota.core/Writers/JavaWriter.cs

@@ -75,7 +75,7 @@ public override void WriteMethod(CodeMethod code)
             WriteLine($"public java.util.concurrent.Future<{GetTypeString(code.ReturnType)}> {code.Name}({string.Join(',', code.Parameters.Select(p=> GetParameterSignature(p)).ToList())}) {{ return null; }}");
         }
 
-        public override void WriteNamespaceDeclaration(CodeNamespace.Declaration code)
+        public override void WriteNamespaceDeclaration(CodeNamespace.BlockDeclaration code)
         {
             WriteLine($"package {code.Name};");
             WriteLine();
@@ -85,7 +85,7 @@ public override void WriteNamespaceDeclaration(CodeNamespace.Declaration code)
             }
         }
 
-        public override void WriteNamespaceEnd(CodeNamespace.End code) => WriteLine();
+        public override void WriteNamespaceEnd(CodeNamespace.BlockEnd code) => WriteLine();
 
         public override void WriteProperty(CodeProperty code)
         {

src/kiota.core/Writers/LanguageWriter.cs

@@ -26,14 +26,14 @@ public void SetTextWriter(TextWriter writer)
 
         public abstract string GetFileSuffix();
 
-        public void IncreaseIndent()
+        public void IncreaseIndent(int factor = 1)
         {
-            currentIndent += indentSize;
+            currentIndent += indentSize * factor;
         }
 
-        public void DecreaseIndent()
+        public void DecreaseIndent(int factor = 1)
         {
-            currentIndent -= indentSize;
+            currentIndent -= indentSize * factor;
         }
 
         public string GetIndent()
@@ -61,10 +61,10 @@ public void Write(CodeElement code)
         {
             switch (code)
             {
-                case CodeNamespace.Declaration c: WriteNamespaceDeclaration(c); break;
-                case CodeNamespace.End c: WriteNamespaceEnd(c); break;
                 case CodeClass.Declaration c: WriteCodeClassDeclaration(c); break;
                 case CodeClass.End c: WriteCodeClassEnd(c); break;
+                case CodeNamespace.BlockDeclaration c: WriteNamespaceDeclaration(c); break;
+                case CodeNamespace.BlockEnd c: WriteNamespaceEnd(c); break;
                 case CodeProperty c: WriteProperty(c); break;
                 case CodeIndexer c: WriteIndexer(c); break;
                 case CodeMethod c: WriteMethod(c); break;
@@ -84,8 +84,8 @@ public void Write(CodeElement code)
         public abstract void WriteIndexer(CodeIndexer code);
         public abstract void WriteMethod(CodeMethod code);
         public abstract void WriteType(CodeType code);
-        public abstract void WriteNamespaceEnd(CodeNamespace.End code);
-        public abstract void WriteNamespaceDeclaration(CodeNamespace.Declaration code);
+        public abstract void WriteNamespaceEnd(CodeNamespace.BlockEnd code);
+        public abstract void WriteNamespaceDeclaration(CodeNamespace.BlockDeclaration code);
         public abstract void WriteCodeClassDeclaration(CodeClass.Declaration code);
         public abstract void WriteCodeClassEnd(CodeClass.End code);
     }

src/kiota.core/Writers/TypeScriptWriter.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.OpenApi.Models;
+
+namespace kiota.core
+{
+    public class TypeScriptWriter : LanguageWriter
+    {
+        public override string GetFileSuffix() => ".ts";
+
+        public override string GetParameterSignature(CodeParameter parameter)
+        {
+            return $"{parameter.Name}{(parameter.Optional ? "?" : string.Empty)}: {GetTypeString(parameter.Type)}{(parameter.Optional ? " | undefined": string.Empty)}";
+        }
+
+        public override string GetTypeString(CodeType code)
+        {
+            var typeName = TranslateType(code.Name, code.Schema);
+            if (code.ActionOf)
+            {
+                var indentFactor = 4;
+                IncreaseIndent(indentFactor);
+                var childElements = code.TypeDefinition
+                                            .InnerChildElements
+                                            .OfType<CodeProperty>()
+                                            .Select(x => $"{x.Name}?: {GetTypeString(x.Type)}");
+                var innerDeclaration = childElements.Any() ? childElements
+                                            .Aggregate((x, y) => $"{x};{Environment.NewLine}{GetIndent()}{y}")
+                                            : string.Empty;
+                DecreaseIndent(indentFactor);
+                return $"(options?: {{{innerDeclaration}}}) => void";
+            }
+            else
+            {
+                return typeName;
+            }
+        }
+
+        public override string TranslateType(string typeName, OpenApiSchema schema)
+        {
+            switch (typeName)
+            {//TODO we're probably missing a bunch of type mappings
+                case "integer": return "number";
+                case "array": return $"{TranslateType(schema.Items.Type, schema.Items)}[]";
+            } // string, boolean, object : same casing
+
+            return typeName;
+        }
+
+        public override void WriteCodeClassDeclaration(CodeClass.Declaration code)
+        {
+            foreach (var codeUsing in code.Usings)
+            {
+                WriteLine($"import {{{codeUsing.Name}}} from './{codeUsing.Name}';");
+            }
+            WriteLine();
+            WriteLine($"export class {code.Name} {{");
+            IncreaseIndent();
+        }
+
+        public override void WriteCodeClassEnd(CodeClass.End code)
+        {
+            DecreaseIndent();
+            WriteLine("}");
+        }
+
+        public override void WriteIndexer(CodeIndexer code)
+        {
+            WriteMethod(new CodeMethod {
+                Name = "get",
+                Parameters = new List<CodeParameter> {
+                    new CodeParameter {
+                        Name = "position",
+                        Type = code.IndexType,
+                        Optional = false,
+                    }
+                },
+                ReturnType = code.IndexType
+            });
+        }
+
+        public override void WriteMethod(CodeMethod code)
+        {
+            WriteLine($"public readonly {code.Name} = ({string.Join(',', code.Parameters.Select(p=> GetParameterSignature(p)).ToList())}) : Promise<{GetTypeString(code.ReturnType)}> => {{ return Promise.resolve({(code.ReturnType.Name.Equals("string") ? "''" : "{}")}); }}");
+        }
+
+        public override void WriteNamespaceDeclaration(CodeNamespace.BlockDeclaration code) => WriteLine();
+
+        public override void WriteNamespaceEnd(CodeNamespace.BlockEnd code) => WriteLine();
+
+        public override void WriteProperty(CodeProperty code)
+        {
+            WriteLine($"public {code.Name}?: {GetTypeString(code.Type)}");
+        }
+
+        public override void WriteType(CodeType code)
+        {
+            Write(GetTypeString(code), includeIndent: false);
+        }
+    }
+}