tensile

type Condition struct {
	// Reads are dependencies the condition may read.
	Reads []Identity
	// Cond decides whether the node runs.
	// nil means always enabled.
	Cond func(Wire) (bool, error)
}

type Conflictor interface {
	// Conflicts returns the identities of resources the node touches,
	// e.g. packages or files.
	Conflicts() ([]Identity, error)
}

type DefaultWire struct {
	Ctx   context.Context //nolint:containedctx
	Log   *slog.Logger
	Store *storage.Store[Identity]
	Topo  Topology
}

type Depender interface {
	// DependsOn returns a list of resources the node depends on, e.g.
	// packages or files.
	DependsOn() ([]Identity, error)
}

type Diff interface {
	fmt.Stringer
	slog.LogValuer
}

type Executor interface {
	// NeedsExecution is run before Execute. NeedsExecution must not
	// mane any modifications to the system, it must be a stateless
	// check to check if Node.Execute must be called.
	//
	// NeedsExecution is called e.g. for noop runs to check if any
	// changes are needed.
	//
	// The returned Diff is an optional description of the change that would be made during Execute.
	// If the returned bool is false Diff may be nil.
	// If the returned bool is true Diff may be nil.
	NeedsExecution(wire Wire) (bool, Diff, error)
	// Execute is called for the node to make the desired change.
	// The returned Diff is an optional description of the change made and may be nil.
	Execute(wire Wire) (Diff, error)
}

type Handler struct {
	Node
}

type Identifier interface {
	// Identity returns the node's identity.
	// It must be deterministic and build from [AsIdentity].
	Identity() Identity
}

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

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

type Notifier interface {
	// Notifies returns a list of resources provided by handlers to
	// notify.
	Notifies() ([]Identity, error)
}

type Reporter interface {
	// Report returns the node's output.
	// It is called after the node completed and must not modify the system.
	Report(wire Wire) (any, error)
}

type Requisite interface {
	// RequiredBy returns a list of resources the node is a requirement for.
	RequiredBy() ([]Identity, error)
}

type Serializer interface {
	// SerializesOn returns the keys to serialize on.
	// Empty means no serialization.
	SerializesOn() []string
}

type State string

type Topology interface {
	// Claimer returns the node claiming identity.
	Claimer(identity Identity) (Identity, bool)
}

type Validator interface {
	// Validate validates the configuration of the node.
	// It may be used to setup states in the node.
	Validate(wire Wire) error
}

type Wire interface {
	// Context returns a context that is valid for the lifetime of the [Node].
	// That means the Context is valid from the first call to Validation
	// and until Execute has finished.
	Context() context.Context

	// Logger returns a logger for the [Node].
	Logger() *slog.Logger

	// Storage the [storage.Store], which provides output of other nodes.
	// The [storage.Store] only gives access to output of [Node] declared as dependencies.
	Storage() *storage.Store[Identity]

	// Topology returns a read-only view of the execution graph.
	// Errors when the wire carries no topology.
	Topology() (Topology, error)
}