Add type-safe artifact lane resolution

internal/framework/pipeline/normalizer_registry.go

@@ -2,71 +2,109 @@ package pipeline
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
 
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 )
 
-type NormalizerConstructor func() (contracts.Normalizer, error)
+type LegacyRawNormalizerConstructor func() (contracts.LegacyRawNormalizer, error)
 
 type NormalizerRegistry struct {
-	constructors map[string]NormalizerConstructor
-	specs        map[string]ModuleSpec
+	legacyConstructors map[string]LegacyRawNormalizerConstructor
+	legacySpecs        map[string]ModuleSpec
+	typedEntries       map[artifactVariantKey]typedNormalizerEntry
+}
+
+type typedNormalizerEntry struct {
+	spec        ModuleSpec
+	valueType   reflect.Type
+	constructor func() (any, error)
 }
 
 func NewNormalizerRegistry() *NormalizerRegistry {
 	return &NormalizerRegistry{
-		constructors: make(map[string]NormalizerConstructor),
-		specs:        make(map[string]ModuleSpec),
+		legacyConstructors: make(map[string]LegacyRawNormalizerConstructor),
+		legacySpecs:        make(map[string]ModuleSpec),
+		typedEntries:       make(map[artifactVariantKey]typedNormalizerEntry),
 	}
 }
 
-func (r *NormalizerRegistry) Register(key string, constructor NormalizerConstructor) error {
-	return r.RegisterWithSpec(defaultModuleSpec(key, StageNormalize), constructor)
+func (r *NormalizerRegistry) RegisterLegacyRaw(key string, constructor LegacyRawNormalizerConstructor) error {
+	return r.RegisterLegacyRawWithSpec(defaultModuleSpec(key, StageNormalize), constructor)
 }
 
-func (r *NormalizerRegistry) RegisterWithSpec(spec ModuleSpec, constructor NormalizerConstructor) error {
+func (r *NormalizerRegistry) RegisterLegacyRawWithSpec(spec ModuleSpec, constructor LegacyRawNormalizerConstructor) error {
 	if r == nil {
 		return fmt.Errorf("normalizer registry must not be nil")
 	}
-
 	normalizedSpec := normalizeModuleSpec(spec)
 	if err := validateModuleSpec("normalizer", StageNormalize, normalizedSpec); err != nil {
 		return err
 	}
+	if normalizedSpec.ArtifactKind != "" {
+		return fmt.Errorf("legacy raw normalizer %q must not declare an artifact kind", normalizedSpec.Key)
+	}
 	if constructor == nil {
 		return fmt.Errorf("normalizer constructor for %q must not be nil", normalizedSpec.Key)
 	}
-	if _, ok := r.constructors[normalizedSpec.Key]; ok {
-		return fmt.Errorf("normalizer %q is already registered", normalizedSpec.Key)
+	if _, ok := r.legacyConstructors[normalizedSpec.Key]; ok {
+		return fmt.Errorf("legacy raw normalizer %q is already registered", normalizedSpec.Key)
 	}
-
-	if r.constructors == nil {
-		r.constructors = make(map[string]NormalizerConstructor)
+	if r.legacyConstructors == nil {
+		r.legacyConstructors = make(map[string]LegacyRawNormalizerConstructor)
 	}
-	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 *NormalizerRegistry) Build(key string) (contracts.Normalizer, error) {
+func RegisterNormalizer[T any](registry *NormalizerRegistry, spec ModuleSpec, constructor func() (contracts.Normalizer[T], error)) error {
+	if registry == nil {
+		return fmt.Errorf("normalizer registry must not be nil")
+	}
+	normalizedSpec := normalizeModuleSpec(spec)
+	if err := validateModuleSpec("normalizer", StageNormalize, normalizedSpec); err != nil {
+		return err
+	}
+	if normalizedSpec.ArtifactKind == "" {
+		return fmt.Errorf("typed normalizer %q artifact kind must not be empty", normalizedSpec.Key)
+	}
+	if constructor == nil {
+		return fmt.Errorf("normalizer 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("normalizer %q variant for artifact kind %q is already registered", key.module, key.kind)
+	}
+	if registry.typedEntries == nil {
+		registry.typedEntries = make(map[artifactVariantKey]typedNormalizerEntry)
+	}
+	registry.typedEntries[key] = typedNormalizerEntry{
+		spec:      cloneModuleSpec(normalizedSpec),
+		valueType: reflect.TypeFor[T](),
+		constructor: func() (any, error) {
+			return constructor()
+		},
+	}
+	return nil
+}
+
+func (r *NormalizerRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawNormalizer, error) {
 	if r == nil {
 		return nil, fmt.Errorf("normalizer registry must not be nil")
 	}
-
 	normalizedKey := strings.TrimSpace(key)
 	if normalizedKey == "" {
 		return nil, fmt.Errorf("normalizer key must not be empty")
 	}
-
-	constructor, ok := r.constructors[normalizedKey]
+	constructor, ok := r.legacyConstructors[normalizedKey]
 	if !ok {
-		return nil, fmt.Errorf("normalizer %q is not registered", normalizedKey)
+		return nil, fmt.Errorf("legacy raw normalizer %q is not registered", normalizedKey)
 	}
-
 	normalizer, err := constructor()
 	if err != nil {
 		return nil, fmt.Errorf("build normalizer %q: %w", normalizedKey, err)
@@ -77,7 +115,6 @@ func (r *NormalizerRegistry) Build(key string) (contracts.Normalizer, error) {
 	if normalizer.Key() != normalizedKey {
 		return nil, fmt.Errorf("normalizer %q returned key %q", normalizedKey, normalizer.Key())
 	}
-
 	return normalizer, nil
 }
 
@@ -85,18 +122,46 @@ func (r *NormalizerRegistry) 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 *NormalizerRegistry) typedEntry(key string, kind contracts.ArtifactKind) (typedNormalizerEntry, bool) {
+	if r == nil {
+		return typedNormalizerEntry{}, false
+	}
+	entry, ok := r.typedEntries[artifactVariantKey{module: strings.TrimSpace(key), kind: normalizeArtifactKind(kind)}]
+	return entry, ok
+}
+
+func (r *NormalizerRegistry) 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 *NormalizerRegistry) 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)
 }