bundlev1

type Bundle = worker.Bundle

type BundleInfo = api.BundleInfo

type BundleProvider interface {
	// GetBundleVersion returns upfront information about the bundle name and version without needing to load
	// the full dag and task information, which could be memory intensive.
	GetBundleVersion() BundleInfo

	// RegisterDags declares every dag and task in this bundle on the supplied
	// Registry, for example:
	//
	//	func (m *myBundle) RegisterDags(dagbag bundlev1.Registry) error {
	//		dag := dagbag.AddDag("simple_dag")
	//		dag.AddTask(extract)
	//		dag.AddTask(transform)
	//		return nil
	//	}
	//
	// Register all dags and tasks here. It is called once per process per
	// bundle and cached internally, so you do not have to cache it yourself.
	RegisterDags(Registry) error
}

type Dag interface {
	// AddTask registers fn as a task, deriving the task_id from fn's own
	// name (so it must match the @task.stub name in the Python dag).
	//
	// fn is an ordinary Go function whose parameters are injected by type
	// and may appear in any order. Recognised parameters are:
	//   - context.Context: cancelled when the task is asked to stop
	//   - *slog.Logger: writes to the task's Airflow log
	//   - sdk.Client (or a narrower sdk.VariableClient / sdk.ConnectionClient):
	//     access to Variables, Connections, and XCom
	//
	// fn must return either error or (result, error): a non-nil error fails
	// the task, and a non-nil first result is pushed as the task's
	// return-value XCom. Passing a non-function, or a function whose return
	// signature does not match, panics at registration time.
	AddTask(fn any)

	// AddTaskWithName is like AddTask but sets task_id explicitly instead of
	// deriving it from the function name. Use it when the Go function name
	// cannot match the Python @task.stub id, for example for an anonymous
	// function or a differing name.
	AddTaskWithName(taskId string, fn any)
}

type DagInfo struct {
	DagID string
	Tasks []TaskInfo
}

type EnumerableBundle interface {
	OrderedDags() []DagInfo
}

type ExecuteTaskWorkload struct {
	Token string `json:"token"`

	TI         api.TaskInstance `json:"ti"`
	BundleInfo api.BundleInfo   `json:"bundle_info"`
	LogPath    *string          `json:"log_path,omitempty"`
}

type GetMetadataResponse struct {
	Bundle BundleInfo
}

type Registry interface {
	Bundle
	// AddDag registers a dag by its dag_id (matching the Python stub dag)
	// and returns a Dag handle for attaching tasks. Registering the same
	// dag_id twice panics.
	AddDag(dagId string) Dag
}

type Task = worker.Task

type TaskInfo struct {
	ID string
}

type TaskInstance = api.TaskInstance