Prepare pipelines before source execution

internal/framework/pipeline/input_registry.go

@@ -8,16 +8,19 @@ import (
 )
 
 type InputAdapterConstructor func() (contracts.InputAdapter, error)
+type InputAdapterBuilder func(BuildRequest) (contracts.InputAdapter, error)
 
 type InputAdapterRegistry struct {
-	constructors map[string]InputAdapterConstructor
-	specs        map[string]ModuleSpec
+	builders         map[string]InputAdapterBuilder
+	optionValidators map[string]OptionValidator
+	specs            map[string]ModuleSpec
 }
 
 func NewInputAdapterRegistry() *InputAdapterRegistry {
 	return &InputAdapterRegistry{
-		constructors: make(map[string]InputAdapterConstructor),
-		specs:        make(map[string]ModuleSpec),
+		builders:         make(map[string]InputAdapterBuilder),
+		optionValidators: make(map[string]OptionValidator),
+		specs:            make(map[string]ModuleSpec),
 	}
 }
 
@@ -26,6 +29,15 @@ func (r *InputAdapterRegistry) Register(key string, constructor InputAdapterCons
 }
 
 func (r *InputAdapterRegistry) RegisterWithSpec(spec ModuleSpec, constructor InputAdapterConstructor) error {
+	if constructor == nil {
+		return fmt.Errorf("input adapter constructor for %q must not be nil", strings.TrimSpace(spec.Key))
+	}
+	return r.RegisterBuilderWithSpec(spec, allowLegacyOptions, func(BuildRequest) (contracts.InputAdapter, error) {
+		return constructor()
+	})
+}
+
+func (r *InputAdapterRegistry) RegisterBuilderWithSpec(spec ModuleSpec, validateOptions OptionValidator, builder InputAdapterBuilder) error {
 	if r == nil {
 		return fmt.Errorf("input adapter registry must not be nil")
 	}
@@ -34,25 +46,36 @@ func (r *InputAdapterRegistry) RegisterWithSpec(spec ModuleSpec, constructor Inp
 	if err := validateModuleSpec("input adapter", StageInput, normalizedSpec); err != nil {
 		return err
 	}
-	if constructor == nil {
-		return fmt.Errorf("input adapter constructor for %q must not be nil", normalizedSpec.Key)
+	if validateOptions == nil {
+		return fmt.Errorf("input adapter option validator for %q must not be nil", normalizedSpec.Key)
 	}
-	if _, ok := r.constructors[normalizedSpec.Key]; ok {
+	if builder == nil {
+		return fmt.Errorf("input adapter builder for %q must not be nil", normalizedSpec.Key)
+	}
+	if _, ok := r.builders[normalizedSpec.Key]; ok {
 		return fmt.Errorf("input adapter %q is already registered", normalizedSpec.Key)
 	}
 
-	if r.constructors == nil {
-		r.constructors = make(map[string]InputAdapterConstructor)
+	if r.builders == nil {
+		r.builders = make(map[string]InputAdapterBuilder)
+	}
+	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 *InputAdapterRegistry) Build(key string) (contracts.InputAdapter, error) {
+	return r.BuildWithRequest(key, BuildRequest{})
+}
+
+func (r *InputAdapterRegistry) BuildWithRequest(key string, request BuildRequest) (contracts.InputAdapter, error) {
 	if r == nil {
 		return nil, fmt.Errorf("input adapter registry must not be nil")
 	}
@@ -62,12 +85,12 @@ func (r *InputAdapterRegistry) Build(key string) (contracts.InputAdapter, error)
 		return nil, fmt.Errorf("input adapter key must not be empty")
 	}
 
-	constructor, ok := r.constructors[normalizedKey]
+	builder, ok := r.builders[normalizedKey]
 	if !ok {
 		return nil, fmt.Errorf("input adapter %q is not registered", normalizedKey)
 	}
 
-	adapter, err := constructor()
+	adapter, err := builder(cloneBuildRequest(request))
 	if err != nil {
 		return nil, fmt.Errorf("build input adapter %q: %w", normalizedKey, err)
 	}
@@ -81,6 +104,18 @@ func (r *InputAdapterRegistry) Build(key string) (contracts.InputAdapter, error)
 	return adapter, nil
 }
 
+func (r *InputAdapterRegistry) ValidateOptions(key string, options map[string]any) error {
+	if r == nil {
+		return fmt.Errorf("input adapter registry must not be nil")
+	}
+	normalizedKey := strings.TrimSpace(key)
+	validator, ok := r.optionValidators[normalizedKey]
+	if !ok {
+		return fmt.Errorf("input adapter %q is not registered", normalizedKey)
+	}
+	return validateRegisteredOptions(validator, options)
+}
+
 func (r *InputAdapterRegistry) Spec(key string) (ModuleSpec, bool) {
 	if r == nil {
 		return ModuleSpec{}, false
@@ -98,5 +133,5 @@ func (r *InputAdapterRegistry) RegisteredKeys() []string {
 		return nil
 	}
 
-	return sortedRegistryKeys(r.constructors)
+	return sortedRegistryKeys(r.builders)
 }