Fixing TypeScript compilation output path issue (#1520)

Author: fabiocav

src/WebJobs.Script/Description/Node/Compilation/JavaScriptCompilationServiceFactory.cs

@@ -4,13 +4,25 @@
 using System;
 using System.Collections.Immutable;
 using System.Globalization;
+using System.IO;
+using System.Linq;
+using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Description.Node.TypeScript;
 
 namespace Microsoft.Azure.WebJobs.Script.Description
 {
     public class JavaScriptCompilationServiceFactory : ICompilationServiceFactory<ICompilationService<IJavaScriptCompilation>, FunctionMetadata>
     {
+        private const string TypeScriptToolName = "tsc.exe";
         private static readonly ImmutableArray<ScriptType> SupportedScriptTypes = new[] { ScriptType.Javascript, ScriptType.TypeScript }.ToImmutableArray();
+        private readonly ScriptHost _host;
+        private readonly Lazy<TypeScriptCompilationOptions> _typeScriptOptions;
+
+        public JavaScriptCompilationServiceFactory(ScriptHost host)
+        {
+            _host = host;
+            _typeScriptOptions = new Lazy<TypeScriptCompilationOptions>(CreateTypeScriptCompilationOptions);
+        }
 
         ImmutableArray<ScriptType> ICompilationServiceFactory<ICompilationService<IJavaScriptCompilation>, FunctionMetadata>.SupportedScriptTypes => SupportedScriptTypes;
 
@@ -21,11 +33,40 @@ public ICompilationService<IJavaScriptCompilation> CreateService(ScriptType scri
                 case ScriptType.Javascript:
                     return new RawJavaScriptCompilationService(metadata);
                 case ScriptType.TypeScript:
-                    return new TypeScriptCompilationService();
+                    return new TypeScriptCompilationService(_typeScriptOptions.Value);
                 default:
                     throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture,
                         "The script type {0} is not supported by the {1}", scriptType, typeof(JavaScriptCompilationServiceFactory).Name));
             }
         }
+
+        private TypeScriptCompilationOptions CreateTypeScriptCompilationOptions()
+        {
+            return new TypeScriptCompilationOptions
+            {
+                ToolPath = GetTypeScriptToolPath(),
+                OutDir = ".output",
+                RootDir = _host.ScriptConfig.RootScriptPath
+            };
+        }
+
+        private static string GetTypeScriptToolPath()
+        {
+            string path = ScriptSettingsManager.Instance.GetSetting(EnvironmentSettingNames.TypeScriptCompilerPath);
+            if (path == null)
+            {
+                string basePath = Path.Combine(Environment.ExpandEnvironmentVariables("%programfiles(x86)%"), "Microsoft SDKs\\TypeScript");
+                if (Directory.Exists(basePath))
+                {
+                    path = Directory.GetDirectories(basePath)
+                        .OrderByDescending(d => d)
+                        .FirstOrDefault() ?? string.Empty;
+
+                    path = Path.Combine(path, TypeScriptToolName);
+                }
+            }
+
+            return path ?? TypeScriptToolName;
+        }
     }
 }

src/WebJobs.Script/Description/Node/Compilation/TypeScript/ITypeScriptCompiler.cs

@@ -0,0 +1,19 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Azure.WebJobs.Script.Description.Node.TypeScript;
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.Azure.WebJobs.Script.Description.Node.TypeScript
+{
+    public interface ITypeScriptCompiler
+    {
+        Task<ImmutableArray<Diagnostic>> CompileAsync(string inputFile, TypeScriptCompilationOptions options);
+    }
+}

src/WebJobs.Script/Description/Node/Compilation/TypeScript/TypeScriptCompilation.cs

@@ -4,116 +4,39 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Scripting;
-using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.Azure.WebJobs.Script.Description.Node.TypeScript
 {
     public class TypeScriptCompilation : IJavaScriptCompilation
     {
-        private static readonly Regex DiagnosticRegex = new Regex("^(.*.ts)\\((\\d*),(\\d*)\\): (\\w*) (TS[0-9]{0,4}): (.*)$", RegexOptions.Compiled);
+        private static readonly Lazy<ITypeScriptCompiler> _defaultCompiler = new Lazy<ITypeScriptCompiler>(() => new TypeScriptCompiler(), LazyThreadSafetyMode.ExecutionAndPublication);
+
         private readonly string _inputFilePath;
         private readonly TypeScriptCompilationOptions _options;
         private readonly List<Diagnostic> _diagnostics = new List<Diagnostic>();
+        private readonly ITypeScriptCompiler _compiler;
 
-        private TypeScriptCompilation(string inputFilePath, TypeScriptCompilationOptions options)
+        private TypeScriptCompilation(string inputFilePath, TypeScriptCompilationOptions options, ITypeScriptCompiler compiler)
         {
+            _compiler = compiler;
             _inputFilePath = inputFilePath;
             _options = options;
         }
 
         public bool SupportsDiagnostics => true;
 
-        private Task CompileAsync()
+        private async Task CompileAsync()
         {
-            var tcs = new TaskCompletionSource<object>();
-
-            try
-            {
-                string inputDirectory = Path.GetDirectoryName(_inputFilePath);
-
-                var startInfo = new ProcessStartInfo
-                {
-                    FileName = _options.ToolPath,
-                    RedirectStandardOutput = true,
-                    RedirectStandardError = true,
-                    CreateNoWindow = true,
-                    UseShellExecute = false,
-                    ErrorDialog = false,
-                    WorkingDirectory = inputDirectory,
-                    Arguments = _options.ToArgumentString(_inputFilePath)
-                };
-
-                var process = new Process { StartInfo = startInfo };
-                process.ErrorDataReceived += ProcessDataReceived;
-                process.OutputDataReceived += ProcessDataReceived;
-                process.EnableRaisingEvents = true;
-                process.Exited += (s, e) =>
-                {
-                    process.WaitForExit();
-                    process.Close();
-
-                    if (_diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
-                    {
-                        tcs.SetException(new CompilationErrorException("Compilation failed.", GetDiagnostics()));
-                    }
-                    else
-                    {
-                        tcs.SetResult(null);
-                    }
-                };
-
-                process.Start();
-
-                process.BeginErrorReadLine();
-                process.BeginOutputReadLine();
-            }
-            catch (Exception exc)
-            {
-                tcs.SetException(exc);
-            }
-
-            return tcs.Task;
-        }
-
-        private void ProcessDataReceived(object sender, DataReceivedEventArgs e)
-        {
-            if (e.Data != null && TryParseDiagnostic(e.Data, out Diagnostic diagnostic))
-            {
-                _diagnostics.Add(diagnostic);
-            }
-        }
-
-        internal static bool TryParseDiagnostic(string data, out Diagnostic diagnostic)
-        {
-            diagnostic = null;
-            Match match = DiagnosticRegex.Match(data);
-
-            if (match.Success)
-            {
-                DiagnosticSeverity severity = (DiagnosticSeverity)Enum.Parse(typeof(DiagnosticSeverity), match.Groups[4].Value, true);
-                var descriptor = new DiagnosticDescriptor(match.Groups[5].Value, match.Groups[6].Value, match.Groups[6].Value, string.Empty, severity, true);
-                int line = int.Parse(match.Groups[2].Value) - 1;
-                int column = int.Parse(match.Groups[3].Value) - 1;
-                var linePosition = new LinePosition(line, column);
-                var location = Location.Create(match.Groups[1].Value, new TextSpan(linePosition.Line, 0), new LinePositionSpan(linePosition, linePosition));
-
-                diagnostic = Diagnostic.Create(descriptor, location);
-            }
-
-            return diagnostic != null;
+          var diagnostics = await _compiler.CompileAsync(_inputFilePath, _options);
         }
 
-        public static async Task<TypeScriptCompilation> CompileAsync(string inputFile, TypeScriptCompilationOptions options)
+        public static async Task<TypeScriptCompilation> CompileAsync(string inputFile, TypeScriptCompilationOptions options, ITypeScriptCompiler compiler = null)
         {
-            var compilation = new TypeScriptCompilation(inputFile, options);
+            var compilation = new TypeScriptCompilation(inputFile, options, compiler ?? _defaultCompiler.Value);
             await compilation.CompileAsync();
 
             return compilation;
@@ -125,10 +48,10 @@ public static async Task<TypeScriptCompilation> CompileAsync(string inputFile, T
 
         public string Emit(CancellationToken cancellationToken)
         {
-            string inputFilePath = Path.GetDirectoryName(_inputFilePath);
-            string outputFileName = Path.GetFileNameWithoutExtension(_inputFilePath) + ".js";
+            string relativeInputFilePath = FileUtility.GetRelativePath(_options.RootDir, _inputFilePath);
+            string outputFileName = Path.ChangeExtension(relativeInputFilePath, ".js");
 
-            return Path.Combine(inputFilePath, _options.OutDir, outputFileName);
+            return Path.Combine(Path.GetDirectoryName(_inputFilePath), _options.OutDir, outputFileName);
         }
     }
 }

src/WebJobs.Script/Description/Node/Compilation/TypeScript/TypeScriptCompilationOptions.cs

@@ -2,12 +2,14 @@
 // Licensed under the MIT License. See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace Microsoft.Azure.WebJobs.Script.Description.Node.TypeScript
 {
+    [DebuggerDisplay("{DebuggerDisplay, nq}")]
     public class TypeScriptCompilationOptions
     {
         private readonly Dictionary<string, CompilationOption> _options = new Dictionary<string, CompilationOption>();
@@ -41,6 +43,14 @@ public string OutDir
             internal set => SetOption(value);
         }
 
+        public string RootDir
+        {
+            get => GetOption<StringCompilationOption>()?.Value;
+            internal set => SetOption(value);
+        }
+
+        private string DebuggerDisplay => ToArgumentString("<filename>");
+
         private static string GetOptionName(string name)
         {
             return name?.ToLowerInvariant();

src/WebJobs.Script/Description/Node/Compilation/TypeScript/TypeScriptCompilationService.cs

@@ -12,16 +12,11 @@ namespace Microsoft.Azure.WebJobs.Script.Description.Node.TypeScript
 {
     public class TypeScriptCompilationService : ICompilationService<IJavaScriptCompilation>
     {
-        private const string DefaultToolName = "tsc.exe";
-        private static readonly TypeScriptCompilationOptions DefaultCompilationOptions;
+        private readonly TypeScriptCompilationOptions _compilationOptions;
 
-        static TypeScriptCompilationService()
+        public TypeScriptCompilationService(TypeScriptCompilationOptions compilationOptions)
         {
-            DefaultCompilationOptions = new TypeScriptCompilationOptions
-            {
-                ToolPath = GetToolPath(),
-                OutDir = ".output"
-            };
+            _compilationOptions = compilationOptions;
         }
 
         public string Language => "TypeScript";
@@ -30,31 +25,12 @@ static TypeScriptCompilationService()
 
         public bool PersistsOutput => true;
 
-        private static string GetToolPath()
-        {
-            string path = ScriptSettingsManager.Instance.GetSetting(EnvironmentSettingNames.TypeScriptCompilerPath);
-            if (path == null)
-            {
-                string basePath = Path.Combine(Environment.ExpandEnvironmentVariables("%programfiles(x86)%"), "Microsoft SDKs\\TypeScript");
-                if (Directory.Exists(basePath))
-                {
-                    path = Directory.GetDirectories(basePath)
-                        .OrderByDescending(d => d)
-                        .FirstOrDefault() ?? string.Empty;
-
-                    path = Path.Combine(path, DefaultToolName);
-                }
-            }
-
-            return path ?? DefaultToolName;
-        }
-
         async Task<object> ICompilationService.GetFunctionCompilationAsync(FunctionMetadata functionMetadata)
             => await GetFunctionCompilationAsync(functionMetadata);
 
         public async Task<IJavaScriptCompilation> GetFunctionCompilationAsync(FunctionMetadata functionMetadata)
         {
-            return await TypeScriptCompilation.CompileAsync(functionMetadata.ScriptFile, DefaultCompilationOptions);
+            return await TypeScriptCompilation.CompileAsync(functionMetadata.ScriptFile, _compilationOptions);
         }
     }
 }