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(";");
}
