Add typed spell validation strategies

internal/modules/generic/validate/always_accept/validator.go

@@ -9,35 +9,76 @@ import (
 
 const Key = "generic/always_accept"
 
-var _ contracts.LegacyRawValidator = (*Validator)(nil)
+type Options struct{}
+type ChunkValidator struct{}
+type TypedValidator[T any] struct{}
+type legacyValidator struct{}
 
-type Validator struct{}
+var _ contracts.ChunkValidator = (*ChunkValidator)(nil)
 
-func New() *Validator {
-	return &Validator{}
-}
+func NewChunk(Options) *ChunkValidator           { return &ChunkValidator{} }
+func NewTyped[T any](Options) *TypedValidator[T] { return &TypedValidator[T]{} }
 
-func (v *Validator) Name() string {
-	return Key
-}
-
-func (v *Validator) ExecutionClass() contracts.ExecutionClass {
+func (v *ChunkValidator) Name() string { return Key }
+func (v *ChunkValidator) ExecutionClass() contracts.ExecutionClass {
 	return contracts.ExecutionClassDeterministic
 }
+func (v *ChunkValidator) Validate(context.Context, contracts.ChunkValidationRequest) (contracts.ValidationResult, error) {
+	return contracts.ValidationResult{Approved: true}, nil
+}
 
-func (v *Validator) Validate(ctx context.Context, req contracts.ValidationRequest) (contracts.ValidationResult, error) {
+func (v *TypedValidator[T]) Name() string { return Key }
+func (v *TypedValidator[T]) ExecutionClass() contracts.ExecutionClass {
+	return contracts.ExecutionClassDeterministic
+}
+func (v *TypedValidator[T]) Validate(context.Context, contracts.TypedValidationRequest[T]) (contracts.ValidationResult, error) {
+	return contracts.ValidationResult{Approved: true}, nil
+}
+
+func (v *legacyValidator) Name() string { return Key }
+func (v *legacyValidator) ExecutionClass() contracts.ExecutionClass {
+	return contracts.ExecutionClassDeterministic
+}
+func (v *legacyValidator) Validate(context.Context, contracts.ValidationRequest) (contracts.ValidationResult, error) {
 	return contracts.ValidationResult{Approved: true}, nil
 }
 
 func Spec() pipeline.ValidatorSpec {
-	return pipeline.ValidatorSpec{
-		Key:            Key,
-		ExecutionClass: contracts.ExecutionClassDeterministic,
-	}
+	return pipeline.ValidatorSpec{Key: Key, ExecutionClass: contracts.ExecutionClassDeterministic}
 }
 
 func Register(registry *pipeline.ValidatorRegistry) error {
-	return registry.RegisterLegacyRawWithSpec(Spec(), func() (contracts.LegacyRawValidator, error) {
-		return New(), nil
+	if err := pipeline.RegisterChunkValidatorBuilder(registry, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.ChunkValidator, error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return NewChunk(options), nil
+	}); err != nil {
+		return err
+	}
+	return registry.RegisterLegacyRawBuilderWithSpec(Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.LegacyRawValidator, error) {
+		if _, err := DecodeOptions(request.Options); err != nil {
+			return nil, err
+		}
+		return &legacyValidator{}, nil
 	})
 }
+
+func RegisterTyped[T any](registry *pipeline.ValidatorRegistry, kind contracts.ArtifactKind) error {
+	return pipeline.RegisterTypedValidatorBuilder(registry, kind, Spec(), validateOptions, func(request pipeline.BuildRequest) (contracts.TypedValidator[T], error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return NewTyped[T](options), nil
+	})
+}
+
+func DecodeOptions(options map[string]any) (Options, error) {
+	if err := pipeline.RejectUnknownOptions(options); err != nil {
+		return Options{}, err
+	}
+	return Options{}, nil
+}
+func validateOptions(options map[string]any) error { _, err := DecodeOptions(options); return err }

internal/modules/generic/validate/always_accept/validator_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestValidatorApproves(t *testing.T) {
-	result, err := New().Validate(context.Background(), contracts.ValidationRequest{})
+	result, err := NewChunk(Options{}).Validate(context.Background(), contracts.ChunkValidationRequest{})
 	if err != nil {
 		t.Fatalf("Validate() error = %v, want nil", err)
 	}