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

@@ -132,16 +132,7 @@ public void ApplyLanguageRefinement(GenerationLanguage language, CodeNamespace g
             var stopwatch = new Stopwatch();
             stopwatch.Start();
 
-            // TODO: Refactor into something more scaleable
-            switch (language)
-            {
-                case GenerationLanguage.CSharp:
-                    generatedCode.AddUsing(new CodeUsing() { Name = "System" });
-                    generatedCode.AddUsing(new CodeUsing() { Name = "System.Threading.Tasks" });
-                    break;
-                default:
-                    break; //Do nothing
-            }
+            ILanguageRefiner.Refine(language, generatedCode);
 
             stopwatch.Stop();
             logger.LogInformation("{timestamp}ms: Language refinement applied", stopwatch.ElapsedMilliseconds);
@@ -164,6 +155,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 +216,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 +277,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/Refiners/CSharpRefiner.cs

@@ -0,0 +1,13 @@
+using System.Linq;
+
+namespace kiota.core {
+    public class CSharpRefiner : CommonLanguageRefiner, ILanguageRefiner
+    {
+        public override void Refine(CodeNamespace generatedCode)
+        {
+            generatedCode.AddUsing(new CodeUsing() { Name = "System" });
+            generatedCode.AddUsing(new CodeUsing() { Name = "System.Threading.Tasks" });
+            AddInnerClasses(generatedCode);
+        }
+    }
+}

src/kiota.core/Refiners/CommonLanaguageRefiner.cs

@@ -0,0 +1,17 @@
+using System.Linq;
+
+namespace kiota.core {
+    public abstract class CommonLanguageRefiner : ILanguageRefiner
+    {
+        public abstract void Refine(CodeNamespace generatedCode);
+
+        internal 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);
+        }
+    }
+}

src/kiota.core/Refiners/ILanguageRefiner.cs

@@ -0,0 +1,23 @@
+namespace kiota.core
+{
+    public interface ILanguageRefiner
+    {
+        void Refine(CodeNamespace generatedCode);
+        public static void Refine(GenerationLanguage language, CodeNamespace generatedCode) {
+            switch (language)
+            {
+                case GenerationLanguage.CSharp:
+                    new CSharpRefiner().Refine(generatedCode);
+                    break;
+                case GenerationLanguage.TypeScript:
+                    new TypeScriptRefiner().Refine(generatedCode);
+                    break;
+                case GenerationLanguage.Java:
+                    new JavaRefiner().Refine(generatedCode);
+                    break;
+                default:
+                    break; //Do nothing
+            }
+        }
+    }
+}

src/kiota.core/Refiners/JavaRefiner.cs

@@ -0,0 +1,9 @@
+namespace kiota.core {
+    public class JavaRefiner : CommonLanguageRefiner, ILanguageRefiner
+    {
+        public override void Refine(CodeNamespace generatedCode)
+        {
+            AddInnerClasses(generatedCode);
+        }
+    }
+}

src/kiota.core/Refiners/TypeScriptRefiner.cs

@@ -0,0 +1,24 @@
+using System.Linq;
+
+namespace kiota.core {
+    public class TypeScriptRefiner : ILanguageRefiner
+    {
+        public void Refine(CodeNamespace generatedCode)
+        {
+            AddRelativeImports(generatedCode);
+        }
+        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);
+        }
+    }
+}

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

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using Microsoft.OpenApi.Models;
 
@@ -25,15 +26,17 @@ public void SetTextWriter(TextWriter writer)
         }
 
         public abstract string GetFileSuffix();
-
-        public void IncreaseIndent()
+        private Stack<int> factorStack = new Stack<int>();
+        public void IncreaseIndent(int factor = 1)
         {
-            currentIndent += indentSize;
+            factorStack.Push(factor);
+            currentIndent += indentSize * factor;
         }
 
         public void DecreaseIndent()
         {
-            currentIndent -= indentSize;
+            var factor = factorStack.Pop();
+            currentIndent -= indentSize * factor;
         }
 
         public string GetIndent()
@@ -61,10 +64,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 +87,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);
     }