Add typed spell validation strategies

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

@@ -11,42 +11,73 @@ import (
 const Key = "generic/valid_json"
 const ReasonCodeInvalidJSON = "invalid_json"
 
-var _ contracts.LegacyRawValidator = (*Validator)(nil)
+type Options struct{}
 
 type Validator struct{}
 
-func New() *Validator {
-	return &Validator{}
-}
+type legacyValidator struct{}
 
-func (v *Validator) Name() string {
-	return Key
-}
+var _ contracts.SerializedValidator = (*Validator)(nil)
+var _ contracts.LegacyRawValidator = (*legacyValidator)(nil)
+
+func New(Options) *Validator { return &Validator{} }
+
+func (v *Validator) Name() string { return Key }
 
 func (v *Validator) ExecutionClass() contracts.ExecutionClass {
 	return contracts.ExecutionClassDeterministic
 }
 
-func (v *Validator) Validate(ctx context.Context, req contracts.ValidationRequest) (contracts.ValidationResult, error) {
-	if !json.Valid(req.Payload.Content) {
-		return contracts.ValidationResult{
-			Approved:   false,
-			ReasonCode: ReasonCodeInvalidJSON,
-			Message:    "payload is not valid JSON",
-		}, nil
+func (v *Validator) Validate(_ context.Context, req contracts.SerializedValidationRequest) (contracts.ValidationResult, error) {
+	return validate(req.Content), nil
+}
+
+func (v *legacyValidator) Name() string { return Key }
+
+func (v *legacyValidator) ExecutionClass() contracts.ExecutionClass {
+	return contracts.ExecutionClassDeterministic
+}
+
+func (v *legacyValidator) Validate(_ context.Context, req contracts.ValidationRequest) (contracts.ValidationResult, error) {
+	return validate(req.Payload.Content), nil
+}
+
+func validate(content []byte) contracts.ValidationResult {
+	if !json.Valid(content) {
+		return contracts.ValidationResult{Approved: false, ReasonCode: ReasonCodeInvalidJSON, Message: "payload is not valid JSON"}
 	}
-	return contracts.ValidationResult{Approved: true}, nil
+	return contracts.ValidationResult{Approved: true}
 }
 
 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.RegisterSerializedValidatorBuilder(registry, pipeline.SerializedValidatorSpec{
+		ValidatorSpec: Spec(), SupportsChunks: true, SupportsArtifacts: true,
+	}, validateOptions, func(request pipeline.BuildRequest) (contracts.SerializedValidator, error) {
+		options, err := DecodeOptions(request.Options)
+		if err != nil {
+			return nil, err
+		}
+		return New(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 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 }