Typescript - introducing index files namespace wise fixing circular dependency

src/Kiota.Builder/CodeDOM/CodeNamespace.cs

@@ -39,6 +39,7 @@ 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 CodeNamespace FindNamespaceByName(string nsName) {
             if(string.IsNullOrEmpty(nsName)) throw new ArgumentNullException(nameof(nsName));
             if(nsName.Equals(Name)) return this;

src/Kiota.Builder/CodeRenderer.cs

@@ -42,9 +42,14 @@ public async Task RenderCodeNamespaceToFilePerClassAsync(LanguageWriter writer,
                     {
                         var namespaceNameLastSegment = codeNamespace.Name.Split('.').Last().ToLowerInvariant();
                         // if the module already has a class with the same name, it's going to be declared automatically
-                        if (_configuration.ShouldWriteBarrelsIfClassExists ||
-                            codeNamespace.FindChildByName<CodeClass>(namespaceNameLastSegment, false) == null)
+                        if (_configuration.ShouldWriteBarrelsIfClassExists && _configuration.setCodeRenderingCondition(codeNamespace))
+                         // TODO : Verify and plug the following condition in the language specific index rendering condition 
+                        //codeNamespace.FindChildByName<CodeClass>(namespaceNameLastSegment, false) == null)
+
+                        {
                             await RenderCodeNamespaceToSingleFileAsync(writer, codeNamespace, writer.PathSegmenter.GetPath(root, codeNamespace));
+                        }
+
                     }
                     await RenderCodeNamespaceToFilePerClassAsync(writer, codeNamespace);
                 }

src/Kiota.Builder/GenerationConfiguration.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace Kiota.Builder {
     public class GenerationConfiguration {
@@ -22,9 +23,15 @@ public class GenerationConfiguration {
         private static readonly HashSet<GenerationLanguage> BarreledLanguages = new () {
             GenerationLanguage.Ruby,
             // TODO: add typescript once we have a barrel writer for it
+           GenerationLanguage.TypeScript
         };
         private static readonly HashSet<GenerationLanguage> BarreledLanguagesWithConstantFileName = new () {
             //TODO: add typescript once we have a barrel writer for it
+
+          GenerationLanguage.TypeScript
         };
+
+        public Func<CodeNamespace, bool>  setCodeRenderingCondition;
+
     }
 }

src/Kiota.Builder/Refiners/RubyRefiner.cs

@@ -30,6 +30,17 @@ public override void Refine(CodeNamespace generatedCode)
                                         new [] { "microsoft_kiota_abstractions.ApiClientBuilder",
                                                 "microsoft_kiota_abstractions.SerializationWriterFactoryRegistry" },
                                         new [] { "microsoft_kiota_abstractions.ParseNodeFactoryRegistry" });
+            setNameSpaceRenderingCondition(_configuration);
+        }
+
+        private static void setNameSpaceRenderingCondition(GenerationConfiguration configuration)
+        {
+            configuration.setCodeRenderingCondition = RenderNamespace;
+        }
+        // TODO : Update this condition
+        public static bool RenderNamespace(CodeNamespace codeNamespace)
+        {
+            return (codeNamespace.Classes.Any() || codeNamespace.Enums.Any());
         }
         private static void CorrectPropertyType(CodeProperty currentProperty) {
             if(currentProperty.IsOfKind(CodePropertyKind.PathParameters)) {

src/Kiota.Builder/Writers/RelativeImportManager.cs

@@ -1,17 +1,19 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Kiota.Builder.Extensions;
 
-namespace Kiota.Builder.Writers {
-    public class RelativeImportManager {
+namespace Kiota.Builder.Writers
+{
+    public class RelativeImportManager
+    {
         private readonly int prefixLength;
         private readonly char separator;
         public RelativeImportManager(string namespacePrefix, char namespaceSeparator)
         {
-            if(string.IsNullOrEmpty(namespacePrefix))
+            if (string.IsNullOrEmpty(namespacePrefix))
                 throw new ArgumentNullException(nameof(namespacePrefix));
-            if(namespaceSeparator == default)
+            if (namespaceSeparator == default)
                 throw new ArgumentNullException(nameof(namespaceSeparator));
 
             prefixLength = namespacePrefix.Length;
@@ -23,36 +25,44 @@ public RelativeImportManager(string namespacePrefix, char namespaceSeparator)
         /// <param name="codeUsing">The using to import into the current namespace context</param>
         /// <param name="currentNamespace">The current namespace</param>
         /// <returns>The import symbol, it's alias if any and the relative import path</returns>
-        public (string, string, string) GetRelativeImportPathForUsing(CodeUsing codeUsing, CodeNamespace currentNamespace) {
-            if(codeUsing?.IsExternal ?? true)
+        public (string, string, string) GetRelativeImportPathForUsing(CodeUsing codeUsing, CodeNamespace currentNamespace)
+        {
+            if (codeUsing?.IsExternal ?? true)
                 return (string.Empty, string.Empty, string.Empty);//it's an external import, add nothing
             var typeDef = codeUsing.Declaration.TypeDefinition;
 
             var importSymbol = codeUsing.Declaration?.Name?.ToFirstCharacterUpperCase() ?? codeUsing.Name;
 
-            if(typeDef == null)
+            if (typeDef == null)
                 return (importSymbol, codeUsing.Alias, "./"); // it's relative to the folder, with no declaration (default failsafe)
-            else {
-                var importPath = GetImportRelativePathFromNamespaces(currentNamespace, 
+            else
+            {
+                var importPath = GetImportRelativePathFromNamespaces(currentNamespace,
                                                         typeDef.GetImmediateParentOfType<CodeNamespace>());
-                if(string.IsNullOrEmpty(importPath))
-                    importPath+= codeUsing.Name;
-                else
-                    importPath+= codeUsing.Declaration.Name.ToFirstCharacterLowerCase();
+                if (importPath == "./")
+                {
+                    importPath += "index";
+                }
+                else if (string.IsNullOrEmpty(importPath))
+                {
+                    importPath += codeUsing.Name;
+                }
                 return (importSymbol, codeUsing.Alias, importPath);
             }
         }
-        private string GetImportRelativePathFromNamespaces(CodeNamespace currentNamespace, CodeNamespace importNamespace) {
-            if(currentNamespace == null)
+        private string GetImportRelativePathFromNamespaces(CodeNamespace currentNamespace, CodeNamespace importNamespace)
+        {
+            if (currentNamespace == null)
                 throw new ArgumentNullException(nameof(currentNamespace));
             else if (importNamespace == null)
                 throw new ArgumentNullException(nameof(importNamespace));
-            else if(currentNamespace == importNamespace || currentNamespace.Name.Equals(importNamespace.Name, StringComparison.OrdinalIgnoreCase)) // we're in the same namespace
+            else if (currentNamespace == importNamespace || currentNamespace.Name.Equals(importNamespace.Name, StringComparison.OrdinalIgnoreCase)) // we're in the same namespace
                 return "./";
             else
-                return GetRelativeImportPathFromSegments(currentNamespace, importNamespace);                
+                return GetRelativeImportPathFromSegments(currentNamespace, importNamespace);
         }
-        private string GetRelativeImportPathFromSegments(CodeNamespace currentNamespace, CodeNamespace importNamespace) {
+        private string GetRelativeImportPathFromSegments(CodeNamespace currentNamespace, CodeNamespace importNamespace)
+        {
             var currentNamespaceSegments = currentNamespace
                                     .Name[prefixLength..]
                                     .Split(separator, StringSplitOptions.RemoveEmptyEntries);
@@ -62,24 +72,29 @@ private string GetRelativeImportPathFromSegments(CodeNamespace currentNamespace,
             var importNamespaceSegmentsCount = importNamespaceSegments.Length;
             var currentNamespaceSegmentsCount = currentNamespaceSegments.Length;
             var deeperMostSegmentIndex = 0;
-            while(deeperMostSegmentIndex < Math.Min(importNamespaceSegmentsCount, currentNamespaceSegmentsCount)) {
-                if(currentNamespaceSegments.ElementAt(deeperMostSegmentIndex).Equals(importNamespaceSegments.ElementAt(deeperMostSegmentIndex), StringComparison.OrdinalIgnoreCase))
+            while (deeperMostSegmentIndex < Math.Min(importNamespaceSegmentsCount, currentNamespaceSegmentsCount))
+            {
+                if (currentNamespaceSegments.ElementAt(deeperMostSegmentIndex).Equals(importNamespaceSegments.ElementAt(deeperMostSegmentIndex), StringComparison.OrdinalIgnoreCase))
                     deeperMostSegmentIndex++;
                 else
                     break;
             }
-            if (deeperMostSegmentIndex == currentNamespaceSegmentsCount) { // we're in a parent namespace and need to import with a relative path
+            if (deeperMostSegmentIndex == currentNamespaceSegmentsCount)
+            { // we're in a parent namespace and need to import with a relative path
                 return "./" + GetRemainingImportPath(importNamespaceSegments.Skip(deeperMostSegmentIndex));
-            } else { // we're in a sub namespace and need to go "up" with dot dots
+            }
+            else
+            { // we're in a sub namespace and need to go "up" with dot dots
                 var upMoves = currentNamespaceSegmentsCount - deeperMostSegmentIndex;
                 var pathSegmentSeparator = upMoves > 0 ? "/" : string.Empty;
                 return string.Join("/", Enumerable.Repeat("..", upMoves)) +
                         pathSegmentSeparator +
                         GetRemainingImportPath(importNamespaceSegments.Skip(deeperMostSegmentIndex));
             }
         }
-        private static string GetRemainingImportPath(IEnumerable<string> remainingSegments) {
-            if(remainingSegments.Any())
+        private static string GetRemainingImportPath(IEnumerable<string> remainingSegments)
+        {
+            if (remainingSegments.Any())
                 return remainingSegments.Select(x => x.ToFirstCharacterLowerCase()).Aggregate((x, y) => $"{x}/{y}") + '/';
             else
                 return string.Empty;

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

@@ -0,0 +1,115 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Kiota.Builder.Writers.TypeScript
+{
+    public class CodeNameSpaceWriter : BaseElementWriter<CodeNamespace, TypeScriptConventionService>
+    {
+        public CodeNameSpaceWriter(TypeScriptConventionService conventionService) : base(conventionService) { }
+
+        /// <summary>
+        /// Writes export statements for classes and enums belonging to a namespace into a generated index.ts file. 
+        /// The classes should be export in the order of inheritance so as to avoid circular dependency issues in javascript.
+        /// </summary>
+        /// <param name="codeElement">Code element is a code namespace</param>
+        /// <param name="writer"></param>
+        public override void WriteCodeElement(CodeNamespace codeElement, LanguageWriter writer)
+        {
+            var sortedClassNames = SortClassesInOrderOfInheritance(codeElement.Classes.ToList());
+
+            foreach (var className in sortedClassNames)
+            {
+                writer.WriteLine($"export * from './{className}'");
+            }
+
+            var enums = codeElement.Enums;
+            if (enums != null && enums.Any())
+            {
+                foreach (var e in enums)
+                {
+                    writer.WriteLine($"export * from './{e.Name}'");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Visits every child for a given parent class and recursively inserts each class into a list ordered based on inheritance.
+        /// </summary>
+        /// <param name="parentListChildren"></param>
+        /// <param name="visited"></param>
+        /// <param name="orderedList"> Lis</param>
+        /// <param name="current"></param>
+        private void VisitEveryChild(Dictionary<string, List<string>> parentChildrenMap, HashSet<string> visited, List<string> inheritanceOrderList, string current)
+        {
+            if (!visited.Contains(current))
+            {
+                visited.Add(current);
+
+                foreach (var child in parentChildrenMap[current])
+                {
+                    if (parentChildrenMap.ContainsKey(child))
+                    {
+                        VisitEveryChild(parentChildrenMap, visited, inheritanceOrderList, child);
+
+                    }
+                }
+                inheritanceOrderList.Insert(0, current);
+            }
+        }
+
+        /// <summary>
+        /// Orders given list of classes in a namespace based on inheritance.
+        /// That is, if class B extends class A then A should exported before class B.
+        /// </summary>
+        /// <param name="classes"> Classes in a given code namespace</param>
+        /// <returns> List of class names in the code name space ordered based on inheritance</returns>
+        private List<string> SortClassesInOrderOfInheritance(List<CodeClass> classes)
+        {
+            var visited = new HashSet<string>();
+            var parentChildrenMap = new Dictionary<string, List<string>>();
+            var inheritanceOrderList = new List<string>();
+
+            /*
+             * 1. Create a dictionary containing all the parent classes.
+             */
+            foreach (var @class in classes)
+            {
+                var usings = @class.StartBlock as CodeClass.Declaration;
+
+                // Verify if parent class is from the same namespace
+                var inheritsFrom = usings?.Inherits?.TypeDefinition.Parent.Name == @class.Parent.Name ? usings.Inherits.Name : null;
+
+                if (inheritsFrom != null)
+                {
+                    if (!parentChildrenMap.ContainsKey(inheritsFrom))
+                    {
+                        parentChildrenMap[inheritsFrom] = new List<string>();
+                    }
+                    parentChildrenMap[inheritsFrom].Add(@class.Name);
+
+                }
+            }
+
+            /*
+             * 2. Print the export command for every parent node before the child node.
+             */
+            foreach (var key in parentChildrenMap.Keys)
+            {
+                VisitEveryChild(parentChildrenMap, visited, inheritanceOrderList, key);
+            }
+
+            /*
+             * 3. Print all remaining classes which have not been visted or those do not have any parent/child relationship.
+             */
+            foreach (var @class in classes)
+            {
+                if (!visited.Contains(@class.Name))
+                {
+                    visited.Add(@class.Name);
+                    inheritanceOrderList.Add(@class.Name);
+                }
+            }
+            return inheritanceOrderList;
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-namespace Kiota.Builder.Writers.TypeScript
+namespace Kiota.Builder.Writers.TypeScript
 {
     public class TypeScriptWriter : LanguageWriter
     {
@@ -12,6 +12,7 @@ public TypeScriptWriter(string rootPath, string clientNamespaceName)
             AddOrReplaceCodeElementWriter(new CodeMethodWriter(conventionService));
             AddOrReplaceCodeElementWriter(new CodePropertyWriter(conventionService));
             AddOrReplaceCodeElementWriter(new CodeTypeWriter(conventionService));
+            AddOrReplaceCodeElementWriter(new CodeNameSpaceWriter(conventionService));
         }
     }
 }