procedure

type GoFrameHTTPInputHandler struct{}

type LifeCycle interface {
	NodeLifeCycle
	// HandleInput defines how to handle input
	HandleInput(ctx context.Context, proto *Proto) (input map[string]any, err error)
	// HandleOutput defines how to handle output
	HandleOutput(ctx context.Context, proto *Proto, raw map[string]any) (out any, err error)
}

type Meta map[string]any

type Node struct {
	// Name of node, output will be overwritten if
	// using same name.
	Name string `json:"name"`
	// Meta data
	Meta Meta `json:"meta"`
	// Must execute success flag.
	// checks NodeLifeCycle.Execute return error
	Must bool `json:"must"`
	// Children nodes
	Children []*Node `json:"children"`
	// InputFilter of node, supported alias usage,
	// e.g. "aaa as bbb" empty means no filter,
	// all input will be passed
	InputFilter []string `json:"input_filter" yaml:"input_filter"`
	// Script in go template syntax
	Script Script `json:"script"`
	// contains filtered or unexported fields
}

type NodeLifeCycle interface {
	// BeforeExecute defines aspect before execute
	// input is copy of ExecuteNode input and filtered.
	BeforeExecute(ctx context.Context, node *Node, input map[string]any) (err error)
	// Execute defines how to execute a node.
	// input is copy of ExecuteNode input and
	// filtered. after execute, output will be
	// saved to ExecuteNode output in key node.Name
	Execute(ctx context.Context, node *Node, input map[string]any) (output any, err error)
	// AfterExecute defines aspect after execute.
	AfterExecute(ctx context.Context, node *Node, output any, err error)
	// BeforeScript defines parameters to build the
	// template.Template, returns the template.FuncMap
	// and the template execute input.
	// this method called after AfterExecute only if
	// node.Script is not empty.
	BeforeScript(ctx context.Context, node *Node, input map[string]any, output any) (fm template.FuncMap)
}

type Parameter struct {
	// Name of parameter
	Name string `json:"name"`
	// Validate validator define of parameter
	Validate *ParameterValidate `json:"validate,omitempty"`
	// Meta of parameter
	Meta Meta `json:"meta"`
}

type ParameterValidate struct {
	// validator rule
	// e.g. "required|length:6,16|same:password2"
	Rule string `json:"rule"`
	// error message accept map or string
	// e.g. "message": "xxx"
	// e.g. "message": {"required": "xxx", "same": "xxx"}
	Message any `json:"message"`
}

type Proto struct {
	// LifeCycle of proto
	LifeCycle `json:"-" yaml:"-"`
	// Name of proto
	Name string `json:"name"`
	// Meta data
	Meta Meta `json:"meta"`
	// Parameters define
	Parameters []*Parameter `json:"parameters"`
	// Node of procedure
	Node *Node `json:"node"`
	// Async is a flag that indicates whether
	// the node is executed asynchronously
	Async bool `json:"async"`
	// Script in go template syntax
	Script Script `json:"script"`
	// contains filtered or unexported fields
}

type Script string

type ScriptExecuteResult struct {
	OK     bool           `json:"ok"`
	Error  string         `json:"error"`
	Result map[string]any `json:"result"`
}