generators

Documentation

Index

• type ControllerGenerator
  • func NewControllerGenerator(side Side, spec asyncapi.Specification) ControllerGenerator
  • func (asg ControllerGenerator) Generate() (string, error)
• type ImportsGenerator
  • func (ig ImportsGenerator) Generate() (string, error)
• type Options
• type Side
• type SubscriberGenerator
  • func NewSubscriberGenerator(side Side, spec asyncapi.Specification) SubscriberGenerator
  • func (asg SubscriberGenerator) Generate() (string, error)
• type TypesGenerator
  • func (tg TypesGenerator) Generate() (string, error)

Types

type ControllerGenerator

type ControllerGenerator struct {
	MethodCount       uint
	SubscribeChannels map[string]*asyncapi.Channel
	PublishChannels   map[string]*asyncapi.Channel
	Prefix            string
	Version           string
}

ControllerGenerator is a code generator for controllers that will turn an asyncapi specification into controller golang code.

func NewControllerGenerator

func NewControllerGenerator(side Side, spec asyncapi.Specification) ControllerGenerator

NewControllerGenerator will create a new controller code generator.

func (ControllerGenerator) Generate

func (asg ControllerGenerator) Generate() (string, error)

Generate will generate the controller code.

type ImportsGenerator

type ImportsGenerator struct {
	PackageName   string
	ModuleVersion string
	ModuleName    string
	CustomImports []string
}

ImportsGenerator is a code generator for imports that will add needed imports to the code, being asyncapi-codegen packages, standard library packages or custom packages.

func (ImportsGenerator) Generate

func (ig ImportsGenerator) Generate() (string, error)

Generate will generate the imports code.

type Options

type Options struct {
	// Application should be true for application code generation to be generated
	Application bool
	// User should be true for user code generation to be generated
	User bool
	// Types should be true for type code (or common code) generation to be generated
	Types bool
}

Options are the options to activate some parts of code generation.

type Side

type Side string

Side represents the side of the code generation based on asyncapi documentation, i.e in front (user) or behind (application) asyncapi specification.

const (
	// SideIsApplication is the application side based on asyncapi documentation,
	// i.e. the side that stand behind of the asyncapi specification.
	SideIsApplication Side = "app"
	// SideIsUser is the user side based on asyncapi documentation,
	// i.e. the side that use the asyncapi specification.
	SideIsUser Side = "user"
)

type SubscriberGenerator

type SubscriberGenerator struct {
	MethodCount uint
	Channels    map[string]*asyncapi.Channel
	Prefix      string
}

SubscriberGenerator is a code generator for subscribers that will turn an asyncapi specification into subscriber golang code.

func NewSubscriberGenerator

func NewSubscriberGenerator(side Side, spec asyncapi.Specification) SubscriberGenerator

NewSubscriberGenerator will create a new subscriber code generator.

func (SubscriberGenerator) Generate

func (asg SubscriberGenerator) Generate() (string, error)

Generate will generate the subscriber code.

type TypesGenerator

type TypesGenerator struct {
	asyncapi.Specification
}

TypesGenerator is a code generator for types that will generate all schemas contained in an asyncapi specification to golang structures code.

func (TypesGenerator) Generate

func (tg TypesGenerator) Generate() (string, error)

Generate will create a new types code generator.