Add type-safe artifact lane resolution

internal/framework/pipeline/extractor_registry.go

@@ -2,71 +2,113 @@ package pipeline
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
 
 	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
 )
 
-type ExtractorConstructor func() (contracts.Extractor, error)
+type LegacyRawExtractorConstructor func() (contracts.LegacyRawExtractor, error)
 
 type ExtractorRegistry struct {
-	constructors map[string]ExtractorConstructor
-	specs        map[string]ModuleSpec
+	legacyConstructors map[string]LegacyRawExtractorConstructor
+	typedEntries       map[string]typedExtractorEntry
+	specs              map[string]ModuleSpec
+}
+
+type typedExtractorEntry struct {
+	spec        ModuleSpec
+	valueType   reflect.Type
+	constructor func() (any, error)
 }
 
 func NewExtractorRegistry() *ExtractorRegistry {
 	return &ExtractorRegistry{
-		constructors: make(map[string]ExtractorConstructor),
-		specs:        make(map[string]ModuleSpec),
+		legacyConstructors: make(map[string]LegacyRawExtractorConstructor),
+		typedEntries:       make(map[string]typedExtractorEntry),
+		specs:              make(map[string]ModuleSpec),
 	}
 }
 
-func (r *ExtractorRegistry) Register(key string, constructor ExtractorConstructor) error {
-	return r.RegisterWithSpec(defaultModuleSpec(key, StageExtract), constructor)
+func (r *ExtractorRegistry) RegisterLegacyRaw(key string, constructor LegacyRawExtractorConstructor) error {
+	return r.RegisterLegacyRawWithSpec(defaultModuleSpec(key, StageExtract), constructor)
 }
 
-func (r *ExtractorRegistry) RegisterWithSpec(spec ModuleSpec, constructor ExtractorConstructor) error {
+func (r *ExtractorRegistry) RegisterLegacyRawWithSpec(spec ModuleSpec, constructor LegacyRawExtractorConstructor) error {
 	if r == nil {
 		return fmt.Errorf("extractor registry must not be nil")
 	}
-
 	normalizedSpec := normalizeModuleSpec(spec)
 	if err := validateModuleSpec("extractor", StageExtract, normalizedSpec); err != nil {
 		return err
 	}
+	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 _, ok := r.constructors[normalizedSpec.Key]; ok {
+	if _, ok := r.specs[normalizedSpec.Key]; ok {
 		return fmt.Errorf("extractor %q is already registered", normalizedSpec.Key)
 	}
-
-	if r.constructors == nil {
-		r.constructors = make(map[string]ExtractorConstructor)
+	if r.legacyConstructors == nil {
+		r.legacyConstructors = make(map[string]LegacyRawExtractorConstructor)
 	}
 	if r.specs == nil {
 		r.specs = make(map[string]ModuleSpec)
 	}
-	r.constructors[normalizedSpec.Key] = constructor
+	r.legacyConstructors[normalizedSpec.Key] = constructor
 	r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
 	return nil
 }
 
-func (r *ExtractorRegistry) Build(key string) (contracts.Extractor, error) {
+func RegisterExtractor[T any](registry *ExtractorRegistry, spec ModuleSpec, constructor func() (contracts.Extractor[T], error)) error {
+	if registry == nil {
+		return fmt.Errorf("extractor registry must not be nil")
+	}
+	normalizedSpec := normalizeModuleSpec(spec)
+	if err := validateModuleSpec("extractor", StageExtract, normalizedSpec); err != nil {
+		return err
+	}
+	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 _, 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()
+		},
+	}
+	if registry.typedEntries == nil {
+		registry.typedEntries = make(map[string]typedExtractorEntry)
+	}
+	if registry.specs == nil {
+		registry.specs = make(map[string]ModuleSpec)
+	}
+	registry.typedEntries[normalizedSpec.Key] = entry
+	registry.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
+	return nil
+}
+
+func (r *ExtractorRegistry) BuildLegacyRaw(key string) (contracts.LegacyRawExtractor, error) {
 	if r == nil {
 		return nil, fmt.Errorf("extractor registry must not be nil")
 	}
-
 	normalizedKey := strings.TrimSpace(key)
 	if normalizedKey == "" {
 		return nil, fmt.Errorf("extractor key must not be empty")
 	}
-
-	constructor, ok := r.constructors[normalizedKey]
+	constructor, ok := r.legacyConstructors[normalizedKey]
 	if !ok {
-		return nil, fmt.Errorf("extractor %q is not registered", normalizedKey)
+		return nil, fmt.Errorf("legacy raw extractor %q is not registered", normalizedKey)
 	}
-
 	extractor, err := constructor()
 	if err != nil {
 		return nil, fmt.Errorf("build extractor %q: %w", normalizedKey, err)
@@ -77,7 +119,6 @@ func (r *ExtractorRegistry) Build(key string) (contracts.Extractor, error) {
 	if extractor.Key() != normalizedKey {
 		return nil, fmt.Errorf("extractor %q returned key %q", normalizedKey, extractor.Key())
 	}
-
 	return extractor, nil
 }
 
@@ -85,7 +126,6 @@ func (r *ExtractorRegistry) Spec(key string) (ModuleSpec, bool) {
 	if r == nil {
 		return ModuleSpec{}, false
 	}
-
 	spec, ok := r.specs[strings.TrimSpace(key)]
 	if !ok {
 		return ModuleSpec{}, false
@@ -93,10 +133,17 @@ func (r *ExtractorRegistry) Spec(key string) (ModuleSpec, bool) {
 	return cloneModuleSpec(spec), true
 }
 
+func (r *ExtractorRegistry) typedEntry(key string) (typedExtractorEntry, bool) {
+	if r == nil {
+		return typedExtractorEntry{}, false
+	}
+	entry, ok := r.typedEntries[strings.TrimSpace(key)]
+	return entry, ok
+}
+
 func (r *ExtractorRegistry) RegisteredKeys() []string {
 	if r == nil {
 		return nil
 	}
-
-	return sortedRegistryKeys(r.constructors)
+	return sortedRegistryKeys(r.specs)
 }