fix: improved handling of type validation errors and their message content

Author: TristanSpeakEasy

arazzo/arazzo.go

@@ -107,11 +107,11 @@ func (a *Arazzo) Validate(ctx context.Context, opts ...validation.Option) []erro
 
 	arazzoMajor, arazzoMinor, arazzoPatch, err := utils.ParseVersion(a.Arazzo)
 	if err != nil {
-		errs = append(errs, validation.NewValueError(validation.NewValueValidationError("arazzo field version is invalid %s: %s", a.Arazzo, err.Error()), core, core.Arazzo))
+		errs = append(errs, validation.NewValueError(validation.NewValueValidationError("arazzo.version is invalid %s: %s", a.Arazzo, err.Error()), core, core.Arazzo))
 	}
 
 	if arazzoMajor != VersionMajor || arazzoMinor != VersionMinor || arazzoPatch > VersionPatch {
-		errs = append(errs, validation.NewValueError(validation.NewValueValidationError("arazzo field version only %s and below is supported", Version), core, core.Arazzo))
+		errs = append(errs, validation.NewValueError(validation.NewValueValidationError("arazzo.version only %s and below is supported", Version), core, core.Arazzo))
 	}
 
 	errs = append(errs, a.Info.Validate(ctx, opts...)...)
@@ -122,7 +122,7 @@ func (a *Arazzo) Validate(ctx context.Context, opts ...validation.Option) []erro
 		errs = append(errs, sourceDescription.Validate(ctx, opts...)...)
 
 		if _, ok := sourceDescriptionNames[sourceDescription.Name]; ok {
-			errs = append(errs, validation.NewSliceError(validation.NewValueValidationError("sourceDescription field name %s is not unique", sourceDescription.Name), core, core.SourceDescriptions, i))
+			errs = append(errs, validation.NewSliceError(validation.NewValueValidationError("sourceDescription.name %s is not unique", sourceDescription.Name), core, core.SourceDescriptions, i))
 		}
 
 		sourceDescriptionNames[sourceDescription.Name] = true
@@ -134,7 +134,7 @@ func (a *Arazzo) Validate(ctx context.Context, opts ...validation.Option) []erro
 		errs = append(errs, workflow.Validate(ctx, opts...)...)
 
 		if _, ok := workflowIds[workflow.WorkflowID]; ok {
-			errs = append(errs, validation.NewSliceError(validation.NewValueValidationError("workflow field workflowId %s is not unique", workflow.WorkflowID), core, core.Workflows, i))
+			errs = append(errs, validation.NewSliceError(validation.NewValueValidationError("workflow.workflowId %s is not unique", workflow.WorkflowID), core, core.Workflows, i))
 		}
 
 		workflowIds[workflow.WorkflowID] = true

arazzo/arazzo_examples_test.go

@@ -190,6 +190,6 @@ func Example_validating() {
 		fmt.Printf("%s\n", err.Error())
 	}
 	// Output:
-	// [3:3] info field version is missing
+	// [3:3] info.version is missing
 	// [13:9] step at least one of operationId, operationPath or workflowId fields must be set
 }

arazzo/arazzo_test.go

@@ -303,11 +303,11 @@ sourceDescriptions:
 		column          int
 		underlyingError error
 	}{
-		{line: 1, column: 1, underlyingError: validation.NewMissingFieldError("arazzo field workflows is missing")},
-		{line: 1, column: 9, underlyingError: validation.NewValueValidationError("arazzo field version only 1.0.1 and below is supported")},
-		{line: 4, column: 3, underlyingError: validation.NewMissingFieldError("info field version is missing")},
-		{line: 6, column: 5, underlyingError: validation.NewMissingFieldError("sourceDescription field url is missing")},
-		{line: 7, column: 11, underlyingError: validation.NewValueValidationError("sourceDescription field type must be one of [openapi, arazzo]")},
+		{line: 1, column: 1, underlyingError: validation.NewMissingFieldError("arazzo.workflows is missing")},
+		{line: 1, column: 9, underlyingError: validation.NewValueValidationError("arazzo.version only 1.0.1 and below is supported")},
+		{line: 4, column: 3, underlyingError: validation.NewMissingFieldError("info.version is missing")},
+		{line: 6, column: 5, underlyingError: validation.NewMissingFieldError("sourceDescription.url is missing")},
+		{line: 7, column: 11, underlyingError: validation.NewValueValidationError("sourceDescription.type must be one of [openapi, arazzo]")},
 	}
 
 	require.Len(t, validationErrs, len(expectedErrors), "number of validation errors should match")
@@ -635,7 +635,7 @@ var stressTests = []struct {
 		args: args{
 			location: "https://raw.githubusercontent.com/frankkilcommins/simple-spectral-arazzo-GA/4ec8856f1cf21c0f77597c715c150ef3e2772a89/apis/OnlineStore.arazzo.yaml",
 			validationIgnores: []string{
-				"field title is missing", // legit issue
+				"info.title is missing", // legit issue
 				"operationId must be a valid expression if there are multiple OpenAPI source descriptions", // legit issue
 				"$responses.body.menuItems[0].subcategories[0].id",                                         // legit issue
 			},

arazzo/components.go

@@ -44,15 +44,15 @@ func (c *Components) Validate(ctx context.Context, opts ...validation.Option) []
 
 	for key, input := range c.Inputs.All() {
 		if !componentNameRegex.MatchString(key) {
-			errs = append(errs, validation.NewMapKeyError(validation.NewValueValidationError("components field inputs key must be a valid key [%s]: %s", componentNameRegex.String(), key), core, core.Inputs, key))
+			errs = append(errs, validation.NewMapKeyError(validation.NewValueValidationError("components.inputs key must be a valid key [%s]: %s", componentNameRegex.String(), key), core, core.Inputs, key))
 		}
 
 		errs = append(errs, input.Validate(ctx, opts...)...)
 	}
 
 	for key, parameter := range c.Parameters.All() {
 		if !componentNameRegex.MatchString(key) {
-			errs = append(errs, validation.NewMapKeyError(validation.NewValueValidationError("components field parameters key must be a valid key [%s]: %s", componentNameRegex.String(), key), core, core.Parameters, key))
+			errs = append(errs, validation.NewMapKeyError(validation.NewValueValidationError("components.parameters key must be a valid key [%s]: %s", componentNameRegex.String(), key), core, core.Parameters, key))
 		}
 
 		paramOps := opts
@@ -63,7 +63,7 @@ func (c *Components) Validate(ctx context.Context, opts ...validation.Option) []
 
 	for key, successAction := range c.SuccessActions.All() {
 		if !componentNameRegex.MatchString(key) {
-			errs = append(errs, validation.NewMapKeyError(validation.NewValueValidationError("components field successActions key must be a valid key [%s]: %s", componentNameRegex.String(), key), core, core.SuccessActions, key))
+			errs = append(errs, validation.NewMapKeyError(validation.NewValueValidationError("components.successActions key must be a valid key [%s]: %s", componentNameRegex.String(), key), core, core.SuccessActions, key))
 		}
 
 		successActionOps := opts
@@ -74,7 +74,7 @@ func (c *Components) Validate(ctx context.Context, opts ...validation.Option) []
 
 	for key, failureAction := range c.FailureActions.All() {
 		if !componentNameRegex.MatchString(key) {
-			errs = append(errs, validation.NewMapKeyError(validation.NewValueValidationError("components field failureActions key must be a valid key [%s]: %s", componentNameRegex.String(), key), core, core.FailureActions, key))
+			errs = append(errs, validation.NewMapKeyError(validation.NewValueValidationError("components.failureActions key must be a valid key [%s]: %s", componentNameRegex.String(), key), core, core.FailureActions, key))
 		}
 
 		failureActionOps := opts

arazzo/core/criterion.go

@@ -63,7 +63,7 @@ func (c *CriterionTypeUnion) Unmarshal(ctx context.Context, parentName string, n
 		c.DetermineValidity(validationErrs)
 	default:
 		return []error{
-			validation.NewValidationError(validation.NewTypeMismatchError("criterionTypeUnion expected scalar or mapping node, got %s", yml.NodeKindToString(resolvedNode.Kind)), resolvedNode),
+			validation.NewValidationError(validation.NewTypeMismatchError(parentName, "criterionTypeUnion expected string or object, got %s", yml.NodeKindToString(resolvedNode.Kind)), resolvedNode),
 		}, nil
 	}
 

arazzo/core/reusable.go

@@ -37,7 +37,7 @@ func (r *Reusable[T]) Unmarshal(ctx context.Context, parentName string, node *ya
 		r.SetValid(false, false)
 
 		return []error{
-			validation.NewValidationError(validation.NewTypeMismatchError("reusable expected mapping node, got %s", yml.NodeKindToString(resolvedNode.Kind)), resolvedNode),
+			validation.NewValidationError(validation.NewTypeMismatchError(parentName, "reusable expected object, got %s", yml.NodeKindToString(resolvedNode.Kind)), resolvedNode),
 		}, nil
 	}
 

arazzo/failureaction.go

@@ -69,22 +69,22 @@ func (f *FailureAction) Validate(ctx context.Context, opts ...validation.Option)
 	errs := []error{}
 
 	if core.Name.Present && f.Name == "" {
-		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("failureAction field name is required"), core, core.Name))
+		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("failureAction.name is required"), core, core.Name))
 	}
 
 	switch f.Type {
 	case FailureActionTypeEnd:
 		if f.WorkflowID != nil {
-			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field workflowId is not allowed when type: end is specified"), core, core.WorkflowID))
+			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.workflowId is not allowed when type: end is specified"), core, core.WorkflowID))
 		}
 		if f.StepID != nil {
-			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field stepId is not allowed when type: end is specified"), core, core.StepID))
+			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.stepId is not allowed when type: end is specified"), core, core.StepID))
 		}
 		if f.RetryAfter != nil {
-			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field retryAfter is not allowed when type: end is specified"), core, core.RetryAfter))
+			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.retryAfter is not allowed when type: end is specified"), core, core.RetryAfter))
 		}
 		if f.RetryLimit != nil {
-			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field retryLimit is not allowed when type: end is specified"), core, core.RetryLimit))
+			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.retryLimit is not allowed when type: end is specified"), core, core.RetryLimit))
 		}
 	case FailureActionTypeGoto:
 		workflowIDNode := core.WorkflowID.GetKeyNodeOrRoot(core.RootNode)
@@ -100,10 +100,10 @@ func (f *FailureAction) Validate(ctx context.Context, opts ...validation.Option)
 			required:       true,
 		}, opts...)...)
 		if f.RetryAfter != nil {
-			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field retryAfter is not allowed when type: goto is specified"), core, core.RetryAfter))
+			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.retryAfter is not allowed when type: goto is specified"), core, core.RetryAfter))
 		}
 		if f.RetryLimit != nil {
-			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field retryLimit is not allowed when type: goto is specified"), core, core.RetryLimit))
+			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.retryLimit is not allowed when type: goto is specified"), core, core.RetryLimit))
 		}
 	case FailureActionTypeRetry:
 		workflowIDNode := core.WorkflowID.GetKeyNodeOrRoot(core.RootNode)
@@ -120,16 +120,16 @@ func (f *FailureAction) Validate(ctx context.Context, opts ...validation.Option)
 		}, opts...)...)
 		if f.RetryAfter != nil {
 			if *f.RetryAfter < 0 {
-				errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field retryAfter must be greater than or equal to 0"), core, core.RetryAfter))
+				errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.retryAfter must be greater than or equal to 0"), core, core.RetryAfter))
 			}
 		}
 		if f.RetryLimit != nil {
 			if *f.RetryLimit < 0 {
-				errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field retryLimit must be greater than or equal to 0"), core, core.RetryLimit))
+				errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.retryLimit must be greater than or equal to 0"), core, core.RetryLimit))
 			}
 		}
 	default:
-		errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction field type must be one of [%s]", strings.Join([]string{string(FailureActionTypeEnd), string(FailureActionTypeGoto), string(FailureActionTypeRetry)}, ", ")), core, core.Type))
+		errs = append(errs, validation.NewValueError(validation.NewValueValidationError("failureAction.type must be one of [%s]", strings.Join([]string{string(FailureActionTypeEnd), string(FailureActionTypeGoto), string(FailureActionTypeRetry)}, ", ")), core, core.Type))
 	}
 
 	for i := range f.Criteria {

arazzo/info.go

@@ -34,11 +34,11 @@ func (i *Info) Validate(ctx context.Context, opts ...validation.Option) []error
 	errs := []error{}
 
 	if core.Title.Present && i.Title == "" {
-		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("info field title is required"), core, core.Title))
+		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("info.title is required"), core, core.Title))
 	}
 
 	if core.Version.Present && i.Version == "" {
-		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("info field version is required"), core, core.Version))
+		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("info.version is required"), core, core.Version))
 	}
 
 	i.Valid = len(errs) == 0 && core.GetValid()

arazzo/parameter.go

@@ -71,17 +71,17 @@ func (p *Parameter) Validate(ctx context.Context, opts ...validation.Option) []e
 	default:
 		if p.In == nil || in == "" {
 			if w == nil && s != nil && s.WorkflowID == nil {
-				errs = append(errs, validation.NewValueError(validation.NewMissingValueError("parameter field in is required within a step when workflowId is not set"), core, core.In))
+				errs = append(errs, validation.NewValueError(validation.NewMissingValueError("parameter.in is required within a step when workflowId is not set"), core, core.In))
 			}
 		}
 
 		if in != "" {
-			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("parameter field in must be one of [%s] but was %s", strings.Join([]string{string(InPath), string(InQuery), string(InHeader), string(InCookie)}, ", "), in), core, core.In))
+			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("parameter.in must be one of [%s] but was %s", strings.Join([]string{string(InPath), string(InQuery), string(InHeader), string(InCookie)}, ", "), in), core, core.In))
 		}
 	}
 
 	if core.Value.Present && p.Value == nil {
-		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("parameter field value is required"), core, core.Value))
+		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("parameter.value is required"), core, core.Value))
 	} else if p.Value != nil {
 		_, expression, err := expression.GetValueOrExpressionValue(p.Value)
 		if err != nil {

arazzo/payloadreplacement.go

@@ -32,23 +32,23 @@ func (p *PayloadReplacement) Validate(ctx context.Context, opts ...validation.Op
 	errs := []error{}
 
 	if core.Target.Present && p.Target == "" {
-		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("payloadReplacement field target is required"), core, core.Target))
+		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("payloadReplacement.target is required"), core, core.Target))
 	}
 
 	if err := p.Target.Validate(); err != nil {
-		errs = append(errs, validation.NewValueError(validation.NewValueValidationError("payloadReplacement field target is invalid: "+err.Error()), core, core.Target))
+		errs = append(errs, validation.NewValueError(validation.NewValueValidationError("payloadReplacement.target is invalid: "+err.Error()), core, core.Target))
 	}
 
 	if core.Value.Present && p.Value == nil {
-		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("payloadReplacement field value is required"), core, core.Value))
+		errs = append(errs, validation.NewValueError(validation.NewMissingValueError("payloadReplacement.value is required"), core, core.Value))
 	} else if p.Value != nil {
 		_, expression, err := expression.GetValueOrExpressionValue(p.Value)
 		if err != nil {
-			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("payloadReplacement field value is invalid: "+err.Error()), core, core.Value))
+			errs = append(errs, validation.NewValueError(validation.NewValueValidationError("payloadReplacement.value is invalid: "+err.Error()), core, core.Value))
 		}
 		if expression != nil {
 			if err := expression.Validate(); err != nil {
-				errs = append(errs, validation.NewValueError(validation.NewValueValidationError("payloadReplacement field value is invalid: "+err.Error()), core, core.Value))
+				errs = append(errs, validation.NewValueError(validation.NewValueValidationError("payloadReplacement.value is invalid: "+err.Error()), core, core.Value))
 			}
 		}
 	}