gen

Documentation

Index

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

Constants

const Client = "client"

const ClientDescription = "client HTTP library"

const ClientTitle = "Client library"

const GeneratePath = "generate-path"

const GeneratePathDescription = "path to generate source code into"

const GeneratePathTitle = "Generate path"

const Jsonlib = "jsonlib"

const JsonlibDescription = "json serialization/deserialization library"

const JsonlibTitle = "JSON library"

const ModuleName = "module-name"

const ModuleNameDescription = "module name"

const ModuleNameTitle = "Module name"

const OutFile = "out-file"

const OutFileDescription = "path to output file"

const OutFileTitle = "Output file path"

const PackageName = "package-name"

const PackageNameDescription = "package name"

const PackageNameTitle = "Package name"

const Server = "server"

const ServerDescription = "server HTTP library/framework"

const ServerTitle = "Server library"

const ServicesPath = "services-path"

const ServicesPathDescription = "path to scaffold services code"

const ServicesPathTitle = "Services path"

const SpecFile = "spec-file"

const SpecFileDescription = "path to specification file"

const SpecFileTitle = "Spec file path"

const SwaggerPath = "swagger-path"

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

const SwaggerPathTitle = "Swagger path"

const Validation = "validation"

const ValidationDescription = "type validation library"

const ValidationTitle = "Type validation library"

Variables

var ArgClient = Arg{Client, ClientTitle, ClientDescription}

var ArgGeneratePath = Arg{GeneratePath, GeneratePathTitle, GeneratePathDescription}

var ArgJsonlib = Arg{Jsonlib, JsonlibTitle, JsonlibDescription}

var ArgModuleName = Arg{ModuleName, ModuleNameTitle, ModuleNameDescription}

var ArgOutFile = Arg{OutFile, OutFileTitle, OutFileDescription}

var ArgPackageName = Arg{PackageName, PackageNameTitle, PackageNameDescription}

var ArgServer = Arg{Server, ServerTitle, ServerDescription}

var ArgServicesPath = Arg{ServicesPath, ServicesPathTitle, ServicesPathDescription}

var ArgSpecFile = Arg{SpecFile, SpecFileTitle, SpecFileDescription}

var ArgSwaggerPath = Arg{SwaggerPath, SwaggerPathTitle, SwaggerPathDescription}

var ArgValidation = Arg{Validation, ValidationTitle, ValidationDescription}

var ClientGo = Generator{
	"client-go",
	"Go Client",
	"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 golang.GenerateClient(specification, params[ArgModuleName], params[ArgGeneratePath])
	},
}

var ClientJava = Generator{
	"client-java",
	"Java Client",
	"Generate Java client 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 java.GenerateClient(specification, params[ArgJsonlib], params[ArgPackageName], params[ArgGeneratePath])
	},
}

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

var ClientRuby = Generator{
	"client-ruby",
	"Ruby Client",
	"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 ruby.GenerateClient(specification, params[ArgGeneratePath])
	},
}

var ClientScala = Generator{
	"client-scala",
	"Scala Client",
	"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 scala.GenerateSttpClient(specification, "", params[ArgGeneratePath])
	},
}

var ClientTs = Generator{
	"client-ts",
	"TypeScript Client",
	"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 ts.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,
	ServiceKotlin,
	ModelsRuby,
	ClientRuby,
	ModelsScala,
	ClientScala,
	ServiceScala,
	ModelsTs,
	ClientTs,
	ServiceTs,
	Openapi,
}

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

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

var ModelsGo = Generator{
	"models-go",
	"Go Models",
	"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 golang.GenerateModels(specification, params[ArgModuleName], params[ArgGeneratePath])
	},
}

var ModelsJava = Generator{
	"models-java",
	"Java Models",
	"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 java.GenerateModels(specification, params[ArgJsonlib], params[ArgPackageName], params[ArgGeneratePath])
	},
}

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

var ModelsRuby = Generator{
	"models-ruby",
	"Ruby Models",
	"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 ruby.GenerateModels(specification, params[ArgGeneratePath])
	},
}

var ModelsScala = Generator{
	"models-scala",
	"Scala Models",
	"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 scala.GenerateCirceModels(specification, "", params[ArgGeneratePath])
	},
}

var ModelsTs = Generator{
	"models-ts",
	"TypeScript Models",
	"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 ts.GenerateModels(specification, params[ArgValidation], params[ArgGeneratePath])
	},
}

var Openapi = Generator{
	"openapi",
	"OpenAPI v3",
	"Generate OpenAPI specification",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgOutFile, Required: true},
	},
	func(specification *spec.Spec, params map[Arg]string) *sources.Sources {
		openapiFile := openapi.GenerateOpenapi(specification, params[ArgOutFile])
		sources := sources.NewSources()
		sources.AddGenerated(openapiFile)
		return sources
	},
}

var ServerJavaValues = []string{"spring", "micronaut"}

var ServerKotlinValues = []string{"micronaut"}

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

var ServiceGo = Generator{
	"service-go",
	"Go Service",
	"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 golang.GenerateService(specification, params[ArgModuleName], params[ArgSwaggerPath], params[ArgGeneratePath], params[ArgServicesPath])
	},
}

var ServiceJava = Generator{
	"service-java",
	"Java Service",
	"Generate Java service source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgJsonlib, Required: true, Values: JsonlibJavaValues},
		{Arg: ArgServer, Required: true, Values: ServerJavaValues},
		{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 java.GenerateService(specification, params[ArgJsonlib], params[ArgServer], params[ArgPackageName], params[ArgSwaggerPath], params[ArgGeneratePath], params[ArgServicesPath])
	},
}

var ServiceKotlin = Generator{
	"service-kotlin",
	"Kotlin Service",
	"Generate Kotlin service source code",
	[]GeneratorArg{
		{Arg: ArgSpecFile, Required: true},
		{Arg: ArgJsonlib, Required: true, Values: JsonlibKotlinValues},
		{Arg: ArgServer, Required: true, Values: ServerKotlinValues},
		{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 kotlin.GenerateService(specification, params[ArgJsonlib], params[ArgServer], params[ArgPackageName], params[ArgSwaggerPath], params[ArgGeneratePath], params[ArgServicesPath])
	},
}

var ServiceScala = Generator{
	"service-scala",
	"Scala Service",
	"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 scala.GeneratePlayService(specification, params[ArgSwaggerPath], params[ArgGeneratePath], params[ArgServicesPath])
	},
}

var ServiceTs = Generator{
	"service-ts",
	"TypeScript Service",
	"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 ts.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
	Title       string
	Description string
}

type Generator

type Generator struct {
	Name      string
	Title     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