test

Author: vm-001

openapi.yml

@@ -1018,3 +1018,24 @@ components:
         signing_secret:
           type: string
           minLength: 1
+
+    JsonschemaValidatorPluginConfiguration:
+      type: object
+      properties:
+        draft:
+          type: string
+          enum: ["6"]
+          default: "6"
+        default_schema:
+          type: string
+          format: jsonschema
+          maxLength: 1048576
+        schemas:
+          type: object
+          additionalProperties:
+            type: object
+            properties:
+              schema:
+                type: string
+                format: jsonschema
+                maxLength: 1048576

pkg/cache/redis.go

@@ -16,7 +16,7 @@ type RedisCache struct {
 func NewRedisCache(client *redis.Client) *RedisCache {
 	return &RedisCache{
 		c: client,
-		s: serializer.Gob,
+		s: serializer.JSON, // FIXME: breaking change (test)
 	}
 }
 

pkg/openapi/openapi.go

@@ -1,13 +1,32 @@
 package openapi
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"github.com/getkin/kin-openapi/openapi3"
 	"github.com/webhookx-io/webhookx/pkg/errs"
 	"strconv"
 )
 
+type FormatValidatorFunc[T any] func(T) error
+
+func (fn FormatValidatorFunc[T]) Validate(value T) error { return fn(value) }
+
+func init() {
+	openapi3.DefineStringFormatValidator("jsonschema", FormatValidatorFunc[string](func(s string) error {
+		schema := &openapi3.Schema{}
+		if err := schema.UnmarshalJSON([]byte(s)); err != nil {
+			return err
+		}
+		// compare to doc.Validat in LoadOpenAPI() ?
+		if err := schema.Validate(context.TODO(), openapi3.EnableSchemaFormatValidation()); err != nil {
+			return err
+		}
+		return nil
+	}))
+}
+
 func SetDefaults(schema *openapi3.Schema, defaults map[string]interface{}) error {
 	data := make(map[string]interface{})
 	_ = schema.VisitJSON(data,
@@ -126,9 +145,9 @@ func insertError(current map[string]interface{}, i int, paths []string, err *ope
 				arr[index] = formatError(err)
 			}
 		} else {
-			if err.Origin == nil {
-				current[key] = formatError(err)
-			}
+			//if err.Origin == nil { // TODO???
+			current[key] = formatError(err)
+			//}
 		}
 		return
 	}

plugins/jsonschema_validator/plugin.go

@@ -3,99 +3,37 @@ package jsonschema_validator
 import (
 	"context"
 	"encoding/json"
-	"errors"
-	"fmt"
 	"github.com/getkin/kin-openapi/openapi3"
-	"github.com/webhookx-io/webhookx/pkg/errs"
+	"github.com/webhookx-io/webhookx/db/entities"
 	"github.com/webhookx-io/webhookx/pkg/http/response"
 	"github.com/webhookx-io/webhookx/pkg/plugin"
 	"github.com/webhookx-io/webhookx/pkg/types"
 	"github.com/webhookx-io/webhookx/plugins/jsonschema_validator/jsonschema"
-	"github.com/webhookx-io/webhookx/utils"
 )
 
 type Config struct {
-	Draft         string             `json:"draft" validate:"required,oneof=6 default:6"`
-	DefaultSchema string             `json:"default_schema" validate:"omitempty,json,max=1048576"`
-	Schemas       map[string]*Schema `json:"schemas" validate:"dive"`
+	Draft         string             `json:"draft"`
+	DefaultSchema string             `json:"default_schema"`
+	Schemas       map[string]*Schema `json:"schemas"`
+}
+
+func (c Config) Schema() *openapi3.Schema {
+	return entities.LookupSchema("JsonschemaValidatorPluginConfiguration")
 }
 
 type Schema struct {
-	Schema string `json:"schema" validate:"omitempty,json,max=1048576"`
+	Schema string `json:"schema"`
 }
 
 type SchemaValidatorPlugin struct {
 	plugin.BasePlugin[Config]
 }
 
-func New(config []byte) (plugin.Plugin, error) {
-	p := &SchemaValidatorPlugin{}
-	p.Name = "jsonschema-validator"
-
-	if config != nil {
-		if err := p.UnmarshalConfig(config); err != nil {
-			return nil, err
-		}
-	}
-	return p, nil
-}
-
-func unmarshalAndValidateSchema(schema string) (*openapi3.Schema, error) {
-	openapiSchema := &openapi3.Schema{}
-	err := openapiSchema.UnmarshalJSON([]byte(schema))
-	if err != nil {
-		return nil, fmt.Errorf("value must be a valid jsonschema")
-	}
-	err = openapiSchema.Validate(context.Background(), openapi3.EnableSchemaFormatValidation())
-	if err != nil {
-		return openapiSchema, err
-	}
-	return openapiSchema, nil
-}
-
-func (p *SchemaValidatorPlugin) ValidateConfig() error {
-	err := utils.Validate(p.Config)
-	if err != nil {
-		return err
-	}
-
-	e := errs.NewValidateError(errors.New("request validation"))
-
-	var defaultErr error
-	if p.Config.DefaultSchema != "" {
-		_, err := unmarshalAndValidateSchema(p.Config.DefaultSchema)
-		if err != nil {
-			defaultErr = err
-			e.Fields = map[string]interface{}{
-				"default_schema": err.Error(),
-			}
-		}
-	}
-
-	for event, schema := range p.Config.Schemas {
-		field := fmt.Sprintf("schemas[%s]", event)
-		if schema == nil || schema.Schema == "" {
-			if defaultErr != nil {
-				e.Fields[field] = map[string]string{
-					"schema": "invalid due to reusing the default_schema definition",
-				}
-			}
-		} else {
-			_, err = unmarshalAndValidateSchema(schema.Schema)
-			if err != nil {
-				e.Fields[field] = map[string]string{
-					"schema": err.Error(),
-				}
-			}
-		}
-	}
-	if len(e.Fields) > 0 {
-		return e
-	}
-	return nil
+func (p *SchemaValidatorPlugin) Name() string {
+	return "jsonschema-validator"
 }
 
-func (p *SchemaValidatorPlugin) ExecuteInbound(inbound *plugin.Inbound) (res plugin.InboundResult, err error) {
+func (p *SchemaValidatorPlugin) ExecuteInbound(ctx context.Context, inbound *plugin.Inbound) (res plugin.InboundResult, err error) {
 	var event map[string]any
 	body := inbound.RawBody
 	if err = json.Unmarshal(body, &event); err != nil {

test/cmd/admin_test.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	. "github.com/onsi/ginkgo/v2"
 	"github.com/stretchr/testify/assert"
@@ -107,7 +108,9 @@ var _ = Describe("admin", Ordered, func() {
 				assert.EqualValues(GinkgoT(), map[string]interface{}{"function": "function handle() {}"}, plugins[0].Config)
 				assert.Equal(GinkgoT(), `jsonschema-validator`, plugins[1].Name)
 				assert.Equal(GinkgoT(), true, plugins[1].Enabled)
-				assert.Equal(GinkgoT(), `{"draft": "6", "schemas": {"charge.succeeded": {"schema": "{\n  \"type\": \"object\",\n  \"properties\": {\n      \"id\": { \"type\": \"string\" },\n      \"amount\": { \"type\": \"integer\", \"minimum\": 1 },\n      \"currency\": { \"type\": \"string\", \"minLength\": 3, \"maxLength\": 6 }\n  },\n  \"required\": [\"id\", \"amount\", \"currency\"]\n}\n"}}, "default_schema": "{\n  \"type\": \"object\",\n  \"properties\": {\n      \"id\": { \"type\": \"string\" }\n  },\n  \"required\": [\"id\"]\n}\n"}`, string(plugins[1].Config))
+				assert.JSONEq(GinkgoT(),
+					`{"draft": "6", "schemas": {"charge.succeeded": {"schema": "{\n  \"type\": \"object\",\n  \"properties\": {\n      \"id\": { \"type\": \"string\" },\n      \"amount\": { \"type\": \"integer\", \"minimum\": 1 },\n      \"currency\": { \"type\": \"string\", \"minLength\": 3, \"maxLength\": 6 }\n  },\n  \"required\": [\"id\", \"amount\", \"currency\"]\n}\n"}}, "default_schema": "{\n  \"type\": \"object\",\n  \"properties\": {\n      \"id\": { \"type\": \"string\" }\n  },\n  \"required\": [\"id\"]\n}\n"}`,
+					string(utils.Must(json.Marshal(plugins[1].Config))))
 			})
 
 			It("entities not defined in the declarative configuration should be deleted", func() {

test/declarative/declarative_test.go

@@ -146,7 +146,7 @@ var _ = Describe("Declarative", Ordered, func() {
 				assert.Nil(GinkgoT(), err)
 				assert.Equal(GinkgoT(), 400, resp.StatusCode())
 				assert.Equal(GinkgoT(),
-					`{"message":"Request Validation","error":{"message":"request validation","fields":{"config":{"default_schema":"value must be a valid json string","draft":"required field missing","schemas[charge.succeed]":{"schema":"value must be a valid json string"}}}}}`,
+					`{"message":"Request Validation","error":{"message":"request validation","fields":{"config":{"default_schema":"string doesn't match the format \"jsonschema\" (invalid character 'i' looking for beginning of value)","schemas":{"charge.succeed":{"schema":"string doesn't match the format \"jsonschema\" (invalid character 'i' looking for beginning of value)"}}}}}}`,
 					string(resp.Body()))
 			})
 
@@ -159,7 +159,7 @@ var _ = Describe("Declarative", Ordered, func() {
 				assert.Nil(GinkgoT(), err)
 				assert.Equal(GinkgoT(), 400, resp.StatusCode())
 				assert.Equal(GinkgoT(),
-					`{"message":"Request Validation","error":{"message":"request validation","fields":{"config":{"default_schema":"unsupported 'type' value \"invlidObject\"","schemas[charge.succeed]":{"schema":"unsupported 'format' value \"invalid\""},"schemas[reuse.default_schema]":{"schema":"invalid due to reusing the default_schema definition"}}}}}`,
+					`{"message":"Request Validation","error":{"message":"request validation","fields":{"config":{"default_schema":"string doesn't match the format \"jsonschema\" (unsupported 'type' value \"invlidObject\")","schemas":{"charge.succeed":{"schema":"string doesn't match the format \"jsonschema\" (unsupported 'format' value \"invalid\")"},"reuse.default_schema":"Value is not nullable"}}}}}`,
 					string(resp.Body()))
 			})
 		})

test/plugins/jsonschema_validator_test.go

@@ -69,11 +69,10 @@ var _ = Describe("jsonschema-validator", Ordered, func() {
 			db = helper.InitDB(true, &entitiesConfig)
 			proxyClient = helper.ProxyClient()
 
-			app = utils.Must(helper.Start(map[string]string{
-				"WEBHOOKX_ADMIN_LISTEN":   "0.0.0.0:8080",
-				"WEBHOOKX_PROXY_LISTEN":   "0.0.0.0:8081",
-				"WEBHOOKX_WORKER_ENABLED": "true",
-			}))
+			app = utils.Must(helper.Start(map[string]string{}))
+
+			err := helper.WaitForServer(helper.ProxyHttpURL, time.Second)
+			assert.NoError(GinkgoT(), err)
 		})
 
 		AfterAll(func() {