public void When_schema_has_default_value_of_enum_it_is_generated_in_CSharp_and_TypeScript_correctly()
{
//// Arrange
var csharpSettings = new CSharpGeneratorSettings {
EnumNameGenerator = new MyEnumNameGenerator(), Namespace = "Ns"
};
var csharpGenerator = new CSharpValueGenerator(csharpSettings);
var csharpTypeResolver = new CSharpTypeResolver(csharpSettings);
//// Act
var schema = new JsonSchema4()
{
Type = JsonObjectType.String,
Enumeration =
{
"Foo",
"Bar"
},
Default = "Bar"
};
var typescriptSettings = new TypeScriptGeneratorSettings {
EnumNameGenerator = new MyEnumNameGenerator()
};
var typescriptGenerator = new TypeScriptValueGenerator(typescriptSettings);
var typescriptTypeResolver = new TypeScriptTypeResolver(typescriptSettings);
var csharpValue = csharpGenerator.GetDefaultValue(schema, true, "MyEnum", "MyEnum", true, csharpTypeResolver);
var typescriptValue = typescriptGenerator.GetDefaultValue(schema, true, "MyEnum", "MyEnum", true, typescriptTypeResolver);
//// Assert
Assert.Equal("Ns.MyEnum.bar", csharpValue);
Assert.Equal("MyEnum.bar", typescriptValue);
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptClientGeneratorSettings"/> class.</summary>
public TypeScriptClientGeneratorSettings()
{
ClassName = "{controller}Client";
ExceptionClass = "ApiException";
Template = TypeScriptTemplate.Fetch;
PromiseType = PromiseType.Promise;
BaseUrlTokenName = "API_BASE_URL";
ImportRequiredTypes = true;
QueryNullValue = "";
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings
{
SchemaType = SchemaType.Swagger2,
MarkOptionalProperties = true,
TypeNameGenerator = new TypeScriptTypeNameGenerator(),
TypeScriptVersion = 2.7m
};
TypeScriptGeneratorSettings.TemplateFactory = new DefaultTemplateFactory(TypeScriptGeneratorSettings, new Assembly[]
{
typeof(TypeScriptGeneratorSettings).GetTypeInfo().Assembly,
typeof(TypeScriptClientGeneratorSettings).GetTypeInfo().Assembly,
});
ProtectedMethods = new string[0];
}
private async void simpleButton1_Click(object sender, EventArgs e)
{
if (!Directory.Exists(beDest.Text))
{
MessageBox.Show("The target directory does not exist.");
return;
}
var schemaSwagger = await SwaggerDocument.FromUrlAsync(meURL.Text);
TypeScriptGeneratorSettings tsGenSettings = new TypeScriptGeneratorSettings()
{
ConvertConstructorInterfaceData = true,
TypeStyle = TypeScriptTypeStyle.KnockoutClass,
MarkOptionalProperties = true,
GenerateDefaultValues = false,
PropertyNameGenerator = new myPropertyNameGenerator(),
TypeNameGenerator = new myTypeNameGenerator(),
TypeScriptVersion = 2.4m
};
var _resolver = new TypeScriptTypeResolver(tsGenSettings);
_resolver.RegisterSchemaDefinitions(schemaSwagger.Definitions);
var generatorJ = new TypeScriptGenerator(schemaSwagger, tsGenSettings, _resolver);
var typeDef = generatorJ.GenerateTypes();
foreach (CodeArtifact codeArtifact in typeDef.Artifacts)
{
File.WriteAllText(Path.Combine(beDest.Text, codeArtifact.TypeName + ".ts"), meFileHeader.Text + "\n\n" + codeArtifact.Code);
}
}
/// <summary>Initializes a new instance of the <see cref="SwaggerToTypeScriptClientGeneratorSettings"/> class.</summary>
public SwaggerToTypeScriptClientGeneratorSettings()
{
ModuleName = "";
ClassName = "{controller}Client";
Template = TypeScriptTemplate.JQueryCallbacks;
PromiseType = PromiseType.Promise;
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings();
}
public PropertyModel(JsonProperty property, string parentTypeName, TypeScriptTypeResolver resolver, TypeScriptGeneratorSettings settings)
: base(property, new DefaultValueGenerator(resolver), settings)
{
_property = property;
_resolver = resolver;
_parentTypeName = parentTypeName;
_settings = settings;
}
/// <summary>Initializes a new instance of the <see cref="PropertyModel"/> class.</summary>
/// <param name="classTemplateModel">The class template model.</param>
/// <param name="property">The property.</param>
/// <param name="parentTypeName">Name of the parent type.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
public PropertyModel(ClassTemplateModel classTemplateModel, JsonProperty property, string parentTypeName, TypeScriptTypeResolver resolver, TypeScriptGeneratorSettings settings)
: base(property, classTemplateModel, new TypeScriptValueGenerator(resolver, settings), settings)
{
_property = property;
_resolver = resolver;
_parentTypeName = parentTypeName;
_settings = settings;
}
/// <summary>Initializes a new instance of the <see cref="ClassTemplateModel" /> class.</summary>
/// <param name="typeName">The type name.</param>
/// <param name="settings">The settings.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="schema">The schema.</param>
/// <param name="rootObject">The root object.</param>
public ClassTemplateModel(string typeName, TypeScriptGeneratorSettings settings, TypeScriptTypeResolver resolver, JsonSchema4 schema, object rootObject)
{
_typeName = typeName;
_settings = settings;
_schema = schema;
_rootObject = rootObject;
_resolver = resolver;
}
public void Init()
{
var csharpSettings = new CSharpGeneratorSettings();
_csharpGenerator = new CSharpDefaultValueGenerator(new CSharpTypeResolver(csharpSettings, new object()), csharpSettings);
var typescriptSettings = new TypeScriptGeneratorSettings();
_typescriptGenerator = new TypeScriptDefaultValueGenerator(new TypeScriptTypeResolver(typescriptSettings, new object()));
}
public DefaultValueGeneratorTests()
{
var csharpSettings = new CSharpGeneratorSettings();
_csharpTypeResolver = new CSharpTypeResolver(csharpSettings);
_csharpGenerator = new CSharpValueGenerator(csharpSettings);
_typescriptSettings = new TypeScriptGeneratorSettings();
_typescriptGenerator = new TypeScriptValueGenerator(_typescriptSettings);
}
/// <summary>Initializes a new instance of the <see cref="SwaggerToTypeScriptClientGeneratorSettings"/> class.</summary>
public SwaggerToTypeScriptClientGeneratorSettings()
{
ClassName = "{controller}Client";
Template = TypeScriptTemplate.JQueryCallbacks;
PromiseType = PromiseType.Promise;
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings
{
NullHandling = NullHandling.Swagger
};
}
public void Init()
{
var csharpSettings = new CSharpGeneratorSettings();
_csharpGenerator = new CSharpValueGenerator(new CSharpTypeResolver(csharpSettings), csharpSettings);
var typescriptSettings = new TypeScriptGeneratorSettings();
_typescriptGenerator = new TypeScriptValueGenerator(new TypeScriptTypeResolver(typescriptSettings), typescriptSettings);
}
/// <summary>Initializes a new instance of the <see cref="SwaggerToTypeScriptClientGeneratorSettings"/> class.</summary>
public SwaggerToTypeScriptClientGeneratorSettings()
{
ClassName = "{controller}Client";
Template = TypeScriptTemplate.JQueryCallbacks;
PromiseType = PromiseType.Promise;
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings
{
PropertyNullHandling = PropertyNullHandling.Required
};
}
public static string CreateTypescriptClass(JsonSchema4 schema)
{
var settings = new TypeScriptGeneratorSettings {
TypeStyle = TypeScriptTypeStyle.Class, TypeScriptVersion = 2.8m
};
string ts = new TypeScriptGenerator(schema, settings).GenerateFile();
//disable warnings because the generator generates code that is not compatible with the version of eslint
string ignore = "/*eslint eqeqeq: [\"error\", \"smart\"]*/\n";
return(ignore + ts);
}
/// <summary>Initializes a new instance of the <see cref="SwaggerToTypeScriptClientGeneratorSettings"/> class.</summary>
public SwaggerToTypeScriptClientGeneratorSettings()
{
ClassName = "{controller}Client";
Template = TypeScriptTemplate.Fetch;
PromiseType = PromiseType.Promise;
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings
{
NullHandling = NullHandling.Swagger,
TemplateFactory = new DefaultTemplateFactory()
};
}
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);
}
/// <summary>Initializes a new instance of the <see cref="ClassTemplateModel" /> class.</summary>
/// <param name="typeName">The type name.</param>
/// <param name="discriminatorName">The name to compare the discriminator against.</param>
/// <param name="settings">The settings.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="schema">The schema.</param>
/// <param name="rootObject">The root object.</param>
public ClassTemplateModel(string typeName, string discriminatorName,
TypeScriptGeneratorSettings settings, TypeScriptTypeResolver resolver,
JsonSchema4 schema, object rootObject)
: base(resolver, schema, rootObject)
{
_settings = settings;
_schema = schema;
_resolver = resolver;
ClassName = typeName;
DiscriminatorName = discriminatorName;
}
/// <summary>Initializes a new instance of the <see cref="SwaggerToTypeScriptClientGeneratorSettings"/> class.</summary>
public SwaggerToTypeScriptClientGeneratorSettings()
{
ClassName = "{controller}Client";
Template = TypeScriptTemplate.Fetch;
PromiseType = PromiseType.Promise;
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings
{
NullHandling = NullHandling.Swagger,
TemplateFactory = new DefaultTemplateFactory(),
TypeNameGenerator = new TypeScriptTypeNameGenerator()
};
BaseUrlTokenName = "API_BASE_URL";
}
private static string Prepare(TypeScriptTypeStyle style)
{
var schema = JsonSchema4.FromType<MyClassTest>();
var data = schema.ToJson();
var settings = new TypeScriptGeneratorSettings
{
TypeStyle = style
};
//// Act
var generator = new TypeScriptGenerator(schema, settings);
var code = generator.GenerateFile();
return code;
}
/// <summary>Initializes a new instance of the <see cref="SwaggerToTypeScriptClientGeneratorSettings"/> class.</summary>
public SwaggerToTypeScriptClientGeneratorSettings()
{
ClassName = "{controller}Client";
Template = TypeScriptTemplate.Fetch;
PromiseType = PromiseType.Promise;
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings
{
SchemaType = SchemaType.Swagger2,
MarkOptionalProperties = true,
TemplateFactory = new DefaultTemplateFactory(),
TypeNameGenerator = new TypeScriptTypeNameGenerator()
};
BaseUrlTokenName = "API_BASE_URL";
ImportRequiredTypes = true;
}
private static string Prepare(TypeScriptTypeStyle style)
{
var schema = JsonSchema4.FromType <MyClassTest>();
var data = schema.ToJson();
var settings = new TypeScriptGeneratorSettings
{
TypeStyle = style
};
//// Act
var generator = new TypeScriptGenerator(schema, settings);
var code = generator.GenerateFile();
return(code);
}
/// <summary>
/// Generates a TypeScript API client at the given path with the specified settings
/// </summary>
/// <param name="outputFile">File path for the generated client code</param>
/// <param name="configure">Optional settings to further control the code generation process</param>
/// <returns>The metadata source</returns>
/// <example>
/// <code><![CDATA[NSwag.FromSwaggerSpecification("./swagger.json").ToTypeScriptClient("./client.ts");]]></code>
/// </example>
public SwaggerSource ToTypeScriptClient(FilePath outputFile,
Action <TypeScriptGeneratorSettings> configure = null)
{
var settings = new TypeScriptGeneratorSettings();
configure?.Invoke(settings);
var args = Runner.GetToolArguments("swagger2tsclient")
.AddSwitch("input", Source.FullPath)
.AddSwitch("output", outputFile.FullPath)
.AddSwitch("ClassName", settings.ClassName)
.AddSwitch("ModuleName", settings.ModuleName)
.AddSwitch("Template", settings.Template);
Runner.Run(args);
return(this);
}
private static async Task <string> PrepareAsync(TypeScriptTypeStyle style)
{
var schema = await JsonSchema4.FromTypeAsync <MyClassTest>();
var data = schema.ToJson();
var settings = new TypeScriptGeneratorSettings
{
TypeStyle = style
};
//// Act
var generator = new TypeScriptGenerator(schema, settings);
var code = generator.GenerateFile("MyClass");
return(code);
}
/// <summary>Initializes a new instance of the <see cref="ClassTemplateModel" /> class.</summary>
/// <param name="typeName">The type name.</param>
/// <param name="discriminatorName">The name to compare the discriminator against.</param>
/// <param name="settings">The settings.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="schema">The schema.</param>
/// <param name="rootObject">The root object.</param>
public ClassTemplateModel(string typeName, string discriminatorName,
TypeScriptGeneratorSettings settings, TypeScriptTypeResolver resolver,
JsonSchema schema, object rootObject)
: base(resolver, schema, rootObject)
{
_settings = settings;
_schema = schema;
_resolver = resolver;
_discriminatorName = discriminatorName;
ClassName = typeName;
Properties = _schema.ActualProperties.Values
.Where(v => v.IsInheritanceDiscriminator == false)
.Select(property => new PropertyModel(this, property, ClassName, _resolver, _settings))
.ToList();
}
public async Task When_add_export_keyword_is_false_dont_add_export_before_enum_in_typescript()
{
//// Arrange
var schema = JsonSchema.FromType <StringAndIntegerEnumTestClass>(new JsonSchemaGeneratorSettings());
var data = schema.ToJson();
TypeScriptGeneratorSettings typeScriptGeneratorSettings = new TypeScriptGeneratorSettings()
{
ExportTypes = false
};
//// Act
var generator = new TypeScriptGenerator(schema, typeScriptGeneratorSettings);
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.DoesNotContain("export enum", code);
}
public async Task When_export_types_is_true_add_export_before_enum_in_typescript()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <StringAndIntegerEnumTestClass>(new JsonSchemaGeneratorSettings());
var data = schema.ToJson();
TypeScriptGeneratorSettings typeScriptGeneratorSettings = new TypeScriptGeneratorSettings()
{
ExportTypes = true
};
//// Act
var generator = new TypeScriptGenerator(schema, typeScriptGeneratorSettings);
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("export enum", code);
}
/// <summary>Initializes a new instance of the <see cref="SwaggerToTypeScriptClientGeneratorSettings"/> class.</summary>
public SwaggerToTypeScriptClientGeneratorSettings()
{
ClassName = "{controller}Client";
Template = TypeScriptTemplate.Fetch;
PromiseType = PromiseType.Promise;
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings
{
SchemaType = SchemaType.Swagger2,
MarkOptionalProperties = true,
TypeNameGenerator = new TypeScriptTypeNameGenerator()
};
TypeScriptGeneratorSettings.TemplateFactory = new DefaultTemplateFactory(TypeScriptGeneratorSettings);
BaseUrlTokenName = "API_BASE_URL";
ImportRequiredTypes = true;
#if DEBUG
//TypeScriptGeneratorSettings.UseLiquidTemplates = true;
//TypeScriptGeneratorSettings.TemplateDirectory = @"C:\Data\Projects\NJsonSchema\src\NJsonSchema.CodeGeneration.TypeScript\Templates\Liquid";
#endif
}
protected override bool Generate(JsonSchemaItem item, JsonSchemaItemMetadata metadata)
{
try
{
var outputFilePath = item.GetOutputFilePath(TargetLanguage);
var schema = JsonSchema4.FromFileAsync(item.SchemaFile).Result;
var settings = new TypeScriptGeneratorSettings
{
Namespace = metadata.Namespace,
};
var code = new TypeScriptGenerator(schema, settings).GenerateFile();
File.WriteAllText(outputFilePath, code);
return(true);
}
catch (Exception ex)
{
Logger.LogError(ex, item.SchemaFile);
return(false);
}
}
/// <summary>
/// Generates a TypeScript API client at the given path with the specified settings
/// </summary>
/// <param name="outputFile">File path for the generated client code</param>
/// <param name="configure">Optional settings to further control the code generation process</param>
/// <returns>The metadata source</returns>
/// <example>
/// <code><![CDATA[NSwag.FromSwaggerSpecification("./swagger.json").ToTypeScriptClient("./client.ts");]]></code>
/// </example>
public SwaggerSource ToTypeScriptClient(FilePath outputFile,
Action <TypeScriptGeneratorSettings> configure = null)
{
var settings = new TypeScriptGeneratorSettings();
configure?.Invoke(settings);
var genSettings = settings.ClientSettings as SwaggerToTypeScriptClientGeneratorSettings ??
SettingsFactory.GetSwaggerToTypeScriptSettings();
genSettings.ClassName = settings.ClassName;
if (!string.IsNullOrWhiteSpace(settings.ModuleName))
{
genSettings.TypeScriptGeneratorSettings.ModuleName = settings.ModuleName;
}
var service = Swag.SwaggerService.FromJson(FileSystem.ReadContent(Source));
var gen = new SwaggerToTypeScriptClientGenerator(service, genSettings);
var ts = gen.GenerateFile();
FileSystem.WriteContent(outputFile, ts);
return(this);
}
public PropertyModel(JsonProperty property, TypeScriptTypeResolver resolver, TypeScriptGeneratorSettings settings, TypeScriptGenerator generator)
: base(property)
{
var propertyName = ConversionUtilities.ConvertToLowerCamelCase(property.Name).Replace("-", "_");
Name = property.Name;
InterfaceName = property.Name.Contains("-") ? '\"' + property.Name + '\"' : property.Name;
PropertyName = propertyName;
Type = resolver.Resolve(property.ActualPropertySchema, property.IsNullable, property.Name);
DataConversionCode = settings.TypeStyle == TypeScriptTypeStyle.Interface ? string.Empty : generator.GenerateDataConversion(
settings.TypeStyle == TypeScriptTypeStyle.Class ? "this." + propertyName : propertyName,
"data[\"" + property.Name + "\"]",
property.ActualPropertySchema,
property.IsNullable,
property.Name);
Description = property.Description;
HasDescription = !string.IsNullOrEmpty(property.Description);
IsArray = property.ActualPropertySchema.Type.HasFlag(JsonObjectType.Array);
ArrayItemType = resolver.TryResolve(property.ActualPropertySchema.Item, property.Name);
IsReadOnly = property.IsReadOnly && settings.GenerateReadOnlyKeywords;
IsOptional = !property.IsRequired;
}
/// <summary>Initializes a new instance of the <see cref="FileTemplateModel"/> class.</summary>
/// <param name="settings">The settings.</param>
public FileTemplateModel(TypeScriptGeneratorSettings settings)
{
_settings = settings;
}
public static void Generate(string assembly, string @namespace, string output)
{
var dir = Directory.GetCurrentDirectory();
var loader = PluginLoader.CreateFromAssemblyFile(assembly);
var defaultAssembly = loader.LoadDefaultAssembly();
var messages =
from t in defaultAssembly.GetTypes()
where t.IsClass || t.IsValueType
where !t.IsPrimitive && !string.IsNullOrEmpty(t.Namespace)
where t.Namespace.StartsWith(@namespace)
let attributes = t.GetCustomAttributes(typeof(DataContractAttribute), true)
where attributes != null && attributes.Length > 0
select t;
var validatorFactory = new ValidatorFactory(defaultAssembly);
var schemaProcessor = new FluentValidationSchemaProcessor(validatorFactory);
var settings = new JsonSchemaGeneratorSettings();
settings.SchemaProcessors.Add(schemaProcessor);
settings.DefaultReferenceTypeNullHandling = ReferenceTypeNullHandling.NotNull;
var schema = new JsonSchema(); // the schema to write into
var resolver = new JsonSchemaResolver(schema, settings); // used to add and retrieve schemas from the 'definitions'
var generator = new JsonSchemaGenerator(settings);
var tsSettings = new TypeScriptGeneratorSettings
{
TypeStyle = TypeScriptTypeStyle.Class,
TypeScriptVersion = 3.7m,
};
Directory.CreateDirectory(output);
var mainModule = "";
foreach (var type in messages)
{
var schemaForType = generator.Generate(type, resolver);
schemaForType.Title = type.Name;
var codeGenerator = new TypeScriptGenerator(schemaForType, tsSettings);
var code = codeGenerator.GenerateFile();
using (var sourceFile = File.Open($"{output}/{type.Name}.ts", FileMode.Create))
{
sourceFile.Write(Encoding.UTF8.GetBytes(code));
sourceFile.Flush();
}
mainModule += $"export * from './{type.Name}'\n";
}
using (var mainFile = File.Open($"{output}/index.ts", FileMode.Create))
{
mainFile.Write(Encoding.UTF8.GetBytes(mainModule));
mainFile.Flush();
}
Console.WriteLine(schema.ToJson());
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptValueGenerator"/> class.</summary>
/// <param name="settings">The settings.</param>
public TypeScriptValueGenerator(TypeScriptGeneratorSettings settings)
: base(settings)
{
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptGenerator"/> class.</summary>
/// <param name="schema">The schema.</param>
/// <param name="settings">The generator settings.</param>
/// <param name="resolver">The resolver.</param>
public TypeScriptGenerator(JsonSchema4 schema, TypeScriptGeneratorSettings settings, TypeScriptTypeResolver resolver)
{
_schema = schema;
_resolver = resolver;
Settings = settings;
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptGenerator"/> class.</summary>
/// <param name="settings">The generator settings.</param>
/// <param name="schema">The schema.</param>
public TypeScriptGenerator(JsonSchema4 schema, TypeScriptGeneratorSettings settings)
: this(schema, settings, new TypeScriptTypeResolver(settings))
{
}
