goloader

type DefinitionInfo struct {
	// Name is the definition name (e.g., "webservice", "daemon")
	Name string
	// Type is the definition type (e.g., "component", "trait", "policy", "workflow-step")
	Type string
	// FunctionName is the Go function that returns the definition
	FunctionName string
	// FilePath is the path to the Go file containing the definition
	FilePath string
	// PackageName is the Go package name
	PackageName string
	// Placement contains the definition-level placement constraints (if any)
	Placement *DefinitionPlacement
}

type DefinitionPlacement struct {
	// RunOn specifies conditions that must be satisfied for the definition to run.
	RunOn []PlacementCondition `json:"runOn,omitempty"`
	// NotRunOn specifies conditions that exclude clusters from running the definition.
	NotRunOn []PlacementCondition `json:"notRunOn,omitempty"`
}

type GeneratorEnvironment struct {
	// TempDir is the temporary directory with go.mod already set up
	TempDir string
	// ModuleRoot is the root directory of the user's Go module
	ModuleRoot string
	// ModuleName is the Go module name from go.mod
	ModuleName string
	// contains filtered or unexported fields
}

type Hook struct {
	// Path is a directory containing YAML manifests to apply
	// Files are processed in alphabetical order (use numeric prefixes for ordering)
	Path string `yaml:"path,omitempty" json:"path,omitempty"`
	// Script is a path to a shell script to execute
	Script string `yaml:"script,omitempty" json:"script,omitempty"`
	// Wait indicates whether to wait for resources to be ready (for Path hooks)
	Wait bool `yaml:"wait,omitempty" json:"wait,omitempty"`
	// WaitFor specifies the readiness condition to wait for.
	// Can be a simple condition name (e.g., "Ready", "Established") or
	// a CUE expression (e.g., 'status.phase == "Running"').
	// Only used when Wait is true.
	WaitFor string `yaml:"waitFor,omitempty" json:"waitFor,omitempty"`
	// Optional indicates whether hook failure should stop the process
	Optional bool `yaml:"optional,omitempty" json:"optional,omitempty"`
	// Timeout for the hook execution (default: 5m for wait, 30s for scripts)
	Timeout string `yaml:"timeout,omitempty" json:"timeout,omitempty"`
}

type HookDetail struct {
	// Name is the hook name (path or script)
	Name string
	// Duration is how long the hook took to execute
	Duration time.Duration
	// Wait indicates if this hook waited for resources
	Wait bool
	// ResourcesCreated is resources created by this hook
	ResourcesCreated int
	// ResourcesUpdated is resources updated by this hook
	ResourcesUpdated int
}

type HookExecutionStats struct {
	// TotalDuration is the total time spent executing hooks
	TotalDuration time.Duration
	// HookDetails contains per-hook timing information
	HookDetails []HookDetail
	// ResourcesCreated is the number of resources created by path hooks
	ResourcesCreated int
	// ResourcesUpdated is the number of resources updated by path hooks
	ResourcesUpdated int
	// OptionalFailed is the number of optional hooks that failed
	OptionalFailed int
}

type HookExecutor struct {
	// Client is the Kubernetes client for applying manifests
	Client client.Client
	// ModulePath is the base path of the module
	ModulePath string
	// Namespace is the target namespace for resources
	Namespace string
	// DryRun indicates whether to perform a dry run
	DryRun bool
	// Streams provides output streams for logging
	Streams util.IOStreams
}

type LoadResult struct {
	// CUE is the generated CUE string
	CUE string
	// YAML is the generated YAML string (Kubernetes CR format)
	YAML []byte
	// Definition contains metadata about the definition
	Definition DefinitionInfo
	// Error is set if loading failed for this definition
	Error error
}

type LoadedModule struct {
	// Metadata is the module metadata
	Metadata ModuleMetadata
	// Path is the local filesystem path to the module
	Path string
	// ModulePath is the Go module path (e.g., github.com/myorg/defs)
	ModulePath string
	// Version is the resolved version
	Version string
	// Definitions contains all discovered definitions
	Definitions []LoadResult
	// Dependencies are the resolved dependencies
	Dependencies []*LoadedModule
}

type Maintainer struct {
	Name  string `yaml:"name" json:"name"`
	Email string `yaml:"email,omitempty" json:"email,omitempty"`
}

type ModuleDependency struct {
	// Module is the Go module path
	Module string `yaml:"module" json:"module"`
	// Version is the required version (supports semver constraints)
	Version string `yaml:"version" json:"version"`
}

type ModuleHooks struct {
	// PreApply hooks run before definitions are applied
	PreApply []Hook `yaml:"pre-apply,omitempty" json:"pre-apply,omitempty"`
	// PostApply hooks run after definitions are applied
	PostApply []Hook `yaml:"post-apply,omitempty" json:"post-apply,omitempty"`
}

type ModuleLoadOptions struct {
	// Version specifies the version to load (for remote modules)
	Version string
	// Types filters which definition types to load
	Types []string
	// NamePrefix adds a prefix to all definition names
	NamePrefix string
	// IncludeTests includes test files
	IncludeTests bool
	// ResolveDependencies resolves and loads dependencies
	ResolveDependencies bool
}

type ModuleMetadata struct {
	// APIVersion is the metadata API version
	APIVersion string `yaml:"apiVersion" json:"apiVersion"`
	// Kind should be "DefinitionModule"
	Kind string `yaml:"kind" json:"kind"`
	// Metadata contains name and version
	Metadata ModuleObjectMeta `yaml:"metadata" json:"metadata"`
	// Spec contains module configuration
	Spec ModuleSpec `yaml:"spec" json:"spec"`
}

type ModuleObjectMeta struct {
	// Name is the module name
	Name string `yaml:"name" json:"name"`
}

type ModulePlacement struct {
	// RunOn specifies conditions that must be satisfied for definitions to be applied.
	RunOn []ModulePlacementCondition `yaml:"runOn,omitempty" json:"runOn,omitempty"`
	// NotRunOn specifies conditions that exclude clusters from running definitions.
	NotRunOn []ModulePlacementCondition `yaml:"notRunOn,omitempty" json:"notRunOn,omitempty"`
}

type ModulePlacementCondition struct {
	// Key is the cluster label key to match against.
	Key string `yaml:"key" json:"key"`
	// Operator is the comparison operator (Eq, Ne, In, NotIn, Exists, NotExists).
	Operator string `yaml:"operator" json:"operator"`
	// Values are the values to compare against.
	Values []string `yaml:"values,omitempty" json:"values,omitempty"`
}

type ModuleSpec struct {
	// Description is a human-readable description
	Description string `yaml:"description,omitempty" json:"description,omitempty"`
	// Maintainers lists the module maintainers
	Maintainers []Maintainer `yaml:"maintainers,omitempty" json:"maintainers,omitempty"`
	// MinVelaVersion is the minimum KubeVela version required
	MinVelaVersion string `yaml:"minVelaVersion,omitempty" json:"minVelaVersion,omitempty"`
	// MinDefkitVersion is the minimum defkit SDK version
	MinDefkitVersion string `yaml:"minDefkitVersion,omitempty" json:"minDefkitVersion,omitempty"`
	// Categories for organization
	Categories []string `yaml:"categories,omitempty" json:"categories,omitempty"`
	// Dependencies lists other definition modules this depends on
	Dependencies []ModuleDependency `yaml:"dependencies,omitempty" json:"dependencies,omitempty"`
	// Exclude patterns for files to skip
	Exclude []string `yaml:"exclude,omitempty" json:"exclude,omitempty"`
	// NameOverrides maps definition paths to custom names
	NameOverrides map[string]string `yaml:"nameOverrides,omitempty" json:"nameOverrides,omitempty"`
	// Placement defines default placement constraints for all definitions in this module.
	// Individual definitions can override these constraints.
	Placement *ModulePlacement `yaml:"placement,omitempty" json:"placement,omitempty"`
	// Hooks defines lifecycle hooks for the module
	Hooks *ModuleHooks `yaml:"hooks,omitempty" json:"hooks,omitempty"`
}

type PlacementCondition struct {
	Key      string   `json:"key"`
	Operator string   `json:"operator"`
	Values   []string `json:"values,omitempty"`
}