Prepare pipelines before source execution

internal/framework/pipeline/extractor_registry.go

@@ -9,24 +9,28 @@ import (
 )
 
 type LegacyRawExtractorConstructor func() (contracts.LegacyRawExtractor, error)
+type LegacyRawExtractorBuilder func(BuildRequest) (contracts.LegacyRawExtractor, error)
 
 type ExtractorRegistry struct {
-	legacyConstructors map[string]LegacyRawExtractorConstructor
-	typedEntries       map[string]typedExtractorEntry
-	specs              map[string]ModuleSpec
+	legacyBuilders   map[string]LegacyRawExtractorBuilder
+	legacyValidators map[string]OptionValidator
+	typedEntries     map[string]typedExtractorEntry
+	specs            map[string]ModuleSpec
 }
 
 type typedExtractorEntry struct {
-	spec        ModuleSpec
-	valueType   reflect.Type
-	constructor func() (any, error)
+	spec            ModuleSpec
+	valueType       reflect.Type
+	validateOptions OptionValidator
+	builder         func(BuildRequest) (any, error)
 }
 
 func NewExtractorRegistry() *ExtractorRegistry {
 	return &ExtractorRegistry{
-		legacyConstructors: make(map[string]LegacyRawExtractorConstructor),
-		typedEntries:       make(map[string]typedExtractorEntry),
-		specs:              make(map[string]ModuleSpec),
+		legacyBuilders:   make(map[string]LegacyRawExtractorBuilder),
+		legacyValidators: make(map[string]OptionValidator),
+		typedEntries:     make(map[string]typedExtractorEntry),
+		specs:            make(map[string]ModuleSpec),
 	}
 }
 
@@ -35,6 +39,15 @@ func (r *ExtractorRegistry) RegisterLegacyRaw(key string, constructor LegacyRawE
 }
 
 func (r *ExtractorRegistry) RegisterLegacyRawWithSpec(spec ModuleSpec, constructor LegacyRawExtractorConstructor) error {
+	if constructor == nil {
+		return fmt.Errorf("extractor constructor for %q must not be nil", strings.TrimSpace(spec.Key))
+	}
+	return r.RegisterLegacyRawBuilderWithSpec(spec, allowLegacyOptions, func(BuildRequest) (contracts.LegacyRawExtractor, error) {
+		return constructor()
+	})
+}
+
+func (r *ExtractorRegistry) RegisterLegacyRawBuilderWithSpec(spec ModuleSpec, validateOptions OptionValidator, builder LegacyRawExtractorBuilder) error {
 	if r == nil {
 		return fmt.Errorf("extractor registry must not be nil")
 	}
@@ -45,24 +58,40 @@ func (r *ExtractorRegistry) RegisterLegacyRawWithSpec(spec ModuleSpec, construct
 	if normalizedSpec.ArtifactKind != "" {
 		return fmt.Errorf("legacy raw extractor %q must not declare an artifact kind", normalizedSpec.Key)
 	}
-	if constructor == nil {
-		return fmt.Errorf("extractor constructor for %q must not be nil", normalizedSpec.Key)
+	if validateOptions == nil {
+		return fmt.Errorf("extractor option validator for %q must not be nil", normalizedSpec.Key)
+	}
+	if builder == nil {
+		return fmt.Errorf("extractor builder for %q must not be nil", normalizedSpec.Key)
 	}
 	if _, ok := r.specs[normalizedSpec.Key]; ok {
 		return fmt.Errorf("extractor %q is already registered", normalizedSpec.Key)
 	}
-	if r.legacyConstructors == nil {
-		r.legacyConstructors = make(map[string]LegacyRawExtractorConstructor)
+	if r.legacyBuilders == nil {
+		r.legacyBuilders = make(map[string]LegacyRawExtractorBuilder)
+	}
+	if r.legacyValidators == nil {
+		r.legacyValidators = make(map[string]OptionValidator)
 	}
 	if r.specs == nil {
 		r.specs = make(map[string]ModuleSpec)
 	}
-	r.legacyConstructors[normalizedSpec.Key] = constructor
+	r.legacyBuilders[normalizedSpec.Key] = builder
+	r.legacyValidators[normalizedSpec.Key] = validateOptions
 	r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
 	return nil
 }
 
 func RegisterExtractor[T any](registry *ExtractorRegistry, spec ModuleSpec, constructor func() (contracts.Extractor[T], error)) error {
+	if constructor == nil {
+		return fmt.Errorf("extractor constructor for %q must not be nil", strings.TrimSpace(spec.Key))
+	}
+	return RegisterExtractorBuilder(registry, spec, allowLegacyOptions, func(BuildRequest) (contracts.Extractor[T], error) {
+		return constructor()
+	})
+}
+
+func RegisterExtractorBuilder[T any](registry *ExtractorRegistry, spec ModuleSpec, validateOptions OptionValidator, builder func(BuildRequest) (contracts.Extractor[T], error)) error {
 	if registry == nil {
 		return fmt.Errorf("extractor registry must not be nil")
 	}
@@ -73,17 +102,21 @@ func RegisterExtractor[T any](registry *ExtractorRegistry, spec ModuleSpec, cons
 	if normalizedSpec.ArtifactKind == "" {
 		return fmt.Errorf("typed extractor %q artifact kind must not be empty", normalizedSpec.Key)
 	}
-	if constructor == nil {
-		return fmt.Errorf("extractor constructor for %q must not be nil", normalizedSpec.Key)
+	if validateOptions == nil {
+		return fmt.Errorf("extractor option validator for %q must not be nil", normalizedSpec.Key)
+	}
+	if builder == nil {
+		return fmt.Errorf("extractor builder for %q must not be nil", normalizedSpec.Key)
 	}
 	if _, ok := registry.specs[normalizedSpec.Key]; ok {
 		return fmt.Errorf("extractor %q is already registered", normalizedSpec.Key)
 	}
 	entry := typedExtractorEntry{
-		spec:      cloneModuleSpec(normalizedSpec),
-		valueType: reflect.TypeFor[T](),
-		constructor: func() (any, error) {
-			return constructor()
+		spec:            cloneModuleSpec(normalizedSpec),
+		valueType:       reflect.TypeFor[T](),
+		validateOptions: validateOptions,
+		builder: func(request BuildRequest) (any, error) {
+			return builder(cloneBuildRequest(request))
 		},
 	}
 	if registry.typedEntries == nil {
@@ -98,6 +131,10 @@ func RegisterExtractor[T any](registry *ExtractorRegistry, spec ModuleSpec, cons
 }
 
 func (r *ExtractorRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawExtractor, error) {
+	return r.BuildLegacyRawWithRequest(key, BuildRequest{})
+}
+
+func (r *ExtractorRegistry) BuildLegacyRawWithRequest(key string, request BuildRequest) (contracts.LegacyRawExtractor, error) {
 	if r == nil {
 		return nil, fmt.Errorf("extractor registry must not be nil")
 	}
@@ -105,11 +142,11 @@ func (r *ExtractorRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawExtra
 	if normalizedKey == "" {
 		return nil, fmt.Errorf("extractor key must not be empty")
 	}
-	constructor, ok := r.legacyConstructors[normalizedKey]
+	builder, ok := r.legacyBuilders[normalizedKey]
 	if !ok {
 		return nil, fmt.Errorf("legacy raw extractor %q is not registered", normalizedKey)
 	}
-	extractor, err := constructor()
+	extractor, err := builder(cloneBuildRequest(request))
 	if err != nil {
 		return nil, fmt.Errorf("build extractor %q: %w", normalizedKey, err)
 	}
@@ -122,6 +159,21 @@ func (r *ExtractorRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawExtra
 	return extractor, nil
 }
 
+func (r *ExtractorRegistry) validateOptions(key string, options map[string]any) error {
+	if r == nil {
+		return fmt.Errorf("extractor registry must not be nil")
+	}
+	normalizedKey := strings.TrimSpace(key)
+	if entry, ok := r.typedEntries[normalizedKey]; ok {
+		return validateRegisteredOptions(entry.validateOptions, options)
+	}
+	validator, ok := r.legacyValidators[normalizedKey]
+	if !ok {
+		return fmt.Errorf("extractor %q is not registered", normalizedKey)
+	}
+	return validateRegisteredOptions(validator, options)
+}
+
 func (r *ExtractorRegistry) Spec(key string) (ModuleSpec, bool) {
 	if r == nil {
 		return ModuleSpec{}, false