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
	Hessian2Options       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 // package prefix ends with `GenPath`, like: github.com/cloudwego/blabla/kitex_gen
	CombineService        bool   // combine services to one service
	CopyIDL               bool
	ThriftPlugins         util.StringSlice
	ProtobufPlugins       util.StringSlice
	Features              []feature
	FrugalPretouch        bool
	ThriftPluginTimeLimit time.Duration
	CompilerPath          string // specify the path of thriftgo or protoc

	ExtensionFile string

	Record    bool
	RecordCmd []string

	TemplateDir string

	GenPath string // default: "kitex_gen"

	DeepCopyAPI           bool
	Protocol              string
	HandlerReturnKeepResp bool

	NoDependencyCheck bool
	Rapid             bool
	LocalThriftgo     bool

	FrugalStruct util.StringSlice
	NoRecurse    bool

	BuiltinTpl util.StringSlice // specify the built-in template to use

	StreamX 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                `json:"pkg_info"`
	ServiceName            string       `json:"service_name,omitempty"`
	Name                   string       `json:"name,omitempty"`
	RawName                string       `json:"raw_name,omitempty"`
	Oneway                 bool         `json:"oneway,omitempty"`
	Void                   bool         `json:"void,omitempty"`
	Args                   []*Parameter `json:"args,omitempty"`
	ArgsLength             int          `json:"args_length,omitempty"`
	Resp                   *Parameter   `json:"resp,omitempty"`
	Exceptions             []*Parameter `json:"exceptions,omitempty"`
	ArgStructName          string       `json:"arg_struct_name,omitempty"`
	ResStructName          string       `json:"res_struct_name,omitempty"`
	IsResponseNeedRedirect bool         `json:"is_response_need_redirect,omitempty"` // int -> int*
	GenArgResultStruct     bool         `json:"gen_arg_result_struct,omitempty"`
	IsStreaming            bool         `json:"is_streaming,omitempty"`
	ClientStreaming        bool         `json:"client_streaming,omitempty"`
	ServerStreaming        bool         `json:"server_streaming,omitempty"`
}

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
	Services     []*ServiceInfo    // all services defined in a IDL for multiple services scenario

	// 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
	Protocol         transport.Protocol
	IDLName          string
	ServerPkg        string
	StreamX          bool
}

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
	ServiceFilePath       string
	Protocol              string
	HandlerReturnKeepResp bool
	UseThriftReflection   bool
	// for multiple services scenario, the reference name for the service
	RefName string
	// identify whether this service would generate a corresponding handler.
	GenerateHandler 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"`
}