gen

Documentation

Index

• Constants
• Variables
• type Arg
• type Generator
• type GeneratorArg
• type GeneratorFunc

Constants

const Client = "client"

const ClientDescription = "client HTTP library"

const GeneratePath = "generate-path"

const GeneratePathDescription = "path to generate source code into"

const Jsonlib = "jsonlib"

const JsonlibDescription = "json serialization/deserialization library"

const ModuleName = "module-name"

const ModuleNameDescription = "module name"

const PackageName = "package-name"

const PackageNameDescription = "package name"

const Server = "server"

const ServerDescription = "server HTTP library/framework"

const ServicesPath = "services-path"

const ServicesPathDescription = "path to scaffold services code"

const SpecFile = "spec-file"

const SpecFileDescription = "path to specification file"

const SwaggerPath = "swagger-path"

const SwaggerPathDescription = "path of generated OpenAPI (Swagger) specification file"

const Validation = "validation"

const ValidationDescription = "type validation library"

Variables

var ArgClient = Arg{Client, ClientDescription}

var ArgGeneratePath = Arg{GeneratePath, GeneratePathDescription}

var ArgJsonlib = Arg{Jsonlib, JsonlibDescription}

var ArgModuleName = Arg{ModuleName, ModuleNameDescription}

var ArgPackageName = Arg{PackageName, PackageNameDescription}

var ArgServer = Arg{Server, ServerDescription}

var ArgServicesPath = Arg{ServicesPath, ServicesPathDescription}

var ArgSpecFile = Arg{SpecFile, SpecFileDescription}

var ArgSwaggerPath = Arg{SwaggerPath, SwaggerPathDescription}

var ArgValidation = Arg{Validation, ValidationDescription}

var ClientGo = Generator{
	"client-go",
	"Generate Go client source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgModuleName, Required: true},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return gengo.GenerateClient(specification, params[ArgModuleName], params[ArgGeneratePath])
	},
}

var ClientJava = Generator{
	"client-java",
	"Generate Java client source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgJsonlib, Required: true, Values: JsonlibJavaValues},
		{Arg: ArgPackageName, Required: true},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genjava.GenerateClient(specification, params[ArgJsonlib], params[ArgPackageName], params[ArgGeneratePath])
	},
}

var ClientKotlin = Generator{
	"client-kotlin",
	"Generate Kotlin client source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgPackageName, Required: true},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genkotlin.GenerateClient(specification, params[ArgPackageName], params[ArgGeneratePath])
	},
}

var ClientRuby = Generator{
	"client-ruby",
	"Generate Ruby client source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genruby.GenerateClient(specification, params[ArgGeneratePath])
	},
}

var ClientScala = Generator{
	"client-scala",
	"Generate Scala client source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genscala.GenerateSttpClient(specification, "", params[ArgGeneratePath])
	},
}

var ClientTs = Generator{
	"client-ts",
	"Generate TypeScript client source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgClient, Required: true, Values: ClientTsValues},
		{Arg: ArgValidation, Required: true, Values: ValidationTsValues},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return gents.GenerateClient(specification, params[ArgGeneratePath], params[ArgClient], params[ArgValidation])
	},
}

var ClientTsValues = []string{"axios", "node-fetch", "browser-fetch"}

var Generators = []Generator{
	ModelsGo,
	ClientGo,
	ServiceGo,
	ModelsJava,
	ClientJava,
	ServiceJava,
	ModelsKotlin,
	ClientKotlin,
	ModelsRuby,
	ClientRuby,
	ModelsScala,
	ClientScala,
	ServiceScala,
	ModelsTs,
	ClientTs,
	ServiceTs,
}

var JsonlibJavaValues = []string{"jackson", "moshi"}

var ModelsGo = Generator{
	"models-go",
	"Generate Go models source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgModuleName, Required: true},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return gengo.GenerateModels(specification, params[ArgModuleName], params[ArgGeneratePath])
	},
}

var ModelsJava = Generator{
	"models-java",
	"Generate Java models source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgJsonlib, Required: true, Values: JsonlibJavaValues},
		{Arg: ArgPackageName, Required: false},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genjava.GenerateModels(specification, params[ArgJsonlib], params[ArgPackageName], params[ArgGeneratePath])
	},
}

var ModelsKotlin = Generator{
	"models-kotlin",
	"Generate Kotlin models source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgJsonlib, Required: false, Default: "jackson"},
		{Arg: ArgPackageName, Required: false},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genkotlin.GenerateModels(specification, params[ArgPackageName], params[ArgGeneratePath])
	},
}

var ModelsRuby = Generator{
	"models-ruby",
	"Generate Ruby models source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genruby.GenerateModels(specification, params[ArgGeneratePath])
	},
}

var ModelsScala = Generator{
	"models-scala",
	"Generate Scala models source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genscala.GenerateCirceModels(specification, "", params[ArgGeneratePath])
	},
}

var ModelsTs = Generator{
	"models-ts",
	"Generate TypeScript models source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgValidation, Required: true, Values: ValidationTsValues},
		{Arg: ArgGeneratePath, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return gents.GenerateModels(specification, params[ArgValidation], params[ArgGeneratePath])
	},
}

var ServerTsValues = []string{"express", "koa"}

var ServiceGo = Generator{
	"service-go",
	"Generate Go service source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgModuleName, Required: true},
		{Arg: ArgSwaggerPath, Required: false},
		{Arg: ArgGeneratePath, Required: true},
		{Arg: ArgServicesPath, Required: false},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return gengo.GenerateService(specification, params[ArgModuleName], params[ArgSwaggerPath], params[ArgGeneratePath], params[ArgServicesPath])
	},
}

var ServiceJava = Generator{
	"service-java",
	"Generate Java service source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgJsonlib, Required: true, Values: JsonlibJavaValues},
		{Arg: ArgPackageName, Required: false},
		{Arg: ArgSwaggerPath, Required: false},
		{Arg: ArgGeneratePath, Required: true},
		{Arg: ArgServicesPath, Required: false},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genjava.GenerateService(specification, params[ArgJsonlib], params[ArgPackageName], params[ArgSwaggerPath], params[ArgGeneratePath], params[ArgServicesPath])
	},
}

var ServiceScala = Generator{
	"service-scala",
	"Generate Scala service source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgSwaggerPath, Required: false},
		{Arg: ArgGeneratePath, Required: true},
		{Arg: ArgServicesPath, Required: false},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return genscala.GeneratePlayService(specification, params[ArgSwaggerPath], params[ArgGeneratePath], params[ArgServicesPath])
	},
}

var ServiceTs = Generator{
	"service-ts",
	"Generate TypeScript client source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgServer, Required: true, Values: ServerTsValues},
		{Arg: ArgValidation, Required: true, Values: ValidationTsValues},
		{Arg: ArgGeneratePath, Required: true},
		{Arg: ArgServicesPath, Required: false},
		{Arg: ArgSwaggerPath, Required: false},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		return gents.GenerateService(specification, params[ArgSwaggerPath], params[ArgGeneratePath], params[ArgServicesPath], params[ArgServer], params[ArgValidation])
	},
}

var ValidationTsValues = []string{"superstruct", "io-ts"}

Types

type Arg

type Arg struct {
	Name        string
	Description string
}

type Generator

type Generator struct {
	Name      string
	Usage     string
	Args      []GeneratorArg
	Generator GeneratorFunc
}

type GeneratorArg

type GeneratorArg struct {
	Arg
	Values   []string
	Required bool
	Default  string
}

type GeneratorFunc

type GeneratorFunc func(specification *spec.Spec, params map[Arg]string) *sources.Sources