Parameter mappers (Azure#219)

* Parameter mappers prototype * Create parameter mapper names in transformer step * Add Azure support * Regenerate * Use specific operation parameter interface * Regenerate * Update ms-rest-js * Sort parameter mappers by name * Regenerate * Cleanup * fix up imports * regenerate * Remove unnecessary gen code * regenerate
sarangan12 · Jul 20, 2018 · e66db24 · e66db24
1 parent 2f51bc0
commit e66db24
Show file tree

Hide file tree

Showing 101 changed files with 3,433 additions and 5,926 deletions.
diff --git a/README.md b/README.md
@@ -9,8 +9,8 @@ npm install -g autorest
 # Compatibility
 This AutoRest extension generates TypeScript code that is compatible with:
 ```
-"ms-rest-azure-js": "~0.11.101",
-"ms-rest-js": "~0.16.366"
+"ms-rest-azure-js": "~0.11.104",
+"ms-rest-js": "~0.16.372"
 ```
 
 # Usage

diff --git a/package.json b/package.json
@@ -68,8 +68,8 @@
     "mocha": "^5.0.4",
     "mocha-chrome": "^1.0.3",
     "moment": "~2.21.0",
-    "ms-rest-azure-js": "~0.11.101",
-    "ms-rest-js": "~0.16.366",
+    "ms-rest-azure-js": "~0.11.104",
+    "ms-rest-js": "~0.16.372",
     "run-sequence": "*",
     "should": "5.2.0",
     "shx": "^0.2.2",

diff --git a/src/azure/CodeGeneratorTSa.cs b/src/azure/CodeGeneratorTSa.cs
@@ -54,6 +54,7 @@ public override async Task Generate(CodeModel cm)
             await Write(modelIndexTemplate, Path.Combine("models", "index.ts"));
             var mapperIndexTemplate = new AzureMapperIndexTemplate { Model = codeModel };
             await Write(mapperIndexTemplate, Path.Combine("models", "mappers.ts"));
+            await Write(new ParameterTemplate {Model = codeModel}, Path.Combine("models", "parameters.ts"));
 
             //MethodGroups
             if (codeModel.MethodGroupModels.Any())

diff --git a/src/azure/Model/CodeModelTSa.cs b/src/azure/Model/CodeModelTSa.cs
@@ -8,6 +8,7 @@
 using AutoRest.TypeScript.Model;
 using Newtonsoft.Json;
 using AutoRest.Core.Utilities;
+using AutoRest.TypeScript.DSL;
 
 namespace AutoRest.TypeScript.Azure.Model
 {
@@ -76,7 +77,36 @@ public override string ConstructRuntimeImportForModelIndex()
 
         public override string PackageDependencies()
         {
-            return "\"ms-rest-azure-js\": \"~0.11.101\"";
+            return "\"ms-rest-azure-js\": \"~0.11.104\"";
+        }
+
+        public string GenerateAzureServiceClientImports()
+        {
+            TSBuilder builder = new TSBuilder();
+
+            builder.ImportAllAs("msRest", "ms-rest-js");
+
+            bool usesAzureOptionsType = OptionalParameterTypeForClientConstructor == "AzureServiceClientOptions";
+            if (usesAzureOptionsType)
+            {
+                builder.ImportAllAs("msRestAzure", "ms-rest-azure-js");
+            }
+
+            builder.ImportAllAs("Models", "./models");
+            builder.ImportAllAs("Mappers", "./models/mappers");
+
+            if (HasMappableParameters)
+            {
+                builder.ImportAllAs("Parameters", "./models/parameters");
+            }
+
+            if (MethodGroupModels.Any())
+            {
+                builder.ImportAllAs("operations", "./operations");
+            }
+            builder.Import(new string[] { ContextName }, $"./{ContextName.ToCamelCase()}");
+
+            return builder.ToString();
         }
     }
 }
diff --git a/src/azure/PluginTSa.cs b/src/azure/PluginTSa.cs
@@ -16,7 +16,7 @@ public PluginTSa()
                 // inherit base settings
                 Context,
 
-                // set code model implementations our own implementations 
+                // set code model implementations our own implementations
                 new Factory<CodeModel, CodeModelTSa>(),
                 new Factory<Method, MethodTSa>(),
                 new Factory<CompositeType, CompositeTypeTS>(),
@@ -25,7 +25,8 @@ public PluginTSa()
                 new Factory<SequenceType, SequenceTypeTS>(),
                 new Factory<MethodGroup, MethodGroupTS>(),
                 new Factory<EnumType, EnumTypeTS>(),
-                new Factory<PrimaryType, PrimaryTypeTS>()
+                new Factory<PrimaryType, PrimaryTypeTS>(),
+                new Factory<Parameter, ParameterTS>()
             };
         }
     }

diff --git a/src/azure/Templates/AzureMethodGroupTemplate.cshtml b/src/azure/Templates/AzureMethodGroupTemplate.cshtml
@@ -7,13 +7,7 @@
 @Header(" * ")
  */
 @EmptyLine
-import * as msRest from "ms-rest-js";
-@if (Model.ContainsCompositeOrEnumTypeInParametersOrReturnType())
-{
-@:import * as Models from "../models";
-}
-import * as Mappers from "../models/@(Model.MappersModuleName)";
-import { @(Model.CodeModelTS.ContextName) } from "../@(Model.CodeModelTS.ContextName.ToCamelCase())";
+@(Model.GenerateMethodGroupImports())
 @EmptyLine
 /** Class representing a @(Model.TypeName). */
 export class @(Model.TypeName) {

diff --git a/src/azure/Templates/AzureServiceClientTemplate.cshtml b/src/azure/Templates/AzureServiceClientTemplate.cshtml
@@ -8,20 +8,7 @@
 @Header(" * ")
  */
 @EmptyLine
-import * as Models from "./models";
-import * as Mappers from "./models/mappers";
-import * as msRest from "ms-rest-js";
-@{
-bool usesAzureOptionsType = Model.OptionalParameterTypeForClientConstructor == "AzureServiceClientOptions";
-if (usesAzureOptionsType)
-{
-@:import * as msRestAzure from "ms-rest-azure-js";
-}
-}
-import { @(Model.ContextName) } from "./@(Model.ContextName.ToCamelCase())";
-@if (Model.MethodGroupModels.Any()) {
-@:import * as operations from "./operations";
-}
+@(Model.GenerateAzureServiceClientImports())
 @EmptyLine
 @{var requiredParameters = Model.Properties.Where(p => p.IsRequired && !p.IsConstant && string.IsNullOrEmpty(p.DefaultValue));}
 @{var optionalParameters = Model.Properties.Where(p => (!p.IsRequired || p.IsRequired && !string.IsNullOrEmpty(p.DefaultValue)) && !p.IsConstant && !p.Name.EqualsIgnoreCase("apiVersion"));}

diff --git a/src/vanilla/ClientModelExtensions.cs b/src/vanilla/ClientModelExtensions.cs
@@ -539,6 +539,11 @@ private static string CreatePatternConstraintValue(string constraintValue)
             return "/" + constraintValue.Replace("/", "\\/") + "/";
         }
 
+        public static void ConstructParameterMapper(TSObject obj, ParameterTS parameter)
+        {
+            MethodTS.GenerateRequestParameter(obj, parameter, parameter.MethodTS.GetParameterTransformations());
+        }
+
         public static void ConstructRequestBodyMapper(TSValue value, Parameter requestBody)
         {
             IModelType requestBodyModelType = requestBody.ModelType;

diff --git a/src/vanilla/CodeGeneratorTS.cs b/src/vanilla/CodeGeneratorTS.cs
@@ -59,6 +59,14 @@ public override async Task Generate(CodeModel cm)
                 await Write(mapperIndexTemplate, Path.Combine("models", "mappers.ts"));
             }
 
+            bool serviceHasMappableParameters = codeModel.Methods
+                .SelectMany(m => m.LogicalParameters)
+                .Any(p => p.Location != ParameterLocation.Body);
+            if (serviceHasMappableParameters)
+            {
+                await Write(new ParameterTemplate {Model = codeModel}, Path.Combine("models", "parameters.ts"));
+            }
+
             //MethodGroups
             if (codeModel.MethodGroupModels.Any())
             {

diff --git a/src/vanilla/Model/CodeModelTS.cs b/src/vanilla/Model/CodeModelTS.cs
@@ -10,6 +10,7 @@
 using AutoRest.Core.Utilities;
 using AutoRest.Extensions;
 using AutoRest.TypeScript.DSL;
+using AutoRest.TypeScript;
 using Newtonsoft.Json;
 
 namespace AutoRest.TypeScript.Model
@@ -363,7 +364,7 @@ public virtual string ConstructRuntimeImportForModelIndex()
 
         public virtual string PackageDependencies()
         {
-            return "\"ms-rest-js\": \"~0.16.366\"";
+            return "\"ms-rest-js\": \"~0.16.372\"";
         }
 
         public virtual Method GetSampleMethod()
@@ -461,6 +462,55 @@ public string GenerateOperationSpecDefinitions(string emptyLine)
             return builder.ToString();
         }
 
+        private sealed class ParameterNameComparer : IEqualityComparer<ParameterTS>
+        {
+            private ParameterNameComparer() {}
+            public static ParameterNameComparer Instance { get; } = new ParameterNameComparer();
+
+            public bool Equals(ParameterTS x, ParameterTS y)
+            {
+                return x.MapperName == y.MapperName;
+            }
+
+            public int GetHashCode(ParameterTS obj)
+            {
+                return obj.MapperName.GetHashCode();
+            }
+        }
+
+        public bool HasMappableParameters =>
+            MethodTemplateModels
+                .SelectMany(m => m.LogicalParameters)
+                .Any(p => p.Location != ParameterLocation.Body);
+
+        public string GenerateParameterMappers()
+        {
+            TSBuilder builder = new TSBuilder();
+            IEnumerable<ParameterTS> parameters = Methods
+                .SelectMany(m => m.LogicalParameters)
+                .Cast<ParameterTS>()
+                .Where(p => p.ModelTypeName != "RequestOptionsBase" && p.Location != ParameterLocation.Body)
+                .OrderBy(p => p.MapperName)
+                .Distinct(ParameterNameComparer.Instance);
+
+            foreach (ParameterTS parameter in parameters)
+            {
+                string parameterInterfaceName =
+                    parameter.Location == ParameterLocation.Path ? "msRest.OperationURLParameter" :
+                    parameter.Location == ParameterLocation.Query ? "msRest.OperationQueryParameter" :
+                    "msRest.OperationParameter";
+
+                builder.Text("export ");
+                builder.ConstObjectVariable(
+                    parameter.MapperName,
+                    parameterInterfaceName,
+                    obj => ClientModelExtensions.ConstructParameterMapper(obj, parameter));
+                builder.Line();
+            }
+
+            return builder.ToString();
+        }
+
         public string GenerateServiceClientImports()
         {
             TSBuilder builder = new TSBuilder();
@@ -471,6 +521,12 @@ public string GenerateServiceClientImports()
             }
             builder.ImportAllAs("Models", "./models");
             builder.ImportAllAs("Mappers", "./models/mappers");
+
+            if (HasMappableParameters)
+            {
+                builder.ImportAllAs("Parameters", "./models/parameters");
+            }
+
             if (MethodGroupModels.Any())
             {
                 builder.ImportAllAs("operations", "./operations");

diff --git a/src/vanilla/Model/MethodGroupTS.cs b/src/vanilla/Model/MethodGroupTS.cs
@@ -160,5 +160,31 @@ public string GenerateOperationSpecDefinitions(string emptyLine)
 
             return builder.ToString();
         }
+
+        public bool HasMappableParameters =>
+            Methods
+                .SelectMany(m => m.LogicalParameters)
+                .Any(p => p.Location != ParameterLocation.Body);
+
+        public string GenerateMethodGroupImports()
+        {
+            TSBuilder builder = new TSBuilder();
+
+            builder.ImportAllAs("msRest", "ms-rest-js");
+            if (ContainsCompositeOrEnumTypeInParametersOrReturnType())
+            {
+                builder.ImportAllAs("Models", "../models");
+            }
+            builder.ImportAllAs("Mappers", $"../models/{MappersModuleName}");
+
+            if (HasMappableParameters)
+            {
+                builder.ImportAllAs("Parameters", "../models/parameters");
+            }
+
+            builder.Import(new string[] { CodeModelTS.ContextName }, $"../{CodeModelTS.ContextName.ToCamelCase()}");
+
+            return builder.ToString();
+        }
     }
 }
diff --git a/src/vanilla/Model/MethodTS.cs b/src/vanilla/Model/MethodTS.cs
@@ -404,7 +404,7 @@ public string ReturnTypeInfo
             }
         }
 
-        private ParameterTransformations GetParameterTransformations()
+        internal ParameterTransformations GetParameterTransformations()
             => new ParameterTransformations(InputParameterTransformation);
 
         /// <summary>
@@ -568,25 +568,16 @@ public void GenerateOperationSpec(TSObject operationSpec)
             }
 
             Parameter[] logicalParameters = LogicalParameters.ToArray();
-            ParameterTransformations parameterTransformations = GetParameterTransformations();
 
-            GenerateRequestParameters(operationSpec, "urlParameters", parameterTransformations, logicalParameters.Where(p => p.Location == ParameterLocation.Path), AddSkipEncodingProperty);
-            GenerateRequestParameters(operationSpec, "queryParameters", parameterTransformations, logicalParameters.Where(p => p.Location == ParameterLocation.Query),
-                (TSObject queryParameterObject, Parameter queryParameter) =>
-                {
-                    AddSkipEncodingProperty(queryParameterObject, queryParameter);
-                    if (queryParameter.CollectionFormat != CollectionFormat.None)
-                    {
-                        queryParameterObject.TextProperty("collectionFormat", $"msRest.QueryCollectionFormat.{queryParameter.CollectionFormat}");
-                    }
-                });
-            GenerateRequestParameters(operationSpec, "headerParameters", parameterTransformations, logicalParameters.Where(p => p.Location == ParameterLocation.Header));
+            AddParameterRefs(operationSpec, "urlParameters", logicalParameters.Where(p => p.Location == ParameterLocation.Path));
+            AddParameterRefs(operationSpec, "queryParameters", logicalParameters.Where(p => p.Location == ParameterLocation.Query));
+            AddParameterRefs(operationSpec, "headerParameters", logicalParameters.Where(p => p.Location == ParameterLocation.Header));
 
             if (Body != null)
             {
                 operationSpec.ObjectProperty("requestBody", requestBodyObject =>
                 {
-                    GenerateRequestParameterPath(requestBodyObject, Body, parameterTransformations);
+                    GenerateRequestParameterPath(requestBodyObject, Body, GetParameterTransformations());
                     requestBodyObject.Property("mapper", requestBodyMapper => ClientModelExtensions.ConstructRequestBodyMapper(requestBodyMapper, Body));
                 });
                 operationSpec.QuotedStringProperty("contentType", RequestContentType);
@@ -596,7 +587,7 @@ public void GenerateOperationSpec(TSObject operationSpec)
                 IEnumerable<Parameter> formDataParameters = logicalParameters.Where(p => p.Location == ParameterLocation.FormData);
                 if (formDataParameters.Any())
                 {
-                    GenerateRequestParameters(operationSpec, "formDataParameters", parameterTransformations, formDataParameters);
+                    AddParameterRefs(operationSpec, "formDataParameters", formDataParameters);
                     operationSpec.QuotedStringProperty("contentType", RequestContentType);
                 }
             }
@@ -649,20 +640,34 @@ private static void AddSkipEncodingProperty(TSObject parameterObject, Parameter
             }
         }
 
-        private static void GenerateRequestParameters(TSObject operationSpec, string propertyName, ParameterTransformations parameterTransformations, IEnumerable<Parameter> requestParameters, Action<TSObject, Parameter> extraParameterProperties = null)
+        internal static void GenerateRequestParameter(TSObject parameterObject, ParameterTS requestParameter, ParameterTransformations parameterTransformations)
+        {
+            GenerateRequestParameterPath(parameterObject, requestParameter, parameterTransformations);
+            parameterObject.Property("mapper", mapper => ClientModelExtensions.ConstructMapper(mapper, requestParameter.ModelType, requestParameter.SerializedName, requestParameter, false, false, false));
+
+            ParameterLocation location = requestParameter.Location;
+            if (location == ParameterLocation.Path || location == ParameterLocation.Query)
+            {
+                AddSkipEncodingProperty(parameterObject, requestParameter);
+            }
+            if (location == ParameterLocation.Query)
+            {
+                if (requestParameter.CollectionFormat != CollectionFormat.None)
+                {
+                    parameterObject.TextProperty("collectionFormat", $"msRest.QueryCollectionFormat.{requestParameter.CollectionFormat}");
+                }
+            }
+        }
+
+        private static void AddParameterRefs(TSObject operationSpec, string propertyName, IEnumerable<Parameter> requestParameters)
         {
             if (requestParameters != null && requestParameters.Any())
             {
                 operationSpec.ArrayProperty(propertyName, parameterArray =>
                 {
-                    foreach (Parameter requestParameter in requestParameters)
+                    foreach (ParameterTS requestParameter in requestParameters)
                     {
-                        parameterArray.Object(parameterObject =>
-                        {
-                            GenerateRequestParameterPath(parameterObject, requestParameter, parameterTransformations);
-                            extraParameterProperties?.Invoke(parameterObject, requestParameter);
-                            parameterObject.Property("mapper", mapper => ClientModelExtensions.ConstructMapper(mapper, requestParameter.ModelType, requestParameter.SerializedName, requestParameter, false, false, false));
-                        });
+                        parameterArray.Value(v => v.Text("Parameters." + requestParameter.MapperName));
                     }
                 });
             }