workflow

type ConcurrencySpec struct {
	Limit int    `yaml:"limit,omitempty"`
	Group string `yaml:"group,omitempty"`
}

type Dependency struct {
	Step  string `yaml:"step,omitempty"`
	Label string `yaml:"label,omitempty"`
}

type OnErrorSpec struct {
	Type string `yaml:"type,omitempty"`
	When string `yaml:"when,omitempty"`
}

type ParamSpec struct {
	Name        string   `yaml:"name,omitempty"`
	Type        string   `yaml:"type,omitempty"`
	Default     string   `yaml:"default,omitempty"`
	Description string   `yaml:"description,omitempty"`
	Enum        []string `yaml:"enum,omitempty"`
	Pattern     string   `yaml:"pattern,omitempty"`
	Title       string   `yaml:"title,omitempty"`
	Group       string   `yaml:"group,omitempty"`
	Warn        string   `yaml:"warn,omitempty"`
	Uses        string   `yaml:"uses,omitempty"`
}

type ResourceSpec struct {
	CPU    string `yaml:"cpu,omitempty"`
	Memory string `yaml:"memory,omitempty"`
	Limits struct {
		CPU    string `yaml:"cpu,omitempty"`
		Memory string `yaml:"memory,omitempty"`
	} `yaml:"limits,omitempty"`
}

type Spec struct {
	Name        string       `yaml:"name,omitempty"`
	Description string       `yaml:"description,omitempty"`
	Schedule    string       `yaml:"schedule,omitempty"`
	Type        string       `yaml:"type,omitempty"`
	Tags        []string     `yaml:"tags,omitempty"`
	Image       string       `yaml:"image,omitempty"`
	Resources   ResourceSpec `yaml:"resources,omitempty"`
	Params      []ParamSpec  `yaml:"params,omitempty"`

	// Env and Secrets apply to every step; a step overrides them name by name.
	Env     map[string]string `yaml:"env,omitempty"`
	Secrets map[string]string `yaml:"secrets,omitempty"`
	// Concurrency is Kestra's `concurrency.limit`, under the name most
	// orchestrators use. See ConcurrencySpec for the two shapes.
	Concurrency ConcurrencySpec `yaml:"concurrency,omitempty"`

	// Trigger is why this runs other than the clock. See TriggerSpec.
	Trigger TriggerSpec `yaml:"trigger,omitempty"`

	Steps []StepSpec `yaml:"steps,omitempty"`
}

type StepSpec struct {
	ID        string         `yaml:"id,omitempty"`
	Run       string         `yaml:"run,omitempty"`
	Action    string         `yaml:"action,omitempty"`
	With      map[string]any `yaml:"with,omitempty"`
	DependsOn []Dependency   `yaml:"depends_on,omitempty"`

	// Image e Resources sobrescrevem os do workflow. Ausentes = herda.
	Image     string       `yaml:"image,omitempty"`
	Host      string       `yaml:"host,omitempty"`
	Resources ResourceSpec `yaml:"resources,omitempty"`

	// Env are variables with a literal value in the file.
	//
	//	env:
	//	  BREVIS_LOG_LEVEL: info
	Env map[string]string `yaml:"env,omitempty"`

	// PersistContext lists the keys this step may read and write through
	// sdk/persist. Declaring it is what makes the engine point the step at the
	// installation's store; a step that declares nothing gets no access at all.
	//
	// It is a LIST and not a boolean because the alternative is a flat global
	// namespace where any step touches any key: two workflows that both know a
	// good name for `station_codes` would overwrite each other and both keep
	// running. Naming them is also what lets the reader of the file see that
	// this step depends on whatever wrote them.
	PersistContext []string `yaml:"persist_context,omitempty"`

	// Secrets are variables whose value is NOT in the file: the key is the
	// variable's name, the value is where to find it.
	//
	//	secrets:
	//	  GABRIEL_SESSION_COOKIE: gabriel-session/cookie
	Secrets map[string]string `yaml:"secrets,omitempty"`

	// Runtime and Tools say what this step runs in, when the engine cannot
	// work it out from `run:` and `image:`.
	//
	//	runtime: python
	//	tools: [dbt]
	//
	// Both optional, and the engine INFERS both when they are absent -- which
	// is the normal case. Declaring one is for when the inference is wrong or
	// blind: a wrapper script, a bare binary path, an image whose name says
	// nothing.
	//
	// An id outside the vocabulary is refused at publish, naming what is
	// valid. The alternative is a chip that renders blank on a screen three
	// days later, with nothing to trace it to.
	Runtime string   `yaml:"runtime,omitempty"`
	Tools   []string `yaml:"tools,omitempty"`

	// Shell: a pointer, to tell "did not declare" from "declared false". Without
	// the pointer, every step without the key would become `shell: false` and
	// images that do have a shell -- most of them -- would start receiving an
	// argv, breaking any command with a pipe or a variable.
	Shell *bool `yaml:"shell,omitempty"`

	// When is the trigger rule. Empty is `all_success`, which is what every
	// workflow written before this existed means.
	When string `yaml:"when,omitempty"`

	// Marker is a step that does nothing and exists to be a point in the
	// graph -- a `start`, an `end`, a join. See dominio.Node.Marker.
	Marker bool `yaml:"marker,omitempty"`

	// UnlessEmpty names a context key that decides whether this step runs.
	// A key, not an expression. See dominio.Node.UnlessEmpty.
	UnlessEmpty string `yaml:"unless_empty,omitempty"`

	// ForEach names a context key holding a list. The step runs once per
	// element. See dominio.Node.ForEach.
	ForEach string `yaml:"for_each,omitempty"`

	// Group draws this step inside a named box on the graph. Visual only.
	// See dominio.Node.Group.
	Group string `yaml:"group,omitempty"`

	// Uses names another workflow whose steps take this one's place, expanded
	// at publish. See dominio.Node.Uses.
	Uses string `yaml:"uses,omitempty"`

	// OnError announces this step's failures.
	//
	//	on_error:
	//	  type: SLACK
	//	  when: attempt     # optional; the default is give_up
	//
	// A pointer for the same reason Shell is: absent has to be different from
	// declared-and-empty, and a zero OnError would look like a step asking to
	// be announced to nowhere.
	OnError *OnErrorSpec `yaml:"on_error,omitempty"`
}

type TriggerSpec struct {
	OnLanded []string      `yaml:"on_landed,omitempty"`
	Debounce time.Duration `yaml:"debounce,omitempty"`
}