jobparser

type ContainerSpec struct {
	Image       string            `yaml:"image,omitempty"`
	Env         map[string]string `yaml:"env,omitempty"`
	Ports       []string          `yaml:"ports,omitempty"`
	Volumes     []string          `yaml:"volumes,omitempty"`
	Options     string            `yaml:"options,omitempty"`
	Credentials map[string]string `yaml:"credentials,omitempty"`
	Cmd         []string          `yaml:"cmd,omitempty"`
}

type Defaults struct {
	Run RunDefaults `yaml:"run,omitempty"`
}

type EvaluateWorkflowCallSecretsArgs struct {
	CallerWorkflow *SingleWorkflow
	GitCtx         *model.GithubContext
	Vars           map[string]string
	Needs          []string
	JobInputs      map[string]any
	JobResults     map[string]string
	JobOutputs     map[string]map[string]string
	CallerSecrets  map[string]string
}

type Event struct {
	Name string
	// contains filtered or unexported fields
}

type ExpressionEvaluator struct {
	// contains filtered or unexported fields
}

type ExternalWorkflowFetcher func(job *Job, ref *model.ExternalReusableWorkflowReference) ([]byte, error)

type IncompleteMatrix struct {
	Dimension string `yaml:"dimension,omitempty"` // if ${{ matrix.some-dimension }} was incomplete, this will contain "some-dimension"
}

type IncompleteNeeds struct {
	Job    string `yaml:"job,omitempty"`    // if ${{ needs.some-job.outputs.some-output }} was incomplete, this will contain "some-job"
	Output string `yaml:"output,omitempty"` // if ${{ needs.some-job.outputs.some-output }} was incomplete, this will contain "some-output"
}

type InstanceWorkflowFetcher func(job *Job, ref *model.NonLocalReusableWorkflowReference) ([]byte, error)

type Job struct {
	Name           string                    `yaml:"name,omitempty"`
	RawNeeds       yaml.Node                 `yaml:"needs,omitempty"`
	RawRunsOn      yaml.Node                 `yaml:"runs-on,omitempty"`
	Env            yaml.Node                 `yaml:"env,omitempty"`
	If             yaml.Node                 `yaml:"if,omitempty"`
	Steps          []*Step                   `yaml:"steps,omitempty"`
	TimeoutMinutes string                    `yaml:"timeout-minutes,omitempty"`
	Services       map[string]*ContainerSpec `yaml:"services,omitempty"`
	Strategy       Strategy                  `yaml:"strategy,omitempty"`
	RawContainer   yaml.Node                 `yaml:"container,omitempty"`
	Defaults       Defaults                  `yaml:"defaults,omitempty"`
	Outputs        map[string]string         `yaml:"outputs,omitempty"`
	Uses           string                    `yaml:"uses,omitempty"`
	With           map[string]any            `yaml:"with,omitempty"`
	RawSecrets     yaml.Node                 `yaml:"secrets,omitempty"`
	RawConcurrency *model.RawConcurrency     `yaml:"concurrency,omitempty"`
}

type JobResult struct {
	Needs   []string
	Result  string
	Outputs map[string]string
}

type LocalWorkflowFetcher func(job *Job, path string) ([]byte, error)

type ParseOption func(c *parseContext)

type RunDefaults struct {
	Shell            string `yaml:"shell,omitempty"`
	WorkingDirectory string `yaml:"working-directory,omitempty"`
}

type SingleWorkflow struct {
	Name                string            `yaml:"name,omitempty"`
	RawOn               yaml.Node         `yaml:"on,omitempty"`
	Env                 map[string]string `yaml:"env,omitempty"`
	RawJobs             yaml.Node         `yaml:"jobs,omitempty"`
	Defaults            Defaults          `yaml:"defaults,omitempty"`
	EnableOpenIDConnect bool              `yaml:"enable-openid-connect,omitempty"`

	// IncompleteMatrix flag indicates that it wasn't possible to evaluate the `strategy.matrix` section of the job
	// because it references a job output that is currently undefined.  The workflow that this job came from will need
	// to be reparsed using the `WithJobOutputs()` option, and it may result in this job being expanded into multiple
	// jobs.
	IncompleteMatrix      bool             `yaml:"incomplete_matrix,omitempty"`
	IncompleteMatrixNeeds *IncompleteNeeds `yaml:"incomplete_matrix_needs,omitempty"`

	// IncompleteRunsOn indicates that it wasn't possible to evaluate the `runs_on` section of the job
	// because it references a job output that is currently undefined.
	IncompleteRunsOn       bool              `yaml:"incomplete_runs_on,omitempty"`
	IncompleteRunsOnNeeds  *IncompleteNeeds  `yaml:"incomplete_runs_on_needs,omitempty"`
	IncompleteRunsOnMatrix *IncompleteMatrix `yaml:"incomplete_runs_on_matrix,omitempty"`

	// IncompleteWith indicates that it wasn't possible to evaluate the `with` section of a job that is calling a
	// reusable workflow because it references a job output that is currently undefined.
	IncompleteWith       bool              `yaml:"incomplete_with,omitempty"`
	IncompleteWithNeeds  *IncompleteNeeds  `yaml:"incomplete_with_needs,omitempty"`
	IncompleteWithMatrix *IncompleteMatrix `yaml:"incomplete_with_matrix,omitempty"`

	// Contains optional data that may be persisted alongside a workflow for internal use, but should not be subject to
	// schema validation as it isn't user-entered.  Unlike the `Incomplete...` fields, these fields will not be
	// removed/resolved before transmission to a runner.
	Metadata SingleWorkflowMetadata `yaml:"__metadata,omitempty"`
}

type SingleWorkflowMetadata struct {
	IncompleteRecursionDepth int `yaml:"incomplete_recursion_depth,omitempty"`

	// When this workflow is a placeholder job that has been expanded into a reusable workflow, the inputs to the
	// reusable workflow are stored here so that they can be used as a valid evaluation context in the reusable
	// workflow's outputs later.
	WorkflowCallInputs map[string]any `yaml:"workflow_call_inputs,omitempty"`

	// When expanding reusable workflows, it is sometimes necessary to identify if a job was expanded into other jobs,
	// and for those jobs to know which job was expanded.  `WorkflowCallID` will be populated for a job that is
	// expanded, and it is guaranteed to be unique within a workflow (unlike the job ID, which may be repeated for
	// matrix evaluation).  `WorkflowCallParent` indicates a job has a "parent" which was expanded to create it.  Both
	// may be populated if a reusable workflow is used within a reusable workflow.
	WorkflowCallID     string `yaml:"workflow_call_id,omitempty"`
	WorkflowCallParent string `yaml:"workflow_call_parent,omitempty"`
}

type Step struct {
	ID               string            `yaml:"id,omitempty"`
	If               yaml.Node         `yaml:"if,omitempty"`
	Name             string            `yaml:"name,omitempty"`
	Uses             string            `yaml:"uses,omitempty"`
	Run              string            `yaml:"run,omitempty"`
	WorkingDirectory string            `yaml:"working-directory,omitempty"`
	Shell            string            `yaml:"shell,omitempty"`
	Env              yaml.Node         `yaml:"env,omitempty"`
	With             map[string]string `yaml:"with,omitempty"`
	ContinueOnError  bool              `yaml:"continue-on-error,omitempty"`
	TimeoutMinutes   string            `yaml:"timeout-minutes,omitempty"`
}

type Strategy struct {
	FailFastString    string    `yaml:"fail-fast,omitempty"`
	MaxParallelString string    `yaml:"max-parallel,omitempty"`
	RawMatrix         yaml.Node `yaml:"matrix,omitempty"`
}