pipeline

type Finding struct {
	Job     string
	Step    string
	Feature string
	Level   FindingLevel
	Detail  string
}

type FindingLevel int

type Job struct {
	Name      string
	Stage     string
	Image     string
	Variables map[string]string
	Steps     []Step
	// DependsOn lists the names of other jobs in the same Pipeline that
	// must reach a terminal state (success, failure, or skip) before this
	// job may start. A job runs only if every dependency succeeded; if any
	// failed or was itself skipped, this job is skipped too. Jobs with no
	// common dependency relationship may run concurrently. For GitLab,
	// this is every job in the nearest non-empty preceding stage
	// (reproducing GitLab's stage-barrier semantics); for CircleCI and
	// GitHub Actions, it's the resolved requires:/needs: list.
	DependsOn []string
	// Services are additional containers started alongside the job's own
	// container for its duration, reachable from it by their Alias (e.g.
	// GitLab's services:, or CircleCI's docker: entries after the first).
	Services []Service
}

type Phase int

type Pipeline struct {
	Stages []string
	Jobs   []Job
	// Findings records config features the parser recognized as not fully
	// faithful to the real provider (Emulated/Unsupported), or — for a
	// feature `polyci check` needs to categorize but that has no downside
	// worth calling out on its own (Supported) — for `polyci check` to
	// report. Populating this never changes what Run executes; it's purely
	// informational. A parser that finds nothing to flag leaves this nil.
	Findings []Finding
	// SkippedJobs lists every job the parser recognized in the config but
	// could not turn into anything runnable at all — e.g. a GitHub Actions
	// job with no container:, or a CircleCI job referencing an orb-based
	// executor. These jobs are excluded from Jobs entirely (the DAG, the
	// executor, and every other job's DependsOn never reference them), so
	// every other job in the file still runs normally; SkippedJobs exists
	// purely so `polyci run` and `polyci check` can report the omission
	// clearly instead of it being silent. A job that depends (directly or
	// transitively) on a skipped job is itself recorded here too, with a
	// reason that says so.
	SkippedJobs []SkippedJob
}

type Service struct {
	Image     string
	Alias     string
	Variables map[string]string
}

type SkippedJob struct {
	Name   string
	Reason string
}

type Step struct {
	Name    string
	Command string
	Env     map[string]string
	Phase   Phase
	// Shell names the interpreter the command runs under (e.g. "sh",
	// "bash"). Only a fixed set of shells is supported — an unrecognized
	// value is a hard error rather than a silent fallback to sh, since
	// silently running a step under the wrong shell can change whether it
	// even parses, let alone what it does.
	Shell string
	// WorkingDirectory is the directory the command runs in, inside the
	// container. A relative path is resolved against the workspace root;
	// an absolute path is used as-is.
	WorkingDirectory string
}