Prepare pipelines before source execution

internal/framework/pipeline/output_registry.go

@@ -8,16 +8,19 @@ import (
 )
 
 type OutputEncoderConstructor func() (contracts.OutputEncoder, error)
+type OutputEncoderBuilder func(BuildRequest) (contracts.OutputEncoder, error)
 
 type OutputEncoderRegistry struct {
-	constructors map[string]OutputEncoderConstructor
-	specs        map[string]ModuleSpec
+	builders         map[string]OutputEncoderBuilder
+	optionValidators map[string]OptionValidator
+	specs            map[string]ModuleSpec
 }
 
 func NewOutputEncoderRegistry() *OutputEncoderRegistry {
 	return &OutputEncoderRegistry{
-		constructors: make(map[string]OutputEncoderConstructor),
-		specs:        make(map[string]ModuleSpec),
+		builders:         make(map[string]OutputEncoderBuilder),
+		optionValidators: make(map[string]OptionValidator),
+		specs:            make(map[string]ModuleSpec),
 	}
 }
 
@@ -26,6 +29,15 @@ func (r *OutputEncoderRegistry) Register(key string, constructor OutputEncoderCo
 }
 
 func (r *OutputEncoderRegistry) RegisterWithSpec(spec ModuleSpec, constructor OutputEncoderConstructor) error {
+	if constructor == nil {
+		return fmt.Errorf("output encoder constructor for %q must not be nil", strings.TrimSpace(spec.Key))
+	}
+	return r.RegisterBuilderWithSpec(spec, allowLegacyOptions, func(BuildRequest) (contracts.OutputEncoder, error) {
+		return constructor()
+	})
+}
+
+func (r *OutputEncoderRegistry) RegisterBuilderWithSpec(spec ModuleSpec, validateOptions OptionValidator, builder OutputEncoderBuilder) error {
 	if r == nil {
 		return fmt.Errorf("output encoder registry must not be nil")
 	}
@@ -34,25 +46,36 @@ func (r *OutputEncoderRegistry) RegisterWithSpec(spec ModuleSpec, constructor Ou
 	if err := validateModuleSpec("output encoder", StageOutput, normalizedSpec); err != nil {
 		return err
 	}
-	if constructor == nil {
-		return fmt.Errorf("output encoder constructor for %q must not be nil", normalizedSpec.Key)
+	if validateOptions == nil {
+		return fmt.Errorf("output encoder option validator for %q must not be nil", normalizedSpec.Key)
 	}
-	if _, ok := r.constructors[normalizedSpec.Key]; ok {
+	if builder == nil {
+		return fmt.Errorf("output encoder builder for %q must not be nil", normalizedSpec.Key)
+	}
+	if _, ok := r.builders[normalizedSpec.Key]; ok {
 		return fmt.Errorf("output encoder %q is already registered", normalizedSpec.Key)
 	}
 
-	if r.constructors == nil {
-		r.constructors = make(map[string]OutputEncoderConstructor)
+	if r.builders == nil {
+		r.builders = make(map[string]OutputEncoderBuilder)
+	}
+	if r.optionValidators == nil {
+		r.optionValidators = make(map[string]OptionValidator)
 	}
 	if r.specs == nil {
 		r.specs = make(map[string]ModuleSpec)
 	}
-	r.constructors[normalizedSpec.Key] = constructor
+	r.builders[normalizedSpec.Key] = builder
+	r.optionValidators[normalizedSpec.Key] = validateOptions
 	r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
 	return nil
 }
 
 func (r *OutputEncoderRegistry) Build(key string) (contracts.OutputEncoder, error) {
+	return r.BuildWithRequest(key, BuildRequest{})
+}
+
+func (r *OutputEncoderRegistry) BuildWithRequest(key string, request BuildRequest) (contracts.OutputEncoder, error) {
 	if r == nil {
 		return nil, fmt.Errorf("output encoder registry must not be nil")
 	}
@@ -62,12 +85,12 @@ func (r *OutputEncoderRegistry) Build(key string) (contracts.OutputEncoder, erro
 		return nil, fmt.Errorf("output encoder key must not be empty")
 	}
 
-	constructor, ok := r.constructors[normalizedKey]
+	builder, ok := r.builders[normalizedKey]
 	if !ok {
 		return nil, fmt.Errorf("output encoder %q is not registered", normalizedKey)
 	}
 
-	encoder, err := constructor()
+	encoder, err := builder(cloneBuildRequest(request))
 	if err != nil {
 		return nil, fmt.Errorf("build output encoder %q: %w", normalizedKey, err)
 	}
@@ -81,6 +104,18 @@ func (r *OutputEncoderRegistry) Build(key string) (contracts.OutputEncoder, erro
 	return encoder, nil
 }
 
+func (r *OutputEncoderRegistry) ValidateOptions(key string, options map[string]any) error {
+	if r == nil {
+		return fmt.Errorf("output encoder registry must not be nil")
+	}
+	normalizedKey := strings.TrimSpace(key)
+	validator, ok := r.optionValidators[normalizedKey]
+	if !ok {
+		return fmt.Errorf("output encoder %q is not registered", normalizedKey)
+	}
+	return validateRegisteredOptions(validator, options)
+}
+
 func (r *OutputEncoderRegistry) Spec(key string) (ModuleSpec, bool) {
 	if r == nil {
 		return ModuleSpec{}, false
@@ -98,5 +133,5 @@ func (r *OutputEncoderRegistry) RegisteredKeys() []string {
 		return nil
 	}
 
-	return sortedRegistryKeys(r.constructors)
+	return sortedRegistryKeys(r.builders)
 }