Add regex cache to avoid constant recompilations

config/config.go

@@ -1,12 +1,24 @@
 package config
 
-import "github.com/santhosh-tekuri/jsonschema/v6"
+import (
+	"github.com/santhosh-tekuri/jsonschema/v6"
+)
+
+// RegexCache can be set to enable compiled regex caching.
+// It can be just a sync.Map, or a custom implementation with possible cleanup.
+//
+// Be aware that the cache should be thread safe
+type RegexCache interface {
+	Load(key any) (value any, ok bool) // Get a compiled regex from the cache
+	Store(key, value any)              // Set a compiled regex to the cache
+}
 
 // ValidationOptions A container for validation configuration.
 //
 // Generally fluent With... style functions are used to establish the desired behavior.
 type ValidationOptions struct {
 	RegexEngine         jsonschema.RegexpEngine
+	RegexCache          RegexCache // Enable compiled regex caching
 	FormatAssertions    bool
 	ContentAssertions   bool
 	SecurityValidation  bool
@@ -44,6 +56,7 @@ func WithExistingOpts(options *ValidationOptions) Option {
 	return func(o *ValidationOptions) {
 		if options != nil {
 			o.RegexEngine = options.RegexEngine
+			o.RegexCache = options.RegexCache
 			o.FormatAssertions = options.FormatAssertions
 			o.ContentAssertions = options.ContentAssertions
 			o.SecurityValidation = options.SecurityValidation
@@ -61,6 +74,14 @@ func WithRegexEngine(engine jsonschema.RegexpEngine) Option {
 	}
 }
 
+// WithRegexCache assigns a cache for compiled regular expressions.
+// A sync.Map should be sufficient for most use cases. It does not implement any cleanup
+func WithRegexCache(regexCache RegexCache) Option {
+	return func(o *ValidationOptions) {
+		o.RegexCache = regexCache
+	}
+}
+
 // WithFormatAssertions enables checks for 'format' assertions (such as date, date-time, uuid, etc)
 func WithFormatAssertions() Option {
 	return func(o *ValidationOptions) {

config/config_test.go

@@ -4,6 +4,7 @@
 package config
 
 import (
+	"sync"
 	"testing"
 
 	"github.com/santhosh-tekuri/jsonschema/v6"
@@ -20,6 +21,7 @@ func TestNewValidationOptions_Defaults(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestNewValidationOptions_WithNilOption(t *testing.T) {
@@ -32,6 +34,7 @@ func TestNewValidationOptions_WithNilOption(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestWithFormatAssertions(t *testing.T) {
@@ -43,6 +46,7 @@ func TestWithFormatAssertions(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestWithContentAssertions(t *testing.T) {
@@ -54,6 +58,7 @@ func TestWithContentAssertions(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestWithoutSecurityValidation(t *testing.T) {
@@ -65,6 +70,7 @@ func TestWithoutSecurityValidation(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestWithRegexEngine(t *testing.T) {
@@ -79,13 +85,15 @@ func TestWithRegexEngine(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestWithExistingOpts(t *testing.T) {
 	// Create original options with all settings enabled
 	var testEngine jsonschema.RegexpEngine = nil
 	original := &ValidationOptions{
 		RegexEngine:        testEngine,
+		RegexCache:         &sync.Map{},
 		FormatAssertions:   true,
 		ContentAssertions:  true,
 		SecurityValidation: false,
@@ -95,6 +103,7 @@ func TestWithExistingOpts(t *testing.T) {
 	opts := NewValidationOptions(WithExistingOpts(original))
 
 	assert.Nil(t, opts.RegexEngine) // Both should be nil
+	assert.NotNil(t, opts.RegexCache)
 	assert.Equal(t, original.FormatAssertions, opts.FormatAssertions)
 	assert.Equal(t, original.ContentAssertions, opts.ContentAssertions)
 	assert.Equal(t, original.SecurityValidation, opts.SecurityValidation)
@@ -112,6 +121,7 @@ func TestWithExistingOpts_NilSource(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestMultipleOptions(t *testing.T) {
@@ -126,6 +136,7 @@ func TestMultipleOptions(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestOptionOverride(t *testing.T) {
@@ -142,6 +153,7 @@ func TestOptionOverride(t *testing.T) {
 	assert.True(t, opts.OpenAPIMode)          // Default is true
 	assert.False(t, opts.AllowScalarCoercion) // Default is false
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestWithExistingOpts_PartialOverride(t *testing.T) {
@@ -160,7 +172,8 @@ func TestWithExistingOpts_PartialOverride(t *testing.T) {
 		WithContentAssertions(), // This should still be true (no change)
 	)
 
-	assert.Nil(t, opts.RegexEngine)          // Both should be nil
+	assert.Nil(t, opts.RegexEngine) // Both should be nil
+	assert.Nil(t, opts.RegexCache)
 	assert.True(t, opts.FormatAssertions)    // From original
 	assert.True(t, opts.ContentAssertions)   // Reapplied, but same value
 	assert.False(t, opts.SecurityValidation) // From original
@@ -189,6 +202,7 @@ func TestComplexScenario(t *testing.T) {
 	assert.True(t, opts.ContentAssertions)   // Added
 	assert.False(t, opts.SecurityValidation) // From base
 	assert.Nil(t, opts.RegexEngine)          // Should be nil
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestMultipleOptionsWithSecurityDisabled(t *testing.T) {
@@ -202,6 +216,7 @@ func TestMultipleOptionsWithSecurityDisabled(t *testing.T) {
 	assert.True(t, opts.ContentAssertions)
 	assert.False(t, opts.SecurityValidation)
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestWithExistingOpts_SecurityValidationCopied(t *testing.T) {
@@ -296,6 +311,7 @@ func TestComplexOpenAPIScenario(t *testing.T) {
 	assert.True(t, opts.ContentAssertions)
 	assert.False(t, opts.SecurityValidation)
 	assert.Nil(t, opts.RegexEngine)
+	assert.Nil(t, opts.RegexCache)
 }
 
 func TestWithExistingOpts_OpenAPIFields(t *testing.T) {
@@ -329,3 +345,11 @@ func TestWithCustomFormat(t *testing.T) {
 	assert.Contains(t, opts.Formats, "test-format")
 	assert.NotNil(t, opts.Formats["test-format"])
 }
+
+func TestWithRegexpCache(t *testing.T) {
+	syncMap := &sync.Map{}
+
+	opts := NewValidationOptions(WithRegexCache(syncMap))
+
+	assert.NotNil(t, opts.RegexCache)
+}

helpers/regex_maker.go

@@ -7,6 +7,12 @@ import (
 	"strings"
 )
 
+var (
+	baseDefaultPattern        = "[^/]*"
+	DefaultPatternRegex       = regexp.MustCompile("^([^/]*)$")
+	DefaultPatternRegexString = DefaultPatternRegex.String()
+)
+
 // GetRegexForPath returns a compiled regular expression for the given path template.
 //
 // This function takes a path template string `tpl` and generates a regular expression
@@ -42,9 +48,6 @@ func GetRegexForPath(tpl string) (*regexp.Regexp, error) {
 	// Backup the original.
 	template := tpl
 
-	// Now let's parse it.
-	defaultPattern := "[^/]*"
-
 	pattern := bytes.NewBufferString("^")
 	var end int
 
@@ -55,7 +58,7 @@ func GetRegexForPath(tpl string) (*regexp.Regexp, error) {
 		end = idxs[i+1]
 		parts := strings.SplitN(tpl[idxs[i]+1:end-1], ":", 2)
 		name := parts[0]
-		patt := defaultPattern
+		patt := baseDefaultPattern
 		if len(parts) == 2 {
 			patt = parts[1]
 		}
@@ -79,8 +82,14 @@ func GetRegexForPath(tpl string) (*regexp.Regexp, error) {
 
 	pattern.WriteByte('$')
 
+	patternString := pattern.String()
+
+	if patternString == DefaultPatternRegexString {
+		return DefaultPatternRegex, nil
+	}
+
 	// Compile full regexp.
-	reg, errCompile := regexp.Compile(pattern.String())
+	reg, errCompile := regexp.Compile(patternString)
 	if errCompile != nil {
 		return nil, errCompile
 	}

helpers/regex_maker_test.go

@@ -2,6 +2,8 @@ package helpers
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestGetRegexForPath(t *testing.T) {
@@ -61,6 +63,12 @@ func TestGetRegexForPath(t *testing.T) {
 			wantErr:  false,
 			wantExpr: "^/entities\\('([0-9]+)'\\)$",
 		},
+		{
+			name:     "get default pattern",
+			tpl:      "/{param}",
+			wantErr:  false,
+			wantExpr: "^/([^/]*)$",
+		},
 	}
 
 	for _, tt := range tests {
@@ -128,6 +136,14 @@ func TestBraceIndices(t *testing.T) {
 	}
 }
 
+func TestDefaultPatternCompileCache(t *testing.T) {
+	res, err := GetRegexForPath("{param}")
+
+	assert.Nil(t, err)
+	assert.Equal(t, res, DefaultPatternRegex)
+	assert.Equal(t, res.String(), DefaultPatternRegexString)
+}
+
 func equal(a, b []int) bool {
 	if len(a) != len(b) {
 		return false

parameters/cookie_parameters.go

@@ -19,7 +19,7 @@ import (
 )
 
 func (v *paramValidator) ValidateCookieParams(request *http.Request) (bool, []*errors.ValidationError) {
-	pathItem, errs, foundPath := paths.FindPath(request, v.document)
+	pathItem, errs, foundPath := paths.FindPath(request, v.document, v.options.RegexCache)
 	if len(errs) > 0 {
 		return false, errs
 	}

parameters/cookie_parameters_test.go

@@ -5,6 +5,7 @@ package parameters
 
 import (
 	"net/http"
+	"sync"
 	"testing"
 
 	"github.com/pb33f/libopenapi"
@@ -690,7 +691,7 @@ paths:
 	request.AddCookie(&http.Cookie{Name: "PattyPreference", Value: "2500"}) // too many dude.
 
 	// preset the path
-	path, _, pv := paths.FindPath(request, &m.Model)
+	path, _, pv := paths.FindPath(request, &m.Model, &sync.Map{})
 
 	valid, errors := v.ValidateCookieParamsWithPathItem(request, path, pv)
 
@@ -720,7 +721,7 @@ paths:
 	request.AddCookie(&http.Cookie{Name: "PattyPreference", Value: "2500"}) // too many dude.
 
 	// preset the path
-	path, _, pv := paths.FindPath(request, &m.Model)
+	path, _, pv := paths.FindPath(request, &m.Model, nil)
 
 	valid, errors := v.ValidateCookieParamsWithPathItem(request, path, pv)
 

parameters/header_parameters.go

@@ -21,7 +21,7 @@ import (
 )
 
 func (v *paramValidator) ValidateHeaderParams(request *http.Request) (bool, []*errors.ValidationError) {
-	pathItem, errs, foundPath := paths.FindPath(request, v.document)
+	pathItem, errs, foundPath := paths.FindPath(request, v.document, v.options.RegexCache)
 	if len(errs) > 0 {
 		return false, errs
 	}

parameters/header_parameters_test.go

@@ -5,6 +5,7 @@ package parameters
 
 import (
 	"net/http"
+	"sync"
 	"testing"
 
 	"github.com/pb33f/libopenapi"
@@ -717,7 +718,7 @@ paths:
 	request.Header.Set("coffeecups", "1200") // that's a lot of cups dude, we only have one dishwasher.
 
 	// preset the path
-	path, _, pv := paths.FindPath(request, &m.Model)
+	path, _, pv := paths.FindPath(request, &m.Model, nil)
 
 	valid, errors := v.ValidateHeaderParamsWithPathItem(request, path, pv)
 
@@ -748,7 +749,7 @@ paths:
 	request.Header.Set("coffeecups", "1200") // that's a lot of cups dude, we only have one dishwasher.
 
 	// preset the path
-	path, _, pv := paths.FindPath(request, &m.Model)
+	path, _, pv := paths.FindPath(request, &m.Model, &sync.Map{})
 
 	valid, errors := v.ValidateHeaderParamsWithPathItem(request, path, pv)
 

parameters/path_parameters.go

@@ -21,7 +21,7 @@ import (
 )
 
 func (v *paramValidator) ValidatePathParams(request *http.Request) (bool, []*errors.ValidationError) {
-	pathItem, errs, foundPath := paths.FindPath(request, v.document)
+	pathItem, errs, foundPath := paths.FindPath(request, v.document, v.options.RegexCache)
 	if len(errs) > 0 {
 		return false, errs
 	}
@@ -57,13 +57,29 @@ func (v *paramValidator) ValidatePathParamsWithPathItem(request *http.Request, p
 					continue
 				}
 
-				r, err := helpers.GetRegexForPath(pathSegments[x])
-				if err != nil {
-					continue
+				var rgx *regexp.Regexp
+
+				if v.options.RegexCache != nil {
+					if cachedRegex, found := v.options.RegexCache.Load(pathSegments[x]); found {
+						rgx = cachedRegex.(*regexp.Regexp)
+					}
+				}
+
+				if rgx == nil {
+
+					r, err := helpers.GetRegexForPath(pathSegments[x])
+					if err != nil {
+						continue
+					}
+
+					rgx = r
+
+					if v.options.RegexCache != nil {
+						v.options.RegexCache.Store(pathSegments[x], r)
+					}
 				}
 
-				re := regexp.MustCompile(r.String())
-				matches := re.FindStringSubmatch(submittedSegments[x])
+				matches := rgx.FindStringSubmatch(submittedSegments[x])
 				matches = matches[1:]
 
 				// Check if it is well-formed.