Prepare pipelines before source execution

internal/framework/pipeline/merger_registry.go

@@ -9,6 +9,7 @@ import (
 )
 
 type LegacyRawMergerConstructor func() (contracts.LegacyRawMerger, error)
+type LegacyRawMergerBuilder func(BuildRequest) (contracts.LegacyRawMerger, error)
 
 type artifactVariantKey struct {
 	module string
@@ -16,22 +17,25 @@ type artifactVariantKey struct {
 }
 
 type MergerRegistry struct {
-	legacyConstructors map[string]LegacyRawMergerConstructor
-	legacySpecs        map[string]ModuleSpec
-	typedEntries       map[artifactVariantKey]typedMergerEntry
+	legacyBuilders   map[string]LegacyRawMergerBuilder
+	legacyValidators map[string]OptionValidator
+	legacySpecs      map[string]ModuleSpec
+	typedEntries     map[artifactVariantKey]typedMergerEntry
 }
 
 type typedMergerEntry struct {
-	spec        ModuleSpec
-	valueType   reflect.Type
-	constructor func() (any, error)
+	spec            ModuleSpec
+	valueType       reflect.Type
+	validateOptions OptionValidator
+	builder         func(BuildRequest) (any, error)
 }
 
 func NewMergerRegistry() *MergerRegistry {
 	return &MergerRegistry{
-		legacyConstructors: make(map[string]LegacyRawMergerConstructor),
-		legacySpecs:        make(map[string]ModuleSpec),
-		typedEntries:       make(map[artifactVariantKey]typedMergerEntry),
+		legacyBuilders:   make(map[string]LegacyRawMergerBuilder),
+		legacyValidators: make(map[string]OptionValidator),
+		legacySpecs:      make(map[string]ModuleSpec),
+		typedEntries:     make(map[artifactVariantKey]typedMergerEntry),
 	}
 }
 
@@ -40,6 +44,15 @@ func (r *MergerRegistry) RegisterLegacyRaw(key string, constructor LegacyRawMerg
 }
 
 func (r *MergerRegistry) RegisterLegacyRawWithSpec(spec ModuleSpec, constructor LegacyRawMergerConstructor) error {
+	if constructor == nil {
+		return fmt.Errorf("merger constructor for %q must not be nil", strings.TrimSpace(spec.Key))
+	}
+	return r.RegisterLegacyRawBuilderWithSpec(spec, allowLegacyOptions, func(BuildRequest) (contracts.LegacyRawMerger, error) {
+		return constructor()
+	})
+}
+
+func (r *MergerRegistry) RegisterLegacyRawBuilderWithSpec(spec ModuleSpec, validateOptions OptionValidator, builder LegacyRawMergerBuilder) error {
 	if r == nil {
 		return fmt.Errorf("merger registry must not be nil")
 	}
@@ -50,24 +63,40 @@ func (r *MergerRegistry) RegisterLegacyRawWithSpec(spec ModuleSpec, constructor
 	if normalizedSpec.ArtifactKind != "" {
 		return fmt.Errorf("legacy raw merger %q must not declare an artifact kind", normalizedSpec.Key)
 	}
-	if constructor == nil {
-		return fmt.Errorf("merger constructor for %q must not be nil", normalizedSpec.Key)
+	if validateOptions == nil {
+		return fmt.Errorf("merger option validator for %q must not be nil", normalizedSpec.Key)
 	}
-	if _, ok := r.legacyConstructors[normalizedSpec.Key]; ok {
+	if builder == nil {
+		return fmt.Errorf("merger builder for %q must not be nil", normalizedSpec.Key)
+	}
+	if _, ok := r.legacyBuilders[normalizedSpec.Key]; ok {
 		return fmt.Errorf("legacy raw merger %q is already registered", normalizedSpec.Key)
 	}
-	if r.legacyConstructors == nil {
-		r.legacyConstructors = make(map[string]LegacyRawMergerConstructor)
+	if r.legacyBuilders == nil {
+		r.legacyBuilders = make(map[string]LegacyRawMergerBuilder)
+	}
+	if r.legacyValidators == nil {
+		r.legacyValidators = make(map[string]OptionValidator)
 	}
 	if r.legacySpecs == nil {
 		r.legacySpecs = make(map[string]ModuleSpec)
 	}
-	r.legacyConstructors[normalizedSpec.Key] = constructor
+	r.legacyBuilders[normalizedSpec.Key] = builder
+	r.legacyValidators[normalizedSpec.Key] = validateOptions
 	r.legacySpecs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
 	return nil
 }
 
 func RegisterMerger[T any](registry *MergerRegistry, spec ModuleSpec, constructor func() (contracts.Merger[T], error)) error {
+	if constructor == nil {
+		return fmt.Errorf("merger constructor for %q must not be nil", strings.TrimSpace(spec.Key))
+	}
+	return RegisterMergerBuilder(registry, spec, allowLegacyOptions, func(BuildRequest) (contracts.Merger[T], error) {
+		return constructor()
+	})
+}
+
+func RegisterMergerBuilder[T any](registry *MergerRegistry, spec ModuleSpec, validateOptions OptionValidator, builder func(BuildRequest) (contracts.Merger[T], error)) error {
 	if registry == nil {
 		return fmt.Errorf("merger registry must not be nil")
 	}
@@ -78,8 +107,11 @@ func RegisterMerger[T any](registry *MergerRegistry, spec ModuleSpec, constructo
 	if normalizedSpec.ArtifactKind == "" {
 		return fmt.Errorf("typed merger %q artifact kind must not be empty", normalizedSpec.Key)
 	}
-	if constructor == nil {
-		return fmt.Errorf("merger constructor for %q must not be nil", normalizedSpec.Key)
+	if validateOptions == nil {
+		return fmt.Errorf("merger option validator for %q must not be nil", normalizedSpec.Key)
+	}
+	if builder == nil {
+		return fmt.Errorf("merger builder for %q must not be nil", normalizedSpec.Key)
 	}
 	key := artifactVariantKey{module: normalizedSpec.Key, kind: normalizedSpec.ArtifactKind}
 	if _, ok := registry.typedEntries[key]; ok {
@@ -89,16 +121,21 @@ func RegisterMerger[T any](registry *MergerRegistry, spec ModuleSpec, constructo
 		registry.typedEntries = make(map[artifactVariantKey]typedMergerEntry)
 	}
 	registry.typedEntries[key] = typedMergerEntry{
-		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))
 		},
 	}
 	return nil
 }
 
 func (r *MergerRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawMerger, error) {
+	return r.BuildLegacyRawWithRequest(key, BuildRequest{})
+}
+
+func (r *MergerRegistry) BuildLegacyRawWithRequest(key string, request BuildRequest) (contracts.LegacyRawMerger, error) {
 	if r == nil {
 		return nil, fmt.Errorf("merger registry must not be nil")
 	}
@@ -106,11 +143,11 @@ func (r *MergerRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawMerger,
 	if normalizedKey == "" {
 		return nil, fmt.Errorf("merger key must not be empty")
 	}
-	constructor, ok := r.legacyConstructors[normalizedKey]
+	builder, ok := r.legacyBuilders[normalizedKey]
 	if !ok {
 		return nil, fmt.Errorf("legacy raw merger %q is not registered", normalizedKey)
 	}
-	merger, err := constructor()
+	merger, err := builder(cloneBuildRequest(request))
 	if err != nil {
 		return nil, fmt.Errorf("build merger %q: %w", normalizedKey, err)
 	}
@@ -123,6 +160,25 @@ func (r *MergerRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawMerger,
 	return merger, nil
 }
 
+func (r *MergerRegistry) validateOptions(key string, kind contracts.ArtifactKind, options map[string]any) error {
+	if r == nil {
+		return fmt.Errorf("merger registry must not be nil")
+	}
+	normalizedKey := strings.TrimSpace(key)
+	if kind != "" {
+		entry, ok := r.typedEntry(normalizedKey, kind)
+		if !ok {
+			return fmt.Errorf("merger %q variant for artifact kind %q is not registered", normalizedKey, kind)
+		}
+		return validateRegisteredOptions(entry.validateOptions, options)
+	}
+	validator, ok := r.legacyValidators[normalizedKey]
+	if !ok {
+		return fmt.Errorf("legacy raw merger %q is not registered", normalizedKey)
+	}
+	return validateRegisteredOptions(validator, options)
+}
+
 func (r *MergerRegistry) Spec(key string) (ModuleSpec, bool) {
 	if r == nil {
 		return ModuleSpec{}, false