public void ConstructMapperWithTypeAndParameterXMLPrefixWithFalseIsXML() { TSBuilder builder = new TSBuilder(); CompositeType type = Models.CompositeType(xmlPrefix: "a"); Property parameter = Models.Property(type: type, xmlPrefix: "b"); ClientModelExtensions.ConstructMapper(builder, type, "fakeSerializedName", parameter, false, false, false); AssertEx.EqualLines( new[] { "{", " serializedName: \"fakeSerializedName\",", " type: {", " name: \"Composite\",", " className: \"\"", " }", "}" }, builder); }
public void ConstructMapperWithXMLNameParameterEqualToSerializedNameParameterWithTypeAndParameterXMLPrefix() { TSBuilder builder = new TSBuilder(); IModelType type = Models.CompositeType(xmlPrefix: "bananas"); Property parameter = Models.Property(type: type, xmlPrefix: "mangos"); ClientModelExtensions.ConstructMapper(builder, type, "fakeSerializedName", parameter, false, false, true, xmlName: "fakeSerializedName"); AssertEx.EqualLines( new[] { "{", " serializedName: \"mangos:fakeSerializedName\",", " type: {", " name: \"Composite\",", " className: \"\"", " }", "}" }, builder); }
public void ConstructMapperWithXMLNameParameterDifferentThanSerializedNameParameterWithTypeXMLPrefix() { TSBuilder builder = new TSBuilder(); IModelType type = Models.CompositeType(xmlPrefix: "apples"); ClientModelExtensions.ConstructMapper(builder, type, "fakeSerializedName", null, false, false, true, xmlName: "fakeXMLSerializedName"); AssertEx.EqualLines( new[] { "{", " xmlName: \"apples:fakeXMLSerializedName\",", " serializedName: \"apples:fakeSerializedName\",", " type: {", " name: \"Composite\",", " className: \"\"", " }", "}" }, builder); }
public void ConstructMapperWithPropertyXMLNameDifferentThanSerializedNameParameter() { TSBuilder builder = new TSBuilder(); IModelType type = Models.CompositeType(); IVariable parameter = Models.Property(type: type, xmlName: "fakeXMLSerializedName"); ClientModelExtensions.ConstructMapper(builder, type, "fakeSerializedName", parameter, false, false, true); AssertEx.EqualLines( new[] { "{", " xmlName: \"fakeXMLSerializedName\",", " serializedName: \"fakeSerializedName\",", " type: {", " name: \"Composite\",", " className: \"\"", " }", "}" }, builder); }
public string GenerateMappers() { TSBuilder builder = new TSBuilder(); builder.Comment(AutoRest.Core.Settings.Instance.Header); builder.Line(); builder.Line("export {"); builder.Indent(() => { List <string> exportedValues = new List <string>(); if (!string.IsNullOrWhiteSpace(CodeModelTS.PolymorphicDictionary)) { exportedValues.Add("discriminators"); } exportedValues.AddRange(OperationModelNames.OrderBy(mapperName => mapperName.ToLowerInvariant())); builder.Line(string.Join(",\n", exportedValues)); }); builder.Line("} from \"../models/mappers\";"); return(builder.ToString()); }
public void GenerateOperationSpecWithSameRequestContentTypeAsCodeModel() { CodeModelTS codeModel = Models.CodeModel(); MethodTS method = Models.Method(codeModel: codeModel, requestContentType: "application/json"); Assert.AreEqual(method.RequestContentType, codeModel.RequestContentType); TSBuilder builder = GenerateOperationSpec(method); AssertEx.EqualLines( new[] { "{", " httpMethod: \"GET\",", " responses: {", " default: {}", " },", " serializer", "}" }, builder); }
public override string Generate() { TSBuilder builder = new TSBuilder(); string extends = $"Array{ConstructTSItemTypeName()}"; if (BaseModelType != null && !BaseIsPolymorphic) { extends += $", {BaseModelType.Name}"; } builder.DocumentationComment(comment => { comment.Interface(); string description = Documentation; if (string.IsNullOrEmpty(description)) { description = $"An interface representing the {Name}."; } comment.Description(description); comment.Summary(Summary); comment.Extends(extends); }); builder.ExportInterface(Name, extends, tsInterface => { foreach (Property property in InterfaceProperties) { if (!(property.Name.ToLowerInvariant() == "value" || property.Name.ToLowerInvariant() == "values")) { tsInterface.DocumentationComment(property.Documentation); string propertyType = property.IsPolymorphicDiscriminator ? $"\"{SerializedName}\"" : property.ModelType.TSType(true); bool isReadonly = property.IsReadOnly; bool isOptional = !property.IsRequired && (!(CodeModel?.HeaderTypes.Contains(this) == true) || CodeModelTS.Settings.OptionalResponseHeaders); tsInterface.Property(property.Name, propertyType, optional: isOptional, isReadonly: isReadonly); } } }); return(builder.ToString()); }
public string GenerateReadmeMdNodeSampleCode(string emptyLine) { TSBuilder builder = new TSBuilder(); GenerateNodeSampleImports(builder); builder.ConstVariable("subscriptionId", "process.env[\"AZURE_SUBSCRIPTION_ID\"]"); builder.Line(emptyLine); builder.Line($"msRestNodeAuth.interactiveLogin().then((creds) => {{"); builder.Indent(() => { builder.ConstVariable("client", $"new {Name}(creds, subscriptionId)"); builder.Line(GenerateSampleMethod(false)); }); builder.Line($"}}).catch((err) => {{"); builder.Indent(() => { builder.Line("console.error(err);"); }); builder.Line($"}});"); return(builder.ToString()); }
/// <summary> /// Generate the method parameter declarations for a method, using TypeScript declaration syntax /// <param name="includeOptions">whether the ServiceClientOptions parameter should be included</param> /// <param name="isOptionsOptional">whether the ServiceClientOptions parameter should be optional</param> /// </summary> public string MethodParameterDeclarationTS(bool includeOptions, bool isOptionsOptional = true) { TSBuilder builder = new TSBuilder(); TSParameterList parameterList = new TSParameterList(builder); parameterList.Parameters(LocalParameters.Where(p => p.IsRequired).Select(AutoRestParameterToTSParameter)); if (includeOptions) { string optionsParameterType; if (OptionsParameterModelType.Name.EqualsIgnoreCase("RequestOptionsBase")) { optionsParameterType = "msRest.RequestOptionsBase"; } else { optionsParameterType = $"Models.{OptionsParameterModelType.Name}"; } parameterList.Parameter("options", optionsParameterType, isOptionsOptional); } return(builder.ToString()); }
public string GenerateServiceClientExports() { TSBuilder builder = new TSBuilder(); builder.Export(exports => { exports.Export(Name); exports.Export(ContextName); if (CodeGeneratorTS.ShouldWriteModelsFiles(this)) { exports.ExportAs("Models", $"{ClientPrefix}Models"); } if (HasMappers()) { exports.ExportAs("Mappers", $"{ClientPrefix}Mappers"); } }); if (MethodGroupModels.Any()) { builder.ExportAll("./operations"); } return(builder.ToString()); }
public string GenerateServiceClientImports() { TSBuilder builder = new TSBuilder(); if (MethodTemplateModels.Any() || OptionalParameterTypeForClientConstructor == ServiceClientOptions) { builder.ImportAllAs("msRest", "ms-rest-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()); }
public string Generate(bool emitEnumType) { TSBuilder builder = new TSBuilder(); builder.DocumentationComment(comment => { comment.Description($"Defines values for {Name}."); comment.Description(ExtendedDocumentation); comment.ReadOnly(); comment.Enum(CodeNamer.Instance.CamelCase(UnderlyingType.Name)); }); if (emitEnumType) { builder.ExportEnum(Name, tsEnum => { foreach (EnumValue value in Values) { tsEnum.DocumentationComment(value.Description); string valueName = CodeNamer.Instance.GetEnumMemberName(value.MemberName); string valueValue = CodeNamerTS.GetEnumValueName(value.SerializedName, UnderlyingType); if (valueValue == null || valueValue == "null") { valueValue = "\"null\""; } tsEnum.Value(valueName, valueValue); } }); } else { builder.ExportUnionType(Name, Values.Select(v => CodeNamerTS.GetEnumValueName(v.SerializedName, UnderlyingType))); } return(builder.ToString()); }
public static string CreateSerializerExpression(this CodeModelTS codeModel) { TSBuilder builder = new TSBuilder(); builder.FunctionCall("new msRest.Serializer", arguments => { bool hasMappers = codeModel.HasMappers(); if (hasMappers) { arguments.Text("Mappers"); } if (codeModel.ShouldGenerateXmlSerialization == true) { if (!hasMappers) { arguments.Object(); } arguments.Boolean(true); } }); return(builder.ToString()); }
public virtual string Generate() { TSBuilder builder = new TSBuilder(); if (ImmediatePolymorphicSubtypes.Any()) { builder.DocumentationComment($"Contains the possible cases for {Name}."); List <string> unionTypeValues = new List <string>() { Name }; unionTypeValues.AddRange(ImmediatePolymorphicSubtypes.Select(m => m.UnionTypeName)); builder.ExportUnionType($"{Name}Union", unionTypeValues); builder.Line(); } builder.DocumentationComment(comment => { string description = Documentation; if (string.IsNullOrEmpty(description)) { description = $"An interface representing {Name}."; } comment.Description(description); comment.Summary(Summary); }); string baseTypeName = null; if (BaseModelType != null && !BaseIsPolymorphic) { baseTypeName = BaseModelType.Name; if (baseTypeName == "RequestOptionsBase") { // baseTypeName = $"coreHttp.{baseTypeName}"; baseTypeName = null; } } builder.ExportInterface(Name, baseTypeName, tsInterface => { ISet <string> addedPropertyNames = new HashSet <string>(); foreach (Property property in InterfaceProperties) { string propertyName = property.Name; if (!addedPropertyNames.Contains(propertyName)) { addedPropertyNames.Add(propertyName); string propertyDescription = $"{property.Summary.EnsureEndsWith(".")} {property.Documentation}".Trim(); if (!property.DefaultValue.IsNullOrEmpty()) { propertyDescription = $"{propertyDescription.EnsureEndsWith(".")} Default value: {property.DefaultValue}.".Trim(); } tsInterface.DocumentationComment(propertyDescription); string propertyType = property.IsPolymorphicDiscriminator ? $"\"{SerializedName}\"" : property.ModelType.TSType(true); bool isReadonly = property.IsReadOnly; bool isOptional = !property.IsRequired && (!(CodeModel?.HeaderTypes.Contains(this) == true) || CodeModelTS.Settings.OptionalResponseHeaders); bool isNullable = property.IsXNullable ?? false; tsInterface.Property(property.Name, propertyType, optional: isOptional, isReadonly: isReadonly, isNullable: isNullable); } } if (AdditionalProperties != null) { tsInterface.DocumentationComment(AdditionalPropertiesDocumentation()); tsInterface.Property("[property: string]", AdditionalPropertiesTSType()); } }); return(builder.ToString()); }
public TSEnum(TSBuilder builder) { this.builder = builder; }
public static void ConstructMapper(TSBuilder builder, IModelType type, string serializedName, IVariable parameter, bool isPageable, bool expandComposite, bool isXML, bool isCaseSensitive = true, string xmlName = null) { builder.Value(value => ConstructMapper(value, type, serializedName, parameter, isPageable, expandComposite, isXML, isCaseSensitive, xmlName)); }
public TSClass(TSBuilder builder) { this.builder = builder; currentState = State.Start; }
public static void EqualLines(string expected, TSBuilder actual) { EqualLines(Lines(expected), actual?.ToString()); }
public static void EqualLines(IEnumerable <string> expected, TSBuilder actual) { EqualLines(expected, actual?.ToString()); }
protected void GenerateNodeSampleMsRestJsImport(TSBuilder builder) { builder.ImportAllAs("msRest", "ms-rest-js"); }
public TSUnionType(TSBuilder builder) { this.builder = builder; currentState = State.Start; }
public void GenerateOperationSpecDefinition(TSBuilder builder) { builder.ConstObjectVariable(GetOperationSpecVariableName(), "msRest.OperationSpec", GenerateOperationSpec); }
protected void GenerateNodeSampleMsRestNodeAuthImport(TSBuilder builder) { builder.ImportAllAs("msRestNodeAuth", "ms-rest-nodeauth"); }
protected virtual void GenerateNodeSampleImports(TSBuilder builder) { GenerateNodeSampleMsRestJsImport(builder); GenerateNodeSampleMsRestNodeAuthImport(builder); GenerateNodeSampleClientImport(builder); }
protected void GenerateNodeSampleClientImport(TSBuilder builder) { builder.Import(new[] { Name, $"{ClientPrefix}Models", $"{ClientPrefix}Mappers" }, PackageName); }
public TSInterface(TSBuilder builder) { this.builder = builder; }
public override void ConstructModelMapper(TSBuilder builder) { builder.Text($"export const {Name}: msRest.CompositeMapper = "); ClientModelExtensions.ConstructMapper(builder, this, SerializedName, null, isPageable: true, expandComposite: true, isXML: CodeModel?.ShouldGenerateXmlSerialization == true); builder.Line(";"); }