applyset

type ApplyMode struct {
	Concurrency int // 0 = len(resources)
}

type ApplyResult struct {
	Applied []ApplyResultItem
}

type ApplyResultItem struct {
	ID       string                     // same as input Resource.ID
	Desired  *unstructured.Unstructured // what we sent
	Observed *unstructured.Unstructured // cluster state after apply (nil if error)
	Changed  bool                       // resourceVersion changed
	Error    error
}

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

type ApplySetConflictError struct {
	ResourceName      string
	ResourceNamespace string
	ResourceGVK       string
	CurrentApplySetID string
	DesiredApplySetID string
}

type Config struct {
	Client          dynamic.Interface
	RESTMapper      meta.RESTMapper
	Log             logr.Logger
	ParentNamespace string // fallback namespace for namespaced resources without namespace set
}

type DeleteOrphanResult struct {
	// Pruned is non-nil when the delete was accepted by the API server.
	Pruned *PruneResultItem
	// Conflict is true when the UID precondition failed (resource was recreated).
	Conflict bool
}

type Interface interface {
	// Project computes metadata as union of current resources + parent annotations.
	// Returns GKs/namespaces from both batch AND parent memory (for prune scope).
	// Returns error if RESTMapping fails for any resource.
	Project(resources []Resource) (Metadata, error)

	// Apply runs SSA on resources and returns batch-only metadata.
	// Batch metadata contains only GKs/namespaces from THIS apply (not parent memory).
	Apply(ctx context.Context, resources []Resource, mode ApplyMode) (*ApplyResult, Metadata, error)

	// ListOrphans discovers orphaned resources without deleting them.
	// Returns candidates that the caller can order (e.g. reverse-topological)
	// before issuing deletes via DeleteOrphan.
	ListOrphans(ctx context.Context, opts PruneOptions) ([]OrphanCandidate, error)

	// DeleteOrphan deletes a single orphan candidate using a UID precondition.
	DeleteOrphan(ctx context.Context, candidate OrphanCandidate) (DeleteOrphanResult, error)
}

type Metadata struct {
	ID                   string
	Tooling              string
	GroupKinds           sets.Set[schema.GroupKind]
	AdditionalNamespaces sets.Set[string] // excludes parent namespace per KEP-3659
}

type OrphanCandidate struct {
	Object *unstructured.Unstructured
	GVR    schema.GroupVersionResource
}

type PruneOptions struct {
	// KeepUIDs are UIDs of resources that should NOT be pruned.
	// Typically from ApplyResult.ObservedUIDs().
	KeepUIDs sets.Set[types.UID]
	// Scope defines GKs and namespaces to prune from (required).
	// Use Metadata.PruneScope() to get the scope from Project() output.
	// Pass the superset scope (union of batch + parent) to ensure
	// prune finds all orphans.
	Scope *PruneScope
}

type PruneResultItem struct {
	Object *unstructured.Unstructured
}

type PruneScope struct {
	GroupKinds sets.Set[schema.GroupKind]
	Namespaces sets.Set[string] // required for namespace-scoped RBAC compatibility
}

type Resource struct {
	// ID is a stable identifier provided by the controller (e.g., "deployment" or "workers-0").
	ID string
	// Object is the desired state to apply (GVK/ns/name must be set correctly by the caller).
	Object *unstructured.Unstructured
	// Current optionally carries the live object fetched by the controller.
	// This allows conflict detection without extra GETs inside Apply().
	Current *unstructured.Unstructured
	// SkipApply excludes the resource from SSA and from the current GK/namespace set.
	// Prune relies on the parent annotation "memory" from previous reconciles to
	// delete these resources if they were previously applied. Use for includeWhen=false.
	SkipApply bool
}