Cleanup And Support Disabling

Author: its-hammer-time

config/config.go

@@ -31,7 +31,8 @@ type ValidationOptions struct {
 	AllowScalarCoercion           bool // Enable string->boolean/number coercion
 	Formats                       map[string]func(v any) error
 	SchemaCache                   cache.SchemaCache // Optional cache for compiled schemas
-	PathLookup                    radix.PathLookup  // O(k) path lookup via radix tree (built automatically)
+	PathTree                      radix.PathLookup  // O(k) path lookup via radix tree (built automatically)
+	pathTreeSet                   bool              // Internal: true if PathTree was explicitly set via WithPathTree
 	Logger                        *slog.Logger      // Logger for debug/error output (nil = silent)
 	AllowXMLBodyValidation        bool              // Allows to convert XML to JSON for validating a request/response body.
 	AllowURLEncodedBodyValidation bool              // Allows to convert URL Encoded to JSON for validating a request/response body.
@@ -78,7 +79,8 @@ func WithExistingOpts(options *ValidationOptions) Option {
 			o.AllowScalarCoercion = options.AllowScalarCoercion
 			o.Formats = options.Formats
 			o.SchemaCache = options.SchemaCache
-			o.PathLookup = options.PathLookup
+			o.PathTree = options.PathTree
+			o.pathTreeSet = options.pathTreeSet
 			o.Logger = options.Logger
 			o.AllowXMLBodyValidation = options.AllowXMLBodyValidation
 			o.AllowURLEncodedBodyValidation = options.AllowURLEncodedBodyValidation
@@ -193,11 +195,13 @@ func WithSchemaCache(schemaCache cache.SchemaCache) Option {
 	}
 }
 
-// WithPathLookup sets a custom path lookup implementation.
-// The default is a radix tree built from the OpenAPI specification.
-func WithPathLookup(pathLookup radix.PathLookup) Option {
+// WithPathTree sets a custom radix tree for path matching.
+// The default is built automatically from the OpenAPI specification.
+// Pass nil to disable the radix tree and use regex-based matching only.
+func WithPathTree(pathTree radix.PathLookup) Option {
 	return func(o *ValidationOptions) {
-		o.PathLookup = pathLookup
+		o.PathTree = pathTree
+		o.pathTreeSet = true
 	}
 }
 
@@ -264,6 +268,11 @@ var defaultIgnoredHeaders = []string{
 	"request-start-time", // Added by some API clients for timing
 }
 
+// IsPathTreeSet returns true if PathTree was explicitly configured via WithPathTree.
+func (o *ValidationOptions) IsPathTreeSet() bool {
+	return o.pathTreeSet
+}
+
 // GetEffectiveStrictIgnoredHeaders returns the list of headers to ignore
 // based on configuration. Returns defaults if not configured, merged list
 // if extra headers were added, or replaced list if headers were fully replaced.

parameters/path_parameters_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/pb33f/libopenapi-validator/config"
 	"github.com/pb33f/libopenapi-validator/helpers"
 	"github.com/pb33f/libopenapi-validator/paths"
+	"github.com/pb33f/libopenapi-validator/radix"
 )
 
 func TestNewValidator_SimpleArrayEncodedPath(t *testing.T) {
@@ -2321,7 +2322,7 @@ paths:
 	m, _ := doc.BuildV3Model()
 
 	cache := &regexCacheWatcher{inner: &sync.Map{}}
-	opts := &config.ValidationOptions{RegexCache: cache}
+	opts := &config.ValidationOptions{RegexCache: cache, PathTree: radix.BuildPathTree(&m.Model)}
 
 	// Simple path - should NOT use regex cache (handled by radix tree)
 	simpleRequest, _ := http.NewRequest(http.MethodGet, "https://things.com/simple/123", nil)

paths/paths.go

@@ -18,7 +18,6 @@ import (
 	"github.com/pb33f/libopenapi-validator/config"
 	"github.com/pb33f/libopenapi-validator/errors"
 	"github.com/pb33f/libopenapi-validator/helpers"
-	"github.com/pb33f/libopenapi-validator/radix"
 )
 
 // FindPath will find the path in the document that matches the request path. If a successful match was found, then
@@ -37,26 +36,13 @@ func FindPath(request *http.Request, document *v3.Document, options *config.Vali
 	stripped := StripRequestPath(request, document)
 
 	// Fast path: try radix tree first (O(k) where k = path depth)
-	tree := pathLookupFrom(options, document)
-	if tree != nil {
-		if pathItem, matchedPath, found := tree.Lookup(stripped); found {
-			// Verify the path has the requested method
+	// If no path lookup is provided, we will fall back to regex-based matching.
+	if options != nil && options.PathTree != nil {
+		if pathItem, matchedPath, found := options.PathTree.Lookup(stripped); found {
 			if pathHasMethod(pathItem, request.Method) {
 				return pathItem, nil, matchedPath
 			}
-			// Path found but method doesn't exist
-			validationErrors := []*errors.ValidationError{{
-				ValidationType:    helpers.ParameterValidationPath,
-				ValidationSubType: "missingOperation",
-				Message:           fmt.Sprintf("%s Path '%s' not found", request.Method, request.URL.Path),
-				Reason: fmt.Sprintf("The %s method for that path does not exist in the specification",
-					request.Method),
-				SpecLine: -1,
-				SpecCol:  -1,
-				HowToFix: errors.HowToFixPath,
-			}}
-			errors.PopulateValidationErrors(validationErrors, request, matchedPath)
-			return pathItem, validationErrors, matchedPath
+			return pathItem, missingOperationError(request, matchedPath), matchedPath
 		}
 	}
 
@@ -128,18 +114,7 @@ func FindPath(request *http.Request, document *v3.Document, options *config.Vali
 	}
 
 	// path matches exist but none have the required method
-	validationErrors := []*errors.ValidationError{{
-		ValidationType:    helpers.PathValidation,
-		ValidationSubType: helpers.ValidationMissingOperation,
-		Message:           fmt.Sprintf("%s Path '%s' not found", request.Method, request.URL.Path),
-		Reason: fmt.Sprintf("The %s method for that path does not exist in the specification",
-			request.Method),
-		SpecLine: -1,
-		SpecCol:  -1,
-		HowToFix: errors.HowToFixPath,
-	}}
-	errors.PopulateValidationErrors(validationErrors, request, bestOverall.path)
-	return bestOverall.pathItem, validationErrors, bestOverall.path
+	return bestOverall.pathItem, missingOperationError(request, bestOverall.path), bestOverall.path
 }
 
 // normalizePathForMatching removes the fragment from a path template unless
@@ -257,13 +232,18 @@ func comparePaths(mapped, requested, basePaths []string, regexCache config.Regex
 	return checkPathAgainstBase(l, r, basePaths)
 }
 
-// pathLookupFrom returns the PathLookup from options, or builds one from the document.
-func pathLookupFrom(options *config.ValidationOptions, document *v3.Document) radix.PathLookup {
-	if options != nil && options.PathLookup != nil {
-		return options.PathLookup
-	}
-	if document != nil && document.Paths != nil {
-		return radix.BuildPathTree(document)
-	}
-	return nil
+// missingOperationError returns a validation error for when a path was found but the HTTP method doesn't exist.
+func missingOperationError(request *http.Request, matchedPath string) []*errors.ValidationError {
+	validationErrors := []*errors.ValidationError{{
+		ValidationType:    helpers.PathValidation,
+		ValidationSubType: helpers.ValidationMissingOperation,
+		Message:           fmt.Sprintf("%s Path '%s' not found", request.Method, request.URL.Path),
+		Reason: fmt.Sprintf("The %s method for that path does not exist in the specification",
+			request.Method),
+		SpecLine: -1,
+		SpecCol:  -1,
+		HowToFix: errors.HowToFixPath,
+	}}
+	errors.PopulateValidationErrors(validationErrors, request, matchedPath)
+	return validationErrors
 }