notarius/internal/framework/pipeline/extractor_registry.go

package pipeline

import (
	"fmt"
	"reflect"
	"strings"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)

type LegacyRawExtractorConstructor func() (contracts.LegacyRawExtractor, error)

type ExtractorRegistry struct {
	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{
		legacyConstructors: make(map[string]LegacyRawExtractorConstructor),
		typedEntries:       make(map[string]typedExtractorEntry),
		specs:              make(map[string]ModuleSpec),
	}
}

func (r *ExtractorRegistry) RegisterLegacyRaw(key string, constructor LegacyRawExtractorConstructor) error {
	return r.RegisterLegacyRawWithSpec(defaultModuleSpec(key, StageExtract), constructor)
}

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.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.specs == nil {
		r.specs = make(map[string]ModuleSpec)
	}
	r.legacyConstructors[normalizedSpec.Key] = constructor
	r.specs[normalizedSpec.Key] = cloneModuleSpec(normalizedSpec)
	return nil
}

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.legacyConstructors[normalizedKey]
	if !ok {
		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)
	}
	if extractor == nil {
		return nil, fmt.Errorf("extractor %q constructor returned nil", normalizedKey)
	}
	if extractor.Key() != normalizedKey {
		return nil, fmt.Errorf("extractor %q returned key %q", normalizedKey, extractor.Key())
	}
	return extractor, nil
}

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
	}
	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.specs)
}