public async Task When_patternProperties_is_set_with_string_value_type_then_correct_dictionary_is_generated()
{
//// Arrange
var schemaJson = @"{
""required"": [ ""dict"" ],
""properties"": {
""dict"": {
""type"": ""object"",
""additionalProperties"": false,
""patternProperties"": {
""^[a-zA-Z_$][a-zA-Z_$0-9]*$"": {
""type"": ""string""
}
}
}
}
}";
var schema = await JsonSchema.FromJsonAsync(schemaJson);
//// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Class
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("dict: { [key: string]: string; };", code); // property not nullable
Assert.Contains("this.dict = {};", code); // must be initialized with {}
}
public async Task When_a_nullable_dict_property_exists_and_typestyle_is_null_then_init_should_assign_null()
{
//// Arrange
var schema = new JsonSchema
{
Properties =
{
{ "Prop", new JsonSchemaProperty
{
Type = JsonObjectType.Object,
AdditionalPropertiesSchema = new JsonSchema
{
Properties = { }
},
IsRequired = true,
IsNullableRaw = true
} },
}
};
//// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
{
NullValue = TypeScriptNullValue.Null,
TypeScriptVersion = 4,
MarkOptionalProperties = false,
});
var code = generator.GenerateFile("Foo").Replace("\r\n", "\n");
//// Assert
Assert.Matches(new Regex(
@"init\(.*\)\s{.*}\s*else\s{\s*this\.prop\s=\s<any>null;\s*}", RegexOptions.Singleline),
code);
}
public async Task When_schema_contains_discriminator_and_inheritance_hierarchy_then_TypeScript_is_correctly_generated()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <Container>();
var json = schema.ToJson();
//// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Class
});
var code = generator.GenerateFile("Container");
//// Assert
Assert.Contains("export class Container", code);
Assert.Contains("export class Animal", code);
Assert.Contains("export class Dog", code);
// discriminator is available for deserialization
Assert.Contains("protected _discriminator: string;", code); // discriminator must be private
Assert.Contains("new Dog();", code); // type is chosen by discriminator
Assert.Contains("new Animal();", code); // type is chosen by discriminator
// discriminator is assign for serialization
Assert.Contains("this._discriminator = \"Animal\"", code);
Assert.Contains("this._discriminator = \"Dog\"", code);
}
public async Task When_property_is_string_dictionary_then_assignment_is_correct()
{
//// Arrange
var json = @"{
""properties"": {
""resource"": {
""type"": ""object"",
""additionalProperties"": {
""$ref"": ""#/definitions/myItem""
}
}
},
""definitions"": {
""myItem"": {
""type"": ""string""
}
}
}";
var schema = await JsonSchema.FromJsonAsync(json);
//// Act
var codeGenerator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Class,
NullValue = TypeScriptNullValue.Undefined,
TypeScriptVersion = 1.8m
});
var code = codeGenerator.GenerateFile("Test");
//// Assert
Assert.Contains("(<any>this.resource)[key] = _data[\"resource\"][key];", code);
}
public async Task When_allOf_schema_is_object_type_then_it_is_an_inherited_class_in_generated_code()
{
//// Arrange
var json = @"{
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'properties': {
'prop1' : { 'type' : 'string' }
},
'allOf': [
{
'$ref': '#/definitions/Bar'
}
],
'definitions': {
'Bar': {
'type': 'object',
'properties': {
'prop2' : { 'type' : 'string' }
}
}
}
}";
//// Act
var schema = await JsonSchema4.FromJsonAsync(json);
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Class
});
var code = generator.GenerateFile("Foo");
//// Assert
Assert.Contains("class Foo extends Bar", code);
}
public async Task When_property_is_object_and_not_dictionary_it_should_be_assigned_in_init_method()
{
//// Arrange
var json = @"{
""properties"": {
""resource"": {
""type"": ""object""
}
}
}";
var schema = await JsonSchema.FromJsonAsync(json);
//// Act
var codeGenerator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Class,
NullValue = TypeScriptNullValue.Null
});
var code = codeGenerator.GenerateFile("Test");
//// Assert
Assert.Contains("resource: any;", code);
Assert.DoesNotContain("this.resource[key] = _data[\"resource\"][key];", code);
Assert.DoesNotContain(" : new any();", code);
}
public void When_allOf_schema_is_object_type_then_it_is_an_inherited_class_in_generated_code()
{
//// Arrange
var json = @"{
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'x-typeName': 'Foo',
'properties': {
'prop1' : { 'type' : 'string' }
},
'allOf': [
{
'type': 'object',
'x-typeName': 'Bar',
'properties': {
'prop2' : { 'type' : 'string' }
}
}
]
}";
//// Act
var schema = JsonSchema4.FromJson(json);
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Class
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("class Foo extends Bar"));
}
public void When_patternProperties_is_set_with_string_value_type_then_correct_dictionary_is_generated()
{
//// Arrange
var schemaJson = @"{
""properties"": {
""dict"": {
""type"": ""object"",
""additionalProperties"": false,
""patternProperties"": {
""^[a-zA-Z_$][a-zA-Z_$0-9]*$"": {
""type"": ""string""
}
}
}
}
}";
var schema = JsonSchema4.FromJson(schemaJson);
//// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Class
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("dict: { [key: string] : string; } = {};")); // property not nullable, must be initialized with {}
}
public void When_more_properties_are_defined_in_allOf_and_type_none_then_all_of_contains_all_properties_in_generated_code()
{
//// Arrange
var json = @"{
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'x-typeName': 'Foo',
'properties': {
'prop1' : { 'type' : 'string' }
},
'allOf': [
{
'properties': {
'prop2' : { 'type' : 'string' }
}
}
]
}";
//// Act
var schema = JsonSchema4.FromJson(json);
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Class
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("class Foo"));
Assert.IsTrue(code.Contains("prop1: string;"));
Assert.IsTrue(code.Contains("prop2: string;"));
Assert.IsFalse(code.Contains("class Anonymous"));
}
public override async ValueTask RenderTypeDeclarationAsync(
RenderingTypeScriptDefinitions notification,
ActivityType activityType,
ActivityDescriptor activityDescriptor,
ActivityDefinition activityDefinition,
StringBuilder writer,
CancellationToken cancellationToken = default)
{
var targetTypeSchema = activityDefinition.Properties.FirstOrDefault(x => x.Name == nameof(HttpEndpoint.Schema))?.Expressions.Values.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(targetTypeSchema))
{
var jsonSchema = await JsonSchema.FromJsonAsync(targetTypeSchema, cancellationToken);
var generator = new TypeScriptGenerator(jsonSchema, new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Interface,
TypeScriptVersion = 4
});
var typeScriptType = $"{activityDefinition.Name}Output";
var jsonSchemaTypes = generator.GenerateFile(typeScriptType)
.Replace("\r\n", "\n")
.Replace("export interface", "declare class");
writer.AppendLine(jsonSchemaTypes);
}
await base.RenderTypeDeclarationAsync(notification, activityType, activityDescriptor, activityDefinition, writer, cancellationToken);
}
public void Demo()
{
var schema = JsonSchema4.FromType <Person>();
var schemaJsonData = schema.ToJson();
var errors = schema.Validate("{}");
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
}
public override async Task RunAsync(CommandLineProcessor processor, IConsoleHost host)
{
var schema = JsonSchema4.FromJson(InputJson);
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
WriteOutput(host, code);
}
/// <summary>
/// Generates a TypeScript client from the JSON Schema metadata
/// </summary>
/// <param name="outputFile">File path for the generated client code</param>
/// <returns>The metadata source</returns>
/// <example>
/// <code><![CDATA[NSwag.FromJsonSchema("./schema.json").ToTypeScriptClient("./client.ts");]]></code>
/// </example>
public JsonSchemaSource ToTypeScriptClient(FilePath outputFile)
{
var schema = JsonSchema4.FromJson(new StreamReader(FileSystem.GetFile(Source).OpenRead()).ReadToEnd());
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
FileSystem.WriteContent(outputFile, code);
return(this);
}
public async Task Demo()
{
var schema = await JsonSchema4.FromTypeAsync <Person>();
var schemaJsonData = schema.ToJson();
var errors = schema.Validate("{}");
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
}
public async Task Demo2()
{
var schema = JsonSchema.FromType <Person>();
var schemaJsonData = schema.ToJson();
var errors = schema.Validate("{}");
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Interface, TypeScriptVersion = 2.0m
});
var code = generator.GenerateFile();
}
private static async Task <string> PrepareAsync(TypeScriptGeneratorSettings settings)
{
var schema = JsonSchema.FromType <MyClassTest>();
var data = schema.ToJson();
//// Act
var generator = new TypeScriptGenerator(schema, settings);
var code = generator.GenerateFile("MyClass");
return(code);
}
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host)
{
var schema = await GetJsonSchemaAsync().ConfigureAwait(false);
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile(Name);
await TryWriteFileOutputAsync(host, () => code).ConfigureAwait(false);
return(Task.FromResult <object>(code));
}
public void When_property_is_readonly_then_ts_property_is_also_readonly()
{
//// Arrange
var schema = JsonSchema4.FromType <Teacher>();
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile();
//// Assert
Assert.IsTrue(output.Contains(@"readonly Birthday"));
}
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host)
{
var schema = JsonSchema4.FromJson(InputJson);
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
if (TryWriteFileOutput(host, () => code) == false)
{
return(Task.FromResult <object>(code));
}
return(Task.FromResult <object>(null));
}
private static string GetTsFileContent(TypeScriptGenerator tsGenerator, IEnumerable <string> dataContractTypes)
{
var ignoreTsLint = "/* eslint-disable */";
var importMoment = "import moment from \"moment\";";
var content = $@"{ignoreTsLint}
{importMoment}
{tsGenerator.GenerateFile()}
export type DataContract =
{string.Join($"{Environment.NewLine} | ", dataContractTypes.Select(type => $"\"{type}\""))};";
return(content);
}
public string GetTypeScript(string jsonSchema)
{
var schema = JsonSchema.FromJsonAsync(jsonSchema).GetAwaiter().GetResult();
var generator = new TypeScriptGenerator(schema,
new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Interface,
TypeScriptVersion = 2.0m
});
var code = generator.GenerateFile();
return(code);
}
public void When_dictionary_value_is_object_then_typescript_uses_any()
{
//// Arrange
var schema = JsonSchema4.FromType <DictionaryObjectTest>();
var data = schema.ToJson();
//// Act
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("Test?: { [key: string] : any; };"));
}
public void When_property_is_object_then_jsonProperty_has_no_reference_and_is_any()
{
//// Arrange
var schema = JsonSchema4.FromType <ObjectTest>();
var data = schema.ToJson();
//// Act
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("Test?: any;"));
}
public void When_type_name_is_missing_then_anonymous_name_is_generated()
{
//// Arrange
var schema = new JsonSchema4();
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile("MyClass");
//// Assert
Assert.DoesNotContain(@"interface {", output);
}
public void When_type_name_is_missing_then_anonymous_name_is_generated()
{
//// Arrange
var schema = new JsonSchema4();
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile();
//// Assert
Assert.IsFalse(output.Contains(@"interface {"));
}
public void When_object_property_is_required_or_not_then_the_code_has_correct_initializer()
{
//// Arrange
var schema = new JsonSchema
{
Properties =
{
{ "A", new JsonSchemaProperty
{
Type = JsonObjectType.Object,
Properties =
{
{ "A", new JsonSchemaProperty
{
Type = JsonObjectType.String
} }
},
IsRequired = true
} },
{ "B", new JsonSchemaProperty
{
Type = JsonObjectType.Object,
Properties =
{
{ "A", new JsonSchemaProperty
{
Type = JsonObjectType.String
} }
},
IsRequired = false
} },
}
};
//// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Class,
SchemaType = SchemaType.Swagger2,
TypeScriptVersion = 1.8m
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("a: A;", code);
Assert.Contains("this.a = new A();", code);
Assert.Contains("this.a = _data[\"A\"] ? A.fromJS(_data[\"A\"]) : new A();", code);
Assert.Contains("b: B;", code);
Assert.Contains("this.b = _data[\"B\"] ? B.fromJS(_data[\"B\"]) : <any>undefined;", code);
}
public async Task When_class_has_description_then_typescript_has_comment()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <Teacher>();
schema.Description = "ClassDesc.";
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains(@"/** ClassDesc. *", output);
}
public async Task When_enum_has_description_then_typescript_has_comment()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <Teacher>();
schema.AllOf.First().ActualSchema.Properties["Gender"].Description = "EnumDesc.";
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains(@"/** EnumDesc. *", output);
}
public async Task When_property_has_description_then_csharp_has_xml_comment()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <Teacher>();
schema.Properties["Class"].Description = "PropertyDesc.";
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains(@"/** PropertyDesc. *", output);
}
public async Task When_class_is_abstract_then_is_abstract_TypeScript_keyword_is_generated()
{
/// Arrange
var schema = await JsonSchema4.FromTypeAsync <AbstractClass>();
/// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeScriptVersion = 2.0m
});
var code = generator.GenerateFile("AbstractClass");
/// Assert
Assert.IsTrue(code.Contains("export abstract class AbstractClass"));
}
