generator

type APIExtension struct {
	// ImportPaths contains a list of import path that the file should add to the import list.
	// The paths must be registered with the TemplateExtension's Dependencies fields.
	ImportPaths []string `json:"import_paths,omitempty" yaml:"import_paths,omitempty"`

	// Code snippets to be inserted in the NewX function before assembling options.
	// It must be a template definition with a name identical to the one kitex uses.
	ExtendOption string `json:"extend_option,omitempty" yaml:"extend_option,omitempty"`

	// Code snippets to be appended to the file.
	// It must be a template definition with a name identical to the one kitex uses.
	ExtendFile string `json:"extend_file,omitempty" yaml:"extend_file,omitempty"`
}

type Config struct {
	Verbose               bool
	GenerateMain          bool // whether stuff in the main package should be generated
	GenerateInvoker       bool // generate main.go with invoker when main package generate
	Version               string
	NoFastAPI             bool
	ModuleName            string
	ServiceName           string
	Use                   string
	IDLType               string
	Includes              util.StringSlice
	ThriftOptions         util.StringSlice
	ProtobufOptions       util.StringSlice
	IDL                   string // the IDL file passed on the command line
	OutputPath            string // the output path for main pkg and kitex_gen
	PackagePrefix         string
	CombineService        bool // combine services to one service
	CopyIDL               bool
	ThriftPlugins         util.StringSlice
	ProtobufPlugins       util.StringSlice
	Features              []feature
	FrugalPretouch        bool
	ThriftPluginTimeLimit time.Duration

	ExtensionFile string

	Record    bool
	RecordCmd []string

	TemplateDir string

	GenPath string

	DeepCopyAPI bool
	// contains filtered or unexported fields
}

type File struct {
	Name    string
	Content string
}

type Generator interface {
	GenerateService(pkg *PackageInfo) ([]*File, error)
	GenerateMainPackage(pkg *PackageInfo) ([]*File, error)
	GenerateCustomPackage(pkg *PackageInfo) ([]*File, error)
}

type HandleFunc func(*Task, *PackageInfo) (*File, error)

type MethodInfo struct {
	PkgInfo
	ServiceName            string
	Name                   string
	RawName                string
	Oneway                 bool
	Void                   bool
	Args                   []*Parameter
	Resp                   *Parameter
	Exceptions             []*Parameter
	ArgStructName          string
	ResStructName          string
	IsResponseNeedRedirect bool // int -> int*
	GenArgResultStruct     bool
	ClientStreaming        bool
	ServerStreaming        bool
}

type Middleware func(HandleFunc) HandleFunc

type PackageInfo struct {
	Namespace    string            // a dot-separated string for generating service package under kitex_gen
	Dependencies map[string]string // package name => import path, used for searching imports
	*ServiceInfo                   // the target service

	// the following fields will be filled and used by the generator
	Codec            string
	NoFastAPI        bool
	Version          string
	RealServiceName  string
	Imports          map[string]map[string]bool // import path => alias
	ExternalKitexGen string
	Features         []feature
	FrugalPretouch   bool
	Module           string
}

type Parameter struct {
	Deps    []PkgInfo
	Name    string
	RawName string
	Type    string // *PkgA.StructB
}

type PkgInfo struct {
	PkgName    string
	PkgRefName string
	ImportPath string
}

type ServiceInfo struct {
	PkgInfo
	ServiceName     string
	RawServiceName  string
	ServiceTypeName func() string
	Base            *ServiceInfo
	Methods         []*MethodInfo
	CombineServices []*ServiceInfo
	HasStreaming    bool
}

type Task struct {
	Name string
	Path string
	Text string
	*template.Template
	Ext *APIExtension
}

type Template struct {
	// The generated path and its filename. For example: biz/test.go
	// will generate test.go in biz directory.
	Path string `yaml:"path,omitempty"`
	// Render template content, currently only supports go template syntax
	Body string `yaml:"body,omitempty"`
	// define update behavior
	UpdateBehavior *Update `yaml:"update_behavior,omitempty"`
	// If set this field, kitex will generate file by cycle. For example:
	// test_a/test_b/{{ .Name}}_test.go
	LoopMethod bool `yaml:"loop_method,omitempty"`
	// If both set this field and combine-service, kitex will generate service by cycle.
	LoopService bool `yaml:"loop_service,omitempty"`
}

type TemplateExtension struct {
	// FeatureNames registers some names to the scope for the code generating phrase, where templates can use the `HasFeature` function to query.
	FeatureNames []string `json:"feature_names,omitempty" yaml:"feature_names,omitempty"`

	// EnableFeatures marks on which features that `HasFeature` queries should return true.
	EnableFeatures []string `json:"enable_features,omitempty" yaml:"enable_features,omitempty"`

	// Dependencies is a mapping from import path to package names/aliases.
	Dependencies map[string]string `json:"dependencies,omitempty" yaml:"dependencies,omitempty"`

	// Extension for client.go .
	ExtendClient *APIExtension `json:"extend_client,omitempty" yaml:"extend_client,omitempty"`

	// Extension for server.go .
	ExtendServer *APIExtension `json:"extend_server,omitempty" yaml:"extend_server,omitempty"`

	// Extension for invoker.go .
	ExtendInvoker *APIExtension `json:"extend_invoker,omitempty" yaml:"extend_invoker,omitempty"`
}

type Update struct {
	// update type: skip / cover / append. Default is skip.
	// If `LoopMethod` is true, only Type field is effect and no append behavior.
	Type string `yaml:"type,omitempty"`
	// Match key in append type. If the rendered key exists in the file, the method will be skipped.
	Key string `yaml:"key,omitempty"`
	// Append template. Use it to render append content.
	AppendTpl string `yaml:"append_tpl,omitempty"`
	// Append import template. Use it to render import content to append.
	ImportTpl []string `yaml:"import_tpl,omitempty"`
}