generator

type Backend interface {
	Template() (*template.Template, error)
	List() map[string]string                 // returns template name -> body mapping
	SetOption(opts string) error             // configures generation options (e.g. MarshalEnumToText)
	GetOptions() []string                    // returns active options
	Funcs(name string, fn interface{}) error // registers custom template functions
}

type Client struct {
	Handler
	ServiceName string
}

type ClientConfig struct {
	QueryEnumAsInt bool
}

type ClientFile struct {
	Config        ClientConfig
	FilePath      string
	PackageName   string
	ServiceName   string
	BaseDomain    string
	Imports       map[string]*model.Model
	ClientMethods []*ClientMethod
}

type ClientMethod struct {
	*HttpMethod
	BodyParamsCode   string
	QueryParamsCode  string
	PathParamsCode   string
	HeaderParamsCode string
	FormValueCode    string
	FormFileCode     string
}

type CustomizedFileForIDL struct {
	*IDLPackageRenderInfo
	FilePath    string
	FilePackage string
}

type CustomizedFileForMethod struct {
	*HttpMethod
	FilePath       string
	FilePackage    string
	ServiceInfo    *Service              // service info for this method
	IDLPackageInfo *IDLPackageRenderInfo // IDL info for this service
}

type CustomizedFileForService struct {
	*Service
	FilePath       string
	FilePackage    string
	IDLPackageInfo *IDLPackageRenderInfo // IDL info for this service
}

type File struct {
	Path        string // relative output path
	Content     string // rendered file content
	NoRepeat    bool   // if true, skip writing when file already exists
	FileTplName string // source template name (used to determine update warnings)
}

type FilePathRenderInfo struct {
	MasterIDLName  string // master IDL name
	GenPackage     string // master IDL generate code package
	HandlerDir     string // handler generate dir
	ModelDir       string // model generate dir
	RouterDir      string // router generate dir
	ProjectDir     string // projectDir
	GoModule       string // go module
	ServiceName    string // service name, changed as services are traversed
	MethodName     string // method name, changed as methods are traversed
	HandlerGenPath string // "api.gen_path" value
}

type GolangBackend struct{}

type Handler struct {
	FilePath    string
	PackageName string
	ProjPackage string
	Imports     map[string]*model.Model
	Methods     []*HttpMethod
}

type HttpMethod struct {
	Name               string
	HTTPMethod         string                  // GET, POST, PUT, DELETE, etc.
	Comment            string                  // doc comment (formatted by InitComment)
	RequestTypeName    string                  // Go type name for request struct
	RequestTypePackage string                  // import path for request type
	RequestTypeRawName string                  // original IDL name before Go conversion
	ReturnTypeName     string                  // Go type name for response struct
	ReturnTypePackage  string                  // import path for response type
	ReturnTypeRawName  string                  // original IDL name before Go conversion
	Path               string                  // HTTP route path (e.g. "/api/v1/users/:id")
	Serializer         string                  // serialization format: JSON, Thrift, ProtoBuf
	OutputDir          string                  // handler output subdirectory (for handler_by_method mode)
	RefPackage         string                  // handler import path (set during router tree construction)
	RefPackageAlias    string                  // handler import alias
	ModelPackage       map[string]string       // model package aliases
	GenHandler         bool                    // false to skip handler generation (dedup for multi-method IDL)
	Models             map[string]*model.Model // all model dependencies for this method
}

type HttpPackage struct {
	IdlName    string
	Package    string
	Services   []*Service
	Models     []*model.Model
	RouterInfo *Router
}

type HttpPackageGenerator struct {
	ConfigPath     string       // path to custom package template YAML config
	Backend        meta.Backend // model code generation backend (e.g. "golang")
	Options        []Option     // model generation options (e.g. MarshalEnumToText)
	CmdType        string       // current command: new/update/model/client
	ProjPackage    string       // Go module path (e.g. "github.com/foo/bar")
	HandlerDir     string       // relative path for handler output
	RouterDir      string       // relative path for router output
	ModelDir       string       // relative path for model output (e.g. "biz/model")
	UseDir         string       // external model package to import instead of generating
	ClientDir      string       // client output dir for "new"/"update" commands
	IdlClientDir   string       // default client dir derived from IDL namespace (for "client" command)
	ForceClientDir string       // client dir without IDL namespace subdirectories
	BaseDomain     string       // default request domain for generated client code
	QueryEnumAsInt bool         // use numeric values for enum query parameters in client code
	ServiceGenDir  string       // per-service handler directory override

	NeedModel            bool // whether to generate model .go files (false when -use is specified)
	HandlerByMethod      bool // one handler file per method (vs one per service)
	SnakeStyleMiddleware bool // use snake_case naming for middleware functions
	SortRouter           bool // sort router registration for deterministic output
	ForceUpdateClient    bool // regenerate hertz_client.go even if it exists

	TemplateGenerator
	// contains filtered or unexported fields
}

type IDLPackageRenderInfo struct {
	FilePathRenderInfo
	ServiceInfos *HttpPackage
}

type Layout struct {
	OutDir          string
	GoModule        string
	ServiceName     string
	UseApacheThrift bool
	HasIdl          bool
	NeedGoMod       bool
	ModelDir        string
	HandlerDir      string
	RouterDir       string
}

type LayoutGenerator struct {
	ConfigPath string
	TemplateGenerator
}

type Option string

type RegisterInfo struct {
	PackageName string
	DepPkgAlias string
	DepPkg      string
}

type Router struct {
	FilePath        string
	PackageName     string
	HandlerPackages map[string]string // package alias -> import path
	Router          *RouterNode
}

type RouterNode struct {
	GroupName         string // parent's middleware var name, used for route registration (e.g. root.GET)
	MiddleWare        string // this node's middleware var name, becomes GroupName for children
	HandlerMiddleware string // middleware name specific to this handler (may differ from GroupMiddleware)
	GroupMiddleware   string // middleware name for the route group (may use snake_case or camelCase)
	PathPrefix        string // accumulated path prefix for snake-style middleware naming

	Path     string
	Parent   *RouterNode
	Children childrenRouterInfo

	Handler             string // qualified handler call: "pkg.HandlerName"
	HandlerPackage      string // handler import path
	HandlerPackageAlias string // handler import alias
	HttpMethod          string // HTTP method (GET, POST, etc.) or "" for group-only nodes
}

type Service struct {
	Name          string
	Methods       []*HttpMethod
	ClientMethods []*ClientMethod
	Models        []*model.Model // all dependency models
	BaseDomain    string         // base domain for client code
	ServiceGroup  string         // service level router group
	ServiceGenDir string         // handler_dir for handler_by_service
}

type SingleHandler struct {
	*HttpMethod
	FilePath    string
	PackageName string
	ProjPackage string
}

type Template struct {
	Default        bool           // Is it the default template
	Path           string         `yaml:"path"`            // The generated path and its filename, such as biz/handler/ping.go
	Delims         [2]string      `yaml:"delims"`          // Template Action Instruction Identifier, default: "{{}}"
	Body           string         `yaml:"body"`            // Render template, currently only supports go template syntax
	Disable        bool           `yaml:"disable"`         // Disable generating file, used to disable default package template
	LoopMethod     bool           `yaml:"loop_method"`     // Loop generate files based on "method"
	LoopService    bool           `yaml:"loop_service"`    // Loop generate files based on "service"
	UpdateBehavior UpdateBehavior `yaml:"update_behavior"` // Update command behavior; 0:unchanged, 1:regenerate, 2:append
}

type TemplateConfig struct {
	Layouts []Template `yaml:"layouts"`
}

type TemplateGenerator struct {
	OutputDir string
	Config    *TemplateConfig
	Excludes  []string
	// contains filtered or unexported fields
}

type UpdateBehavior struct {
	Type string `yaml:"type"` // Update behavior type: skip/cover/append
	// the following variables are used for append update
	AppendKey      string   `yaml:"append_key"`         // Append content based in key; for example: 'method'/'service'
	InsertKey      string   `yaml:"insert_key"`         // Insert content by "insert_key"
	AppendTpl      string   `yaml:"append_content_tpl"` // Append content if UpdateBehavior is "append"
	ImportTpl      []string `yaml:"import_tpl"`         // Import insert template
	AppendLocation string   `yaml:"append_location"`    // AppendLocation specifies the location of append,  the default is the end of the file
}