Add type-safe artifact lane resolution

internal/framework/pipeline/merger_registry.go

@@ -2,71 +2,114 @@ package pipeline
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
 
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 )
 
-type MergerConstructor func() (contracts.Merger, error)
+type LegacyRawMergerConstructor func() (contracts.LegacyRawMerger, error)
+
+type artifactVariantKey struct {
+	module string
+	kind   contracts.ArtifactKind
+}
 
 type MergerRegistry struct {
-	constructors map[string]MergerConstructor
-	specs        map[string]ModuleSpec
+	legacyConstructors map[string]LegacyRawMergerConstructor
+	legacySpecs        map[string]ModuleSpec
+	typedEntries       map[artifactVariantKey]typedMergerEntry
+}
+
+type typedMergerEntry struct {
+	spec        ModuleSpec
+	valueType   reflect.Type
+	constructor func() (any, error)
 }
 
 func NewMergerRegistry() *MergerRegistry {
 	return &MergerRegistry{
-		constructors: make(map[string]MergerConstructor),
-		specs:        make(map[string]ModuleSpec),
+		legacyConstructors: make(map[string]LegacyRawMergerConstructor),
+		legacySpecs:        make(map[string]ModuleSpec),
+		typedEntries:       make(map[artifactVariantKey]typedMergerEntry),
 	}
 }
 
-func (r *MergerRegistry) Register(key string, constructor MergerConstructor) error {
-	return r.RegisterWithSpec(defaultModuleSpec(key, StageMerge), constructor)
+func (r *MergerRegistry) RegisterLegacyRaw(key string, constructor LegacyRawMergerConstructor) error {
+	return r.RegisterLegacyRawWithSpec(defaultModuleSpec(key, StageMerge), constructor)
 }
 
-func (r *MergerRegistry) RegisterWithSpec(spec ModuleSpec, constructor MergerConstructor) error {
+func (r *MergerRegistry) RegisterLegacyRawWithSpec(spec ModuleSpec, constructor LegacyRawMergerConstructor) error {
 	if r == nil {
 		return fmt.Errorf("merger registry must not be nil")
 	}
-
 	normalizedSpec := normalizeModuleSpec(spec)
 	if err := validateModuleSpec("merger", StageMerge, normalizedSpec); err != nil {
 		return err
 	}
+	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 _, ok := r.constructors[normalizedSpec.Key]; ok {
-		return fmt.Errorf("merger %q is already registered", normalizedSpec.Key)
+	if _, ok := r.legacyConstructors[normalizedSpec.Key]; ok {
+		return fmt.Errorf("legacy raw merger %q is already registered", normalizedSpec.Key)
 	}
-
-	if r.constructors == nil {
-		r.constructors = make(map[string]MergerConstructor)
+	if r.legacyConstructors == nil {
+		r.legacyConstructors = make(map[string]LegacyRawMergerConstructor)
 	}
-	if r.specs == nil {
-		r.specs = make(map[string]ModuleSpec)
+	if r.legacySpecs == nil {
+		r.legacySpecs = make(map[string]ModuleSpec)
 	}
-	r.constructors[normalizedSpec.Key] = constructor
-	r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
+	r.legacyConstructors[normalizedSpec.Key] = constructor
+	r.legacySpecs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
 	return nil
 }
 
-func (r *MergerRegistry) Build(key string) (contracts.Merger, error) {
+func RegisterMerger[T any](registry *MergerRegistry, spec ModuleSpec, constructor func() (contracts.Merger[T], error)) error {
+	if registry == nil {
+		return fmt.Errorf("merger registry must not be nil")
+	}
+	normalizedSpec := normalizeModuleSpec(spec)
+	if err := validateModuleSpec("merger", StageMerge, normalizedSpec); err != nil {
+		return err
+	}
+	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)
+	}
+	key := artifactVariantKey{module: normalizedSpec.Key, kind: normalizedSpec.ArtifactKind}
+	if _, ok := registry.typedEntries[key]; ok {
+		return fmt.Errorf("merger %q variant for artifact kind %q is already registered", key.module, key.kind)
+	}
+	if registry.typedEntries == nil {
+		registry.typedEntries = make(map[artifactVariantKey]typedMergerEntry)
+	}
+	registry.typedEntries[key] = typedMergerEntry{
+		spec:      cloneModuleSpec(normalizedSpec),
+		valueType: reflect.TypeFor[T](),
+		constructor: func() (any, error) {
+			return constructor()
+		},
+	}
+	return nil
+}
+
+func (r *MergerRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawMerger, error) {
 	if r == nil {
 		return nil, fmt.Errorf("merger registry must not be nil")
 	}
-
 	normalizedKey := strings.TrimSpace(key)
 	if normalizedKey == "" {
 		return nil, fmt.Errorf("merger key must not be empty")
 	}
-
-	constructor, ok := r.constructors[normalizedKey]
+	constructor, ok := r.legacyConstructors[normalizedKey]
 	if !ok {
-		return nil, fmt.Errorf("merger %q is not registered", normalizedKey)
+		return nil, fmt.Errorf("legacy raw merger %q is not registered", normalizedKey)
 	}
-
 	merger, err := constructor()
 	if err != nil {
 		return nil, fmt.Errorf("build merger %q: %w", normalizedKey, err)
@@ -77,7 +120,6 @@ func (r *MergerRegistry) Build(key string) (contracts.Merger, error) {
 	if merger.Key() != normalizedKey {
 		return nil, fmt.Errorf("merger %q returned key %q", normalizedKey, merger.Key())
 	}
-
 	return merger, nil
 }
 
@@ -85,18 +127,46 @@ func (r *MergerRegistry) Spec(key string) (ModuleSpec, bool) {
 	if r == nil {
 		return ModuleSpec{}, false
 	}
-
-	spec, ok := r.specs[strings.TrimSpace(key)]
+	spec, ok := r.legacySpecs[strings.TrimSpace(key)]
 	if !ok {
 		return ModuleSpec{}, false
 	}
 	return cloneModuleSpec(spec), true
 }
 
+func (r *MergerRegistry) typedEntry(key string, kind contracts.ArtifactKind) (typedMergerEntry, bool) {
+	if r == nil {
+		return typedMergerEntry{}, false
+	}
+	entry, ok := r.typedEntries[artifactVariantKey{module: strings.TrimSpace(key), kind: normalizeArtifactKind(kind)}]
+	return entry, ok
+}
+
+func (r *MergerRegistry) registeredKinds(key string) []contracts.ArtifactKind {
+	if r == nil {
+		return nil
+	}
+	module := strings.TrimSpace(key)
+	kinds := make([]contracts.ArtifactKind, 0)
+	for variant := range r.typedEntries {
+		if variant.module == module {
+			kinds = append(kinds, variant.kind)
+		}
+	}
+	sortArtifactKinds(kinds)
+	return kinds
+}
+
 func (r *MergerRegistry) RegisteredKeys() []string {
 	if r == nil {
 		return nil
 	}
-
-	return sortedRegistryKeys(r.constructors)
+	keys := make(map[string]struct{}, len(r.legacySpecs)+len(r.typedEntries))
+	for key := range r.legacySpecs {
+		keys[key] = struct{}{}
+	}
+	for key := range r.typedEntries {
+		keys[key.module] = struct{}{}
+	}
+	return sortedRegistryKeys(keys)
 }