public static async Task<EngineRunResult> Run(Configuration config)
{
Validation(config);
var specifications = await GetSpecifications(config);
var targetPath = Path.GetDirectoryName(config.Target);
if (!Directory.Exists(targetPath))
{
Directory.CreateDirectory(targetPath);
}
if (config.Language.HasFlag(TargetLanguage.csharp))
{
foreach (var spec in specifications.Where(_ => !_.Error))
{
CSharpGenerator.Run(config, spec);
}
}
if (config.Language.HasFlag(TargetLanguage.typescript))
{
var generator = new TypeScriptGenerator();
generator.Run(config, specifications);
}
return new EngineRunResult
{
Errors = specifications.Where(_ => _.Error)
};
}
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 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 static void AssertEqual(string input, string expectedOutput, Action <TypeScriptGenerator> options = null)
{
var sb = new StringBuilder();
var generator = new TypeScriptGenerator(new StringWriter(sb));
options?.Invoke(generator);
generator.Generate(input);
var expexted = NormalizeTypescriptSource(expectedOutput);
var actual = NormalizeTypescriptSource(sb.ToString());
Assert.AreEqual(expexted, actual);
}
public bool GenerateCode(IActivityMonitor monitor, TypeScriptGenerator g)
{
Generate(monitor, g, typeof(ICommandOne));
Generate(monitor, g, typeof(ICommandTwo));
Generate(monitor, g, typeof(ICommandThree));
// Skip "object CommandModel" property for ICommand.
var f = g.GetTSTypeFile(monitor, typeof(ICommand));
f.EnsureFile().Body.Append("export interface ").Append(f.TypeName).OpenBlock().CloseBlock();
return(true);
}
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 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 TypeScriptGeneratorTests()
{
var services = new ServiceCollection()
.AddSingleton <TypeScriptGenerator>()
.AddSingleton <ITypeScriptTranspiler, TTypeScriptTranspiler>()
.AddSingleton <IJavaScriptGenerator, TJavaScriptGenerator>()
.AddSingleton <ResourceScriptFactory>()
.AddSingleton <ObjectPoolProvider, DefaultObjectPoolProvider>()
.AddMemoryCache()
.BuildServiceProvider();
_generator = services.GetRequiredService <TypeScriptGenerator>();
}
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));
}
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_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_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 void When_enum_has_integer_value_then_TS_code_has_string_value()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassWithIntegerEnum>();
var schemaData = schema.ToJson();
//// Act
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("_0562 = 10, "));
Assert.IsTrue(code.Contains("_0532 = 15, "));
}
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host)
{
var inputJson = await GetInputJsonAsync().ConfigureAwait(false);
var schema = await JsonSchema4.FromJsonAsync(inputJson).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_has_description_then_csharp_has_xml_comment()
{
//// Arrange
var schema = JsonSchema4.FromType <Teacher>();
schema.Properties["Class"].Description = "PropertyDesc.";
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile();
//// Assert
Assert.IsTrue(output.Contains(@"/** PropertyDesc. *"));
}
public void When_dictionary_value_is_enum_then_typescript_has_enum_value()
{
//// Arrange
var schema = JsonSchema4.FromType <EnumValueDictionaryTest>();
var data = schema.ToJson();
//// Act
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("Mapping?: { [key: string] : Gender; };"));
Assert.IsTrue(code.Contains("Mapping2?: { [key: string] : Gender; };"));
}
public void When_class_has_description_then_typescript_has_comment()
{
//// Arrange
var schema = JsonSchema4.FromType <Teacher>();
schema.Description = "ClassDesc.";
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile();
//// Assert
Assert.IsTrue(output.Contains(@"/** ClassDesc. *"));
}
protected void GenerateFiles(ICustomTypeGenerator customTypeGenerator, string folderName, params Type[] rootTypes)
{
var path = $"{TestContext.CurrentContext.TestDirectory}/{folderName}/{JavaScriptTypeChecker}";
if (Directory.Exists(path))
{
Directory.Delete(path, recursive: true);
}
Directory.CreateDirectory(path);
var generator = new TypeScriptGenerator(TypeScriptGenerationOptions.Default, customTypeGenerator, new RootTypesProvider(rootTypes));
generator.GenerateFiles(path, JavaScriptTypeChecker);
}
public async Task When_property_is_required_and_abstract_then_it_is_not_instantiated()
{
/// Arrange
var schema = await JsonSchema4.FromTypeAsync <ContainerClass>();
/// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeScriptVersion = 2.0m
});
var code = generator.GenerateFile("ContainerClass");
/// Assert
Assert.Contains("this.foo = data[\"Foo\"] ? AbstractClass.fromJS(data[\"Foo\"]) : <any>undefined;", code);
}
public void When_property_is_readonly_then_ts_property_is_also_readonly()
{
//// Arrange
var schema = JsonSchema4.FromType <Teacher>();
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Interface
});
//// Act
var output = generator.GenerateFile();
//// Assert
Assert.IsTrue(output.Contains(@"readonly Birthday"));
}
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_abstract_class_is_in_inheritance_hierarchy_then_it_is_newer_instantiated()
{
/// Arrange
var schema = JsonSchema.FromType <AbstractClass>();
/// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings {
TypeScriptVersion = 2.0m
});
var code = generator.GenerateFile("AbstractClass");
/// Assert
Assert.DoesNotContain("new AbstractClass();", code);
}
public static void BasicScenario()
{
var schema = JsonSchema4.FromType <PhotoGallery>();
var generator = new TypeScriptGenerator(schema);
var csGenerator = new CSharpGenerator(schema);
var file = generator.GenerateFile();
Console.Write(file);
file = csGenerator.GenerateFile();
Console.Write(file);
Console.ReadLine();
}
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 void When_enum_has_description_then_typescript_has_comment()
{
//// Arrange
var schema = JsonSchema4.FromType <Teacher>();
schema.AllOf.First().Properties["Gender"].Description = "EnumDesc.";
var generator = new TypeScriptGenerator(schema);
//// Act
var output = generator.GenerateFile();
//// Assert
Assert.IsTrue(output.Contains(@"/** EnumDesc. *"));
}
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"));
}
public void When_object_property_is_required_or_not_then_the_code_has_correct_initializer()
{
//// Arrange
var schema = new JsonSchema4
{
Properties =
{
{ "A", new JsonProperty
{
Type = JsonObjectType.Object,
Properties =
{
{ "A", new JsonProperty
{
Type = JsonObjectType.String
} }
},
IsRequired = true
} },
{ "B", new JsonProperty
{
Type = JsonObjectType.Object,
Properties =
{
{ "A", new JsonProperty
{
Type = JsonObjectType.String
} }
},
IsRequired = false
} },
}
};
//// Act
var generator = new TypeScriptGenerator(schema, new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Class,
NullHandling = NullHandling.Swagger
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.IsTrue(code.Contains("a: A = new A();"));
Assert.IsTrue(code.Contains("this.a = data[\"A\"] ? A.fromJS(data[\"A\"]) : new A();"));
Assert.IsTrue(code.Contains("b: B;"));
Assert.IsTrue(code.Contains("this.b = data[\"B\"] ? B.fromJS(data[\"B\"]) : undefined;"));
}
public async Task When_enum_has_integer_value_then_TS_code_has_string_value()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <ClassWithIntegerEnum>();
var schemaData = schema.ToJson();
//// Act
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("_0562 = 10, ", code);
Assert.Contains("_0532 = 15, ", code);
}
public static void Main(params string[] args)
{
var targetPath = Path.Combine(Directory.GetParent(AppDomain.CurrentDomain.BaseDirectory).FullName, "../../../output");
var options = new TypeScriptGenerationOptions
{
EnableOptionalProperties = false,
LinterDisableMode = LinterDisableMode.TsLint,
UseGlobalNullable = true,
NullabilityMode = NullabilityMode.Optimistic,
};
var typeScriptCodeGenerator = new TypeScriptGenerator(options, new AspNetCoreExampleCustomGenerator(), new TypesProvider());
typeScriptCodeGenerator.GenerateFiles(targetPath);
}
public async Task When_enum_has_string_value_then_TS_code_has_string_value()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <ClassWithStringEnum>();
var schemaData = schema.ToJson();
//// Act
var generator = new TypeScriptGenerator(schema);
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.IsTrue(code.Contains("_0562 = <any>\"0562\", "));
Assert.IsTrue(code.Contains("_0532 = <any>\"0532\", "));
}
