Schema validator plugin

pkg/plugin/definition/schemaValidator.go

@@ -0,0 +1,38 @@
+package definition
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+// SchemaValError represents a single schema validation failure.
+type SchemaValError struct {
+	Path    string
+	Message string
+}
+
+// SchemaValidationErr represents a collection of schema validation failures.
+type SchemaValidationErr struct {
+	Errors []SchemaValError
+}
+
+// Validator interface for schema validation.
+type SchemaValidator interface {
+	Validate(ctx context.Context, url *url.URL, payload []byte) error
+}
+
+// ValidatorProvider interface for creating validators.
+type SchemaValidatorProvider interface {
+	New(ctx context.Context, config map[string]string) (SchemaValidator, func() error, error)
+}
+
+// Error implements the error interface for SchemaValidationErr.
+func (e *SchemaValidationErr) Error() string {
+	var errorMessages []string
+	for _, err := range e.Errors {
+		errorMessages = append(errorMessages, fmt.Sprintf("%s: %s", err.Path, err.Message))
+	}
+	return strings.Join(errorMessages, "; ")
+}

pkg/plugin/implementation/schemaValidator/cmd/plugin.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"context"
+	"errors"
+
+	definition "github.com/beckn/beckn-onix/pkg/plugin/definition"
+	validator "github.com/beckn/beckn-onix/pkg/plugin/implementation/schemaValidator"
+)
+
+// ValidatorProvider provides instance of Validator.
+type schemaValidatorProvider struct{}
+
+// New initializes a new Verifier instance.
+func (vp schemaValidatorProvider) New(ctx context.Context, config map[string]string) (definition.SchemaValidator, func() error, error) {
+	if ctx == nil {
+		return nil, nil, errors.New("context cannot be nil")
+	}
+
+	// Extract schema_dir from the config map
+	schemaDir, ok := config["schema_dir"]
+	if !ok || schemaDir == "" {
+		return nil, nil, errors.New("config must contain 'schema_dir'")
+	}
+
+	// Create a new Validator instance with the provided configuration
+	return validator.New(ctx, &validator.Config{
+		SchemaDir: schemaDir, // Pass the schemaDir to the validator.Config
+	})
+}
+
+// Provider is the exported symbol that the plugin manager will look for.
+var Provider definition.SchemaValidatorProvider = &schemaValidatorProvider{}

pkg/plugin/implementation/schemaValidator/cmd/plugin_test.go

@@ -0,0 +1,148 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// setupTestSchema creates a temporary directory and writes a sample schema file.
+func setupTestSchema(t *testing.T) string {
+	t.Helper()
+
+	// Create a temporary directory for the schema
+	schemaDir, err := os.MkdirTemp("", "schemas")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+
+	// Create the directory structure for the schema file
+	schemaFilePath := filepath.Join(schemaDir, "example", "1.0", "test_schema.json")
+	if err := os.MkdirAll(filepath.Dir(schemaFilePath), 0755); err != nil {
+		t.Fatalf("Failed to create schema directory structure: %v", err)
+	}
+
+	// Define a sample schema
+	schemaContent := `{
+		"type": "object",
+		"properties": {
+			"context": {
+				"type": "object",
+				"properties": {
+					"domain": {"type": "string"},
+					"version": {"type": "string"}
+				},
+				"required": ["domain", "version"]
+			}
+		},
+		"required": ["context"]
+	}`
+
+	// Write the schema to the file
+	if err := os.WriteFile(schemaFilePath, []byte(schemaContent), 0644); err != nil {
+		t.Fatalf("Failed to write schema file: %v", err)
+	}
+
+	return schemaDir
+}
+
+// TestValidatorProviderSuccess tests successful ValidatorProvider implementation.
+func TestValidatorProviderSuccess(t *testing.T) {
+	schemaDir := setupTestSchema(t)
+	defer os.RemoveAll(schemaDir)
+
+	// Define test cases.
+	tests := []struct {
+		name          string
+		ctx           context.Context
+		config        map[string]string
+		expectedError string
+	}{
+		{
+			name:          "Valid schema directory",
+			ctx:           context.Background(), // Valid context
+			config:        map[string]string{"schema_dir": schemaDir},
+			expectedError: "",
+		},
+	}
+
+	// Test using table-driven tests
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vp := schemaValidatorProvider{}
+			validator, close, err := vp.New(tt.ctx, tt.config)
+
+			// Ensure no error occurred
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+				return
+			}
+
+			// Ensure the validator is not nil
+			if validator == nil {
+				t.Error("expected a non-nil validator, got nil")
+			}
+
+			// Ensure the close function is not nil
+			if close == nil {
+				t.Error("expected a non-nil close function, got nil")
+			}
+
+			// Test the close function
+			if err := close(); err != nil {
+				t.Errorf("close function returned an error: %v", err)
+			}
+		})
+	}
+}
+
+// TestValidatorProviderSuccess tests cases where ValidatorProvider creation should fail.
+func TestValidatorProviderFailure(t *testing.T) {
+	schemaDir := setupTestSchema(t)
+	defer os.RemoveAll(schemaDir)
+
+	// Define test cases.
+	tests := []struct {
+		name          string
+		ctx           context.Context
+		config        map[string]string
+		expectedError string
+	}{
+		{
+			name:          "Invalid schema directory",
+			ctx:           context.Background(), // Valid context
+			config:        map[string]string{"schema_dir": "/invalid/dir"},
+			expectedError: "failed to initialise validator: schema directory does not exist: /invalid/dir",
+		},
+		{
+			name:          "Nil context",
+			ctx:           nil, // Nil context
+			config:        map[string]string{"schema_dir": schemaDir},
+			expectedError: "context cannot be nil",
+		},
+	}
+
+	// Test using table-driven tests
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			vp := schemaValidatorProvider{}
+			_, _, err := vp.New(tt.ctx, tt.config)
+
+			// Check for expected error
+			if tt.expectedError != "" {
+				if err == nil || !strings.Contains(err.Error(), tt.expectedError) {
+					t.Errorf("expected error %q, got %v", tt.expectedError, err)
+				}
+				return
+			}
+
+			// Ensure no error occurred
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+				return
+			}
+		})
+	}
+}

pkg/plugin/implementation/schemaValidator/schemaValidator.go

@@ -0,0 +1,201 @@
+package schemaValidator
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	definition "github.com/beckn/beckn-onix/pkg/plugin/definition"
+
+	"github.com/santhosh-tekuri/jsonschema/v6"
+)
+
+// Payload represents the structure of the data payload with context information.
+type payload struct {
+	Context struct {
+		Domain  string `json:"domain"`
+		Version string `json:"version"`
+	} `json:"context"`
+}
+
+// Validator implements the Validator interface.
+type SchemaValidator struct {
+	config      *Config
+	schemaCache map[string]*jsonschema.Schema
+}
+
+type Config struct {
+	SchemaDir string
+}
+
+// New creates a new ValidatorProvider instance.
+func New(ctx context.Context, config *Config) (*SchemaValidator, func() error, error) {
+	// Check if config is nil
+	if config == nil {
+		return nil, nil, fmt.Errorf("config cannot be nil")
+	}
+	v := &SchemaValidator{
+		config:      config,
+		schemaCache: make(map[string]*jsonschema.Schema),
+	}
+
+	// Call Initialise function to load schemas and get validators
+	if err := v.Initialise(); err != nil {
+		return nil, nil, fmt.Errorf("failed to initialise validator: %v", err)
+	}
+	return v, v.Close, nil
+}
+
+// Validate validates the given data against the schema.
+func (v *SchemaValidator) Validate(ctx context.Context, url *url.URL, data []byte) error {
+	var payloadData payload
+	err := json.Unmarshal(data, &payloadData)
+	if err != nil {
+		return fmt.Errorf("failed to parse JSON payload: %v", err)
+	}
+
+	// Extract domain, version, and endpoint from the payload and uri.
+	cxt_domain := payloadData.Context.Domain
+	version := payloadData.Context.Version
+	version = fmt.Sprintf("v%s", version)
+
+	endpoint := path.Base(url.String())
+	// ToDo Add debug log here
+	fmt.Println("Handling request for endpoint:", endpoint)
+	domain := strings.ToLower(cxt_domain)
+	domain = strings.ReplaceAll(domain, ":", "_")
+
+	// Construct the schema file name.
+	schemaFileName := fmt.Sprintf("%s_%s_%s", domain, version, endpoint)
+
+	// Retrieve the schema from the cache.
+	schema, exists := v.schemaCache[schemaFileName]
+	if !exists {
+		return fmt.Errorf("schema not found for domain: %s", schemaFileName)
+	}
+
+	var jsonData any
+	if err := json.Unmarshal(data, &jsonData); err != nil {
+		return fmt.Errorf("failed to parse JSON data: %v", err)
+	}
+	err = schema.Validate(jsonData)
+	if err != nil {
+		// Handle schema validation errors
+		if validationErr, ok := err.(*jsonschema.ValidationError); ok {
+			// Convert validation errors into an array of SchemaValError
+			var schemaErrors []definition.SchemaValError
+			for _, cause := range validationErr.Causes {
+				// Extract the path and message from the validation error
+				path := strings.Join(cause.InstanceLocation, ".") // JSON path to the invalid field
+				message := cause.Error()                          // Validation error message
+
+				// Append the error to the schemaErrors array
+				schemaErrors = append(schemaErrors, definition.SchemaValError{
+					Path:    path,
+					Message: message,
+				})
+			}
+			// Return the array of schema validation errors
+			return &definition.SchemaValidationErr{Errors: schemaErrors}
+		}
+		// Return a generic error for non-validation errors
+		return fmt.Errorf("validation failed: %v", err)
+	}
+
+	// Return nil if validation succeeds
+	return nil
+}
+
+// ValidatorProvider provides instances of Validator.
+type ValidatorProvider struct{}
+
+// Initialise initialises the validator provider by compiling all the JSON schema files
+// from the specified directory and storing them in a cache indexed by their schema filenames.
+func (v *SchemaValidator) Initialise() error {
+	schemaDir := v.config.SchemaDir
+	// Check if the directory exists and is accessible.
+	info, err := os.Stat(schemaDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("schema directory does not exist: %s", schemaDir)
+		}
+		return fmt.Errorf("failed to access schema directory: %v", err)
+	}
+	if !info.IsDir() {
+		return fmt.Errorf("provided schema path is not a directory: %s", schemaDir)
+	}
+
+	compiler := jsonschema.NewCompiler()
+
+	// Helper function to process directories recursively.
+	var processDir func(dir string) error
+	processDir = func(dir string) error {
+		entries, err := os.ReadDir(dir)
+		if err != nil {
+			return fmt.Errorf("failed to read directory: %v", err)
+		}
+
+		for _, entry := range entries {
+			path := filepath.Join(dir, entry.Name())
+			if entry.IsDir() {
+				// Recursively process subdirectories.
+				if err := processDir(path); err != nil {
+					return err
+				}
+			} else if filepath.Ext(entry.Name()) == ".json" {
+				// Process JSON files.
+				compiledSchema, err := compiler.Compile(path)
+				if err != nil {
+					return fmt.Errorf("failed to compile JSON schema from file %s: %v", entry.Name(), err)
+				}
+
+				// Use relative path from schemaDir to avoid absolute paths and make schema keys domain/version specific.
+				relativePath, err := filepath.Rel(schemaDir, path)
+				if err != nil {
+					return fmt.Errorf("failed to get relative path for file %s: %v", entry.Name(), err)
+				}
+				// Split the relative path to get domain, version, and schema.
+				parts := strings.Split(relativePath, string(os.PathSeparator))
+
+				// Ensure that the file path has at least 3 parts: domain, version, and schema file.
+				if len(parts) < 3 {
+					return fmt.Errorf("invalid schema file structure, expected domain/version/schema.json but got: %s", relativePath)
+				}
+
+				// Extract domain, version, and schema filename from the parts.
+				// Validate that the extracted parts are non-empty.
+				domain := strings.TrimSpace(parts[0])
+				version := strings.TrimSpace(parts[1])
+				schemaFileName := strings.TrimSpace(parts[2])
+				schemaFileName = strings.TrimSuffix(schemaFileName, ".json")
+
+				if domain == "" || version == "" || schemaFileName == "" {
+					return fmt.Errorf("invalid schema file structure, one or more components are empty. Relative path: %s", relativePath)
+				}
+
+				// Construct a unique key combining domain, version, and schema name (e.g., ondc_trv10_v2.0.0_schema).
+				uniqueKey := fmt.Sprintf("%s_%s_%s", domain, version, schemaFileName)
+				// Store the compiled schema in the SchemaCache using the unique key.
+				v.schemaCache[uniqueKey] = compiledSchema
+			}
+		}
+		return nil
+	}
+
+	// Start processing from the root schema directory.
+	if err := processDir(schemaDir); err != nil {
+		return fmt.Errorf("failed to read schema directory: %v", err)
+	}
+
+	return nil
+}
+
+// Close releases resources (mock implementation returning nil).
+func (v *SchemaValidator) Close() error {
+	return nil
+}

pkg/plugin/implementation/schemaValidator/schemaValidator_test.go

@@ -0,0 +1,363 @@
+package schemaValidator
+
+import (
+	"context"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/beckn/beckn-onix/pkg/plugin/definition"
+)
+
+// setupTestSchema creates a temporary directory and writes a sample schema file.
+func setupTestSchema(t *testing.T) string {
+	t.Helper()
+
+	// Create a temporary directory for the schema
+	schemaDir, err := os.MkdirTemp("", "schemas")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+
+	// Create the directory structure for the schema file
+	schemaFilePath := filepath.Join(schemaDir, "example", "v1.0", "endpoint.json")
+	if err := os.MkdirAll(filepath.Dir(schemaFilePath), 0755); err != nil {
+		t.Fatalf("Failed to create schema directory structure: %v", err)
+	}
+
+	// Define a sample schema
+	schemaContent := `{
+		"type": "object",
+		"properties": {
+			"context": {
+				"type": "object",
+				"properties": {
+					"domain": {"type": "string"},
+					"version": {"type": "string"},
+					"action": {"type": "string"}
+				},
+				"required": ["domain", "version", "action"]
+			}
+		},
+		"required": ["context"]
+	}`
+
+	// Write the schema to the file
+	if err := os.WriteFile(schemaFilePath, []byte(schemaContent), 0644); err != nil {
+		t.Fatalf("Failed to write schema file: %v", err)
+	}
+
+	return schemaDir
+}
+
+func TestValidator_Validate_Success(t *testing.T) {
+	tests := []struct {
+		name      string
+		url       string
+		payload   string
+		wantValid bool
+	}{
+		{
+			name:      "Valid payload",
+			url:       "http://example.com/endpoint",
+			payload:   `{"context": {"domain": "example", "version": "1.0", "action": "endpoint"}}`,
+			wantValid: true,
+		},
+	}
+
+	// Setup a temporary schema directory for testing
+	schemaDir := setupTestSchema(t)
+	defer os.RemoveAll(schemaDir)
+
+	config := &Config{SchemaDir: schemaDir}
+	v, _, err := New(context.Background(), config)
+	if err != nil {
+		t.Fatalf("Failed to create validator: %v", err)
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			u, _ := url.Parse(tt.url)
+			valid, err := v.Validate(context.Background(), u, []byte(tt.payload))
+			if err != (definition.SchemaValError{}) {
+				t.Errorf("Unexpected error: %v", err)
+			}
+			if valid != tt.wantValid {
+				t.Errorf("Error: Validate() returned valid = %v, expected valid = %v", valid, tt.wantValid)
+			}
+		})
+	}
+}
+
+func TestValidator_Validate_Failure(t *testing.T) {
+	tests := []struct {
+		name      string
+		url       string
+		payload   string
+		wantValid bool
+		wantErr   string
+	}{
+		{
+			name:      "Invalid JSON payload",
+			url:       "http://example.com/endpoint",
+			payload:   `{"context": {"domain": "example", "version": "1.0"`,
+			wantValid: false,
+			wantErr:   "failed to parse JSON payload",
+		},
+		{
+			name:      "Schema validation failure",
+			url:       "http://example.com/endpoint",
+			payload:   `{"context": {"domain": "example", "version": "1.0"}}`,
+			wantValid: false,
+			wantErr:   "Validation failed",
+		},
+		{
+			name:      "Schema not found",
+			url:       "http://example.com/unknown_endpoint",
+			payload:   `{"context": {"domain": "example", "version": "1.0"}}`,
+			wantValid: false,
+			wantErr:   "schema not found for domain",
+		},
+	}
+
+	// Setup a temporary schema directory for testing
+	schemaDir := setupTestSchema(t)
+	defer os.RemoveAll(schemaDir)
+
+	config := &Config{SchemaDir: schemaDir}
+	v, _, err := New(context.Background(), config)
+	if err != nil {
+		t.Fatalf("Failed to create validator: %v", err)
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			u, _ := url.Parse(tt.url)
+			valid, err := v.Validate(context.Background(), u, []byte(tt.payload))
+			if (err != (definition.SchemaValError{}) && !strings.Contains(err.Message, tt.wantErr)) || (err == (definition.SchemaValError{}) && tt.wantErr != "") {
+				t.Errorf("Error: Validate() returned error = %v, expected error = %v", err, tt.wantErr)
+				return
+			}
+			if valid != tt.wantValid {
+				t.Errorf("Validate() returned valid = %v, expected valid = %v", valid, tt.wantValid)
+			}
+		})
+	}
+}
+
+func TestValidator_Initialise(t *testing.T) {
+	tests := []struct {
+		name      string
+		setupFunc func(schemaDir string) error
+		wantErr   string
+	}{
+		{
+			name: "Schema directory does not exist",
+			setupFunc: func(schemaDir string) error {
+				// Do not create the schema directory
+				return nil
+
+			},
+			wantErr: "schema directory does not exist",
+		},
+		{
+			name: "Schema path is not a directory",
+			setupFunc: func(schemaDir string) error {
+				// Create a file instead of a directory
+				return os.WriteFile(schemaDir, []byte{}, 0644)
+			},
+			wantErr: "provided schema path is not a directory",
+		},
+		{
+			name: "Invalid schema file structure",
+			setupFunc: func(schemaDir string) error {
+				// Create an invalid schema file structure
+				invalidSchemaFile := filepath.Join(schemaDir, "invalid_schema.json")
+				if err := os.MkdirAll(filepath.Dir(invalidSchemaFile), 0755); err != nil {
+					t.Fatalf("Failed to create directory: %v", err)
+				}
+				return os.WriteFile(invalidSchemaFile, []byte(`{}`), 0644)
+			},
+			wantErr: "invalid schema file structure",
+		},
+		{
+			name: "Failed to compile JSON schema",
+			setupFunc: func(schemaDir string) error {
+				// Create a schema file with invalid JSON
+				invalidSchemaFile := filepath.Join(schemaDir, "example", "1.0", "endpoint.json")
+				if err := os.MkdirAll(filepath.Dir(invalidSchemaFile), 0755); err != nil {
+					t.Fatalf("Failed to create directory: %v", err)
+				}
+				return os.WriteFile(invalidSchemaFile, []byte(`{invalid json}`), 0644)
+			},
+			wantErr: "failed to compile JSON schema",
+		},
+		{
+			name: "Invalid schema file structure with empty components",
+			setupFunc: func(schemaDir string) error {
+				// Create a schema file with empty domain, version, or schema name
+				invalidSchemaFile := filepath.Join(schemaDir, "", "1.0", "endpoint.json")
+				if err := os.MkdirAll(filepath.Dir(invalidSchemaFile), 0755); err != nil {
+					t.Fatalf("Failed to create directory: %v", err)
+				}
+				return os.WriteFile(invalidSchemaFile, []byte(`{
+					"type": "object",
+					"properties": {
+						"context": {
+							"type": "object",
+							"properties": {
+								"domain": {"type": "string"},
+								"version": {"type": "string"}
+							},
+							"required": ["domain", "version"]
+						}
+					},
+					"required": ["context"]
+				}`), 0644)
+			},
+			wantErr: "failed to read schema directory: invalid schema file structure, expected domain/version/schema.json but got: 1.0/endpoint.json",
+		},
+		{
+			name: "Failed to read directory",
+			setupFunc: func(schemaDir string) error {
+				// Create a directory and remove read permissions
+				if err := os.MkdirAll(schemaDir, 0000); err != nil {
+					t.Fatalf("Failed to create directory: %v", err)
+				}
+				return nil
+			},
+			wantErr: "failed to read directory",
+		},
+		{
+			name: "Valid schema directory",
+			setupFunc: func(schemaDir string) error {
+				// Create a valid schema file
+				validSchemaFile := filepath.Join(schemaDir, "example", "1.0", "endpoint.json")
+				if err := os.MkdirAll(filepath.Dir(validSchemaFile), 0755); err != nil {
+					t.Fatalf("Failed to create directory: %v", err)
+				}
+				return os.WriteFile(validSchemaFile, []byte(`{
+					"type": "object",
+					"properties": {
+						"context": {
+							"type": "object",
+							"properties": {
+								"domain": {"type": "string"},
+								"version": {"type": "string"}
+							},
+							"required": ["domain", "version"]
+						}
+					},
+					"required": ["context"]
+				}`), 0644)
+			},
+			wantErr: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup a temporary schema directory for testing
+			schemaDir := filepath.Join(os.TempDir(), "schemas")
+			defer os.RemoveAll(schemaDir)
+
+			// Run the setup function to prepare the test case
+			if err := tt.setupFunc(schemaDir); err != nil {
+				t.Fatalf("setupFunc() error = %v", err)
+			}
+
+			config := &Config{SchemaDir: schemaDir}
+			v := &Validator{config: config}
+
+			err := v.Initialise()
+			if (err != nil && !strings.Contains(err.Error(), tt.wantErr)) || (err == nil && tt.wantErr != "") {
+				t.Errorf("Error: Initialise() returned error = %v, expected error = %v", err, tt.wantErr)
+			} else if err == nil {
+				t.Logf("Test %s passed: validator initialized successfully", tt.name)
+			} else {
+				t.Logf("Test %s passed with expected error: %v", tt.name, err)
+			}
+		})
+	}
+}
+
+func TestValidator_New_Success(t *testing.T) {
+	schemaDir := setupTestSchema(t)
+	defer os.RemoveAll(schemaDir)
+
+	config := &Config{SchemaDir: schemaDir}
+	_, _, err := New(context.Background(), config)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func TestValidator_New_Failure(t *testing.T) {
+	tests := []struct {
+		name      string
+		config    *Config
+		setupFunc func(schemaDir string) error
+		wantErr   string
+	}{
+		{
+			name:   "Config is nil",
+			config: nil,
+			setupFunc: func(schemaDir string) error {
+				return nil
+			},
+			wantErr: "config cannot be nil",
+		},
+		{
+			name:   "Config is empty",
+			config: &Config{},
+			setupFunc: func(schemaDir string) error {
+				return nil
+			},
+			wantErr: "config must contain 'schema_dir'",
+		},
+		{
+			name:   "schema_dir is empty",
+			config: &Config{SchemaDir: ""},
+			setupFunc: func(schemaDir string) error {
+				return nil
+			},
+			wantErr: "config must contain 'schema_dir'",
+		},
+		{
+			name: "Failed to initialise validators",
+			config: &Config{
+				SchemaDir: "/invalid/path",
+			},
+			setupFunc: func(schemaDir string) error {
+				// Do not create the schema directory
+				return nil
+			},
+			wantErr: "failed to initialise validator",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Run the setup function if provided
+			if tt.setupFunc != nil {
+				schemaDir := ""
+				if tt.config != nil {
+					schemaDir = tt.config.SchemaDir
+				}
+				if err := tt.setupFunc(schemaDir); err != nil {
+					t.Fatalf("Setup function failed: %v", err)
+				}
+			}
+
+			// Call the New function with the test config
+			_, _, err := New(context.Background(), tt.config)
+			if (err != nil && !strings.Contains(err.Error(), tt.wantErr)) || (err == nil && tt.wantErr != "") {
+				t.Errorf("Error: New() returned error = %v, expected error = %v", err, tt.wantErr)
+			} else {
+				t.Logf("Test %s passed with expected error: %v", tt.name, err)
+			}
+		})
+	}
+}

pkg/plugin/manager.go

@@ -0,0 +1,146 @@
+package plugin
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"plugin"
+	"strings"
+
+	"github.com/beckn/beckn-onix/pkg/plugin/definition"
+
+	"gopkg.in/yaml.v2"
+)
+
+// Config represents the plugin manager configuration.
+type Config struct {
+	Root      string       `yaml:"root"`
+	Validator PluginConfig `yaml:"schema_validator"`
+}
+
+// PluginConfig represents configuration details for a plugin.
+type PluginConfig struct {
+	ID     string            `yaml:"id"`
+	Config map[string]string `yaml:"config"`
+}
+
+// // ValidationPluginConfig represents configuration details for a plugin.
+// type ValidationPluginConfig struct {
+// 	ID         string        `yaml:"id"`
+// 	Schema     SchemaDetails `yaml:"config"`
+// 	PluginPath string        `yaml:"plugin_path"`
+// }
+
+// SchemaDetails contains information about the plugin schema directory.
+type SchemaDetails struct {
+	SchemaDir string `yaml:"schema_dir"`
+}
+
+// // Config represents the configuration for the application, including plugin configurations.
+// type Config struct {
+// 	Plugins struct {
+// 		ValidationPlugin ValidationPluginConfig `yaml:"validation_plugin"`
+// 	} `yaml:"plugins"`
+// }
+
+// Manager handles dynamic plugin loading and management.
+type Manager struct {
+	vp definition.SchemaValidatorProvider
+	// validators definition.Validator
+	cfg *Config
+}
+
+// NewManager initializes a new Manager with the given configuration file.
+func NewManager(ctx context.Context, cfg *Config) (*Manager, error) {
+	if cfg == nil {
+		return nil, fmt.Errorf("configuration cannot be nil")
+	}
+
+	// Load validator plugin
+	vp, err := provider[definition.SchemaValidatorProvider](cfg.Root, cfg.Validator.ID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load validator plugin: %w", err)
+	}
+	if vp == nil {
+		return nil, fmt.Errorf("validator provider is nil")
+	}
+
+	// // Initialize validator
+	// validatorMap, defErr := vp.New(ctx, map[string]string{
+	// 	"schema_dir": cfg.Plugins.ValidationPlugin.Schema.SchemaDir,
+	// })
+	// if defErr != nil {
+	// 	return nil, fmt.Errorf("failed to initialize validator: %v", defErr)
+	// }
+
+	// // Initialize the validators map
+	// validators := make(map[string]definition.Validator)
+	// for key, validator := range validatorMap {
+	// 	validators[key] = validator
+	// }
+
+	return &Manager{vp: vp, cfg: cfg}, nil
+}
+
+// provider loads a plugin dynamically and retrieves its provider instance.
+func provider[T any](path string, id string) (T, error) {
+	var zero T
+	if len(strings.TrimSpace(id)) == 0 {
+		return zero, nil
+	}
+
+	p, err := plugin.Open(pluginPath(path, id))
+	if err != nil {
+		return zero, fmt.Errorf("failed to open plugin %s: %w", id, err)
+	}
+
+	symbol, err := p.Lookup("Provider")
+	if err != nil {
+		return zero, fmt.Errorf("failed to find Provider symbol in plugin %s: %w", id, err)
+	}
+
+	// Ensure the symbol is of the correct type
+	prov, ok := symbol.(*T)
+	if !ok {
+		return zero, fmt.Errorf("failed to cast Provider for %s", id)
+	}
+
+	return *prov, nil
+}
+
+// pluginPath constructs the path to the plugin pkg object file.
+func pluginPath(path, id string) string {
+	return filepath.Join(path, id+".so")
+}
+
+// Validators retrieves the validation plugin instances.
+func (m *Manager) Validator(ctx context.Context) (definition.SchemaValidator, func() error, error) {
+	if m.vp == nil {
+		return nil, nil, fmt.Errorf("validator plugin provider not loaded")
+
+	}
+	validator, close, err := m.vp.New(ctx, m.cfg.Validator.Config)
+	if err != nil {
+
+		return nil, nil, fmt.Errorf("failed to initialize validator: %v", err)
+	}
+	return validator, close, nil
+}
+
+// LoadConfig loads the configuration from a YAML file.
+func LoadConfig(path string) (*Config, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open config file: %w", err)
+	}
+	defer file.Close()
+
+	var cfg Config
+	decoder := yaml.NewDecoder(file)
+	if err := decoder.Decode(&cfg); err != nil {
+		return nil, fmt.Errorf("failed to decode config file: %w", err)
+	}
+
+	return &cfg, nil
+}

pkg/plugin/plugin.yaml

@@ -0,0 +1,6 @@
+root: pkg/plugin/implementation/
+schema_validator:
+  id: validator
+  config:
+    schema_dir: schemas #Directory where the schema files are stored
+  plugin_path: pkg/plugin/implementations/

pkg/plugin/testData/payloads/cancel.json

@@ -0,0 +1,31 @@
+{
+    "context": {
+        "action": "cancel",
+        "bap_id": "example-bap.com",
+        "bap_uri": "https://example-bap.com/prod/trv10",
+        "bpp_id": "api.beckn.juspay.in/dobpp/beckn/7f7896dd-787e-4a0b-8675-e9e6fe93bb8f",
+        "bpp_uri": "https://example-bpp.com/prod/seller",
+        "domain": "ONDC:TRV10",
+        "location": {
+            "city": {
+                "code": "std:080"
+            },
+            "country": {
+                "code": "IND"
+            }
+        },
+        "message_id": "be6a495a-e941-4fbf-9d59-f1e6166cccc8",
+        "timestamp": "2023-03-23T05:15:08Z",
+        "transaction_id": "870782be-6757-43f1-945c-8eeaf9536259",
+        "ttl": "PT30S",
+        "version": "2.0.0"
+    },
+    "message": {
+        "cancellation_reason_id": "7",
+        "descriptor": {
+            "code": "SOFT_CANCEL",
+            "name": "Ride Cancellation"
+        },
+        "order_id": "O1"
+    }
+}

pkg/plugin/testData/payloads/confirm.json

@@ -0,0 +1,153 @@
+{
+    "context": {
+        "action": "confirm",
+        "bap_id": "example-bap.com",
+        "bap_uri": "https://example-bap.com/prod/trv10",
+        "bpp_id": "example-bpp.com",
+        "bpp_uri": "https://example-bpp.com/prod/seller",
+        "domain": "ONDC:TRV10",
+        "location": {
+            "city": {
+                "code": "std:080"
+            },
+            "country": {
+                "code": "IND"
+            }
+        },
+        "message_id": "6743e9e2-4fb5-487c-92b7-13ba8018f176",
+        "timestamp": "2023-12-10T04:34:48.031Z",
+        "transaction_id": "870782be-6757-43f1-945c-8eeaf9536259",
+        "ttl": "PT30S",
+        "version": "2.0.0"
+    },
+    "message": {
+        "order": {
+            "billing": {
+                "name": "Joe Adams"
+            },
+            "fulfillments": [
+                {
+                    "customer": {
+                        "contact": {
+                            "phone": "9876556789"
+                        },
+                        "person": {
+                            "name": "Joe Adams"
+                        }
+                    },
+                    "id": "F1",
+                    "stops": [
+                        {
+                            "location": {
+                                "gps": "13.008935, 77.644408"
+                            },
+                            "type": "START"
+                        },
+                        {
+                            "location": {
+                                "gps": "12.971186, 77.586812"
+                            },
+                            "type": "END"
+                        }
+                    ],
+                    "vehicle": {
+                        "category": "AUTO_RICKSHAW"
+                    }
+                }
+            ],
+            "items": [
+                {
+                    "id": "I1"
+                }
+            ],
+            "payments": [
+                {
+                    "collected_by": "BPP",
+                    "id": "PA1",
+                    "params": {
+                        "bank_account_number": "xxxxxxxxxxxxxx",
+                        "bank_code": "XXXXXXXX",
+                        "virtual_payment_address": "9988199772@okicic"
+                    },
+                    "status": "NOT-PAID",
+                    "tags": [
+                        {
+                            "descriptor": {
+                                "code": "BUYER_FINDER_FEES"
+                            },
+                            "display": false,
+                            "list": [
+                                {
+                                    "descriptor": {
+                                        "code": "BUYER_FINDER_FEES_PERCENTAGE"
+                                    },
+                                    "value": "1"
+                                }
+                            ]
+                        },
+                        {
+                            "descriptor": {
+                                "code": "SETTLEMENT_TERMS"
+                            },
+                            "display": false,
+                            "list": [
+                                {
+                                    "descriptor": {
+                                        "code": "SETTLEMENT_WINDOW"
+                                    },
+                                    "value": "PT60M"
+                                },
+                                {
+                                    "descriptor": {
+                                        "code": "SETTLEMENT_BASIS"
+                                    },
+                                    "value": "DELIVERY"
+                                },
+                                {
+                                    "descriptor": {
+                                        "code": "SETTLEMENT_TYPE"
+                                    },
+                                    "value": "UPI"
+                                },
+                                {
+                                    "descriptor": {
+                                        "code": "MANDATORY_ARBITRATION"
+                                    },
+                                    "value": "true"
+                                },
+                                {
+                                    "descriptor": {
+                                        "code": "COURT_JURISDICTION"
+                                    },
+                                    "value": "New Delhi"
+                                },
+                                {
+                                    "descriptor": {
+                                        "code": "DELAY_INTEREST"
+                                    },
+                                    "value": "5"
+                                },
+                                {
+                                    "descriptor": {
+                                        "code": "STATIC_TERMS"
+                                    },
+                                    "value": "https://example-test-bap.com/static-terms.txt"
+                                },
+                                {
+                                    "descriptor": {
+                                        "code": "SETTLEMENT_AMOUNT"
+                                    },
+                                    "value": "1.46"
+                                }
+                            ]
+                        }
+                    ],
+                    "type": "ON-FULFILLMENT"
+                }
+            ],
+            "provider": {
+                "id": "P1"
+            }
+        }
+    }
+}

pkg/plugin/testData/payloads/search.json

@@ -0,0 +1,80 @@
+{
+  "context": {
+    "action": "search",
+    "bap_id": "example-bap.com",
+    "bap_uri": "https://example-bap.com/prod/trv10",
+    "domain": "ONDC:TRV10",
+    "location": {
+      "city": {
+        "code": "std:080"
+      },
+      "country": {
+        "code": "IND"
+      }
+    },
+    "message_id": "40963dc1-e402-4f4d-ae70-7c5864ca682c",
+    "timestamp": "2023-12-09T13:39:56.645Z",
+    "transaction_id": "870782be-6757-43f1-945c-8eeaf9536259",
+    "ttl": "PT30S",
+    "version": "2.0.0"
+  },
+  "message": {
+    "intent": {
+      "fulfillment": {
+        "stops": [
+          {
+            "location": {
+              "gps": "13.008935, 77.644408"
+            },
+            "type": "START"
+          },
+          {
+            "location": {
+              "gps": "12.971186, 77.586812"
+            },
+            "type": "END"
+          }
+        ]
+      },
+      "payment": {
+        "collected_by": "BPP",
+        "tags": [
+          {
+            "descriptor": {
+              "code": "BUYER_FINDER_FEES"
+            },
+            "display": false,
+            "list": [
+              {
+                "descriptor": {
+                  "code": "BUYER_FINDER_FEES_PERCENTAGE"
+                },
+                "value": "1"
+              }
+            ]
+          },
+          {
+            "descriptor": {
+              "code": "SETTLEMENT_TERMS"
+            },
+            "display": false,
+            "list": [
+              {
+                "descriptor": {
+                  "code": "DELAY_INTEREST"
+                },
+                "value": "5"
+              },
+              {
+                "descriptor": {
+                  "code": "STATIC_TERMS"
+                },
+                "value": "https://example-test-bap.com/static-terms.txt"
+              }
+            ]
+          }
+        ]
+      }
+    }
+  }
+}

pkg/plugin/testData/payloads/search_extraField.json

@@ -0,0 +1,63 @@
+{
+    "context": {
+      "action": "search",
+      "bap_id": "bap.example.com",
+      "bap_uri": "https://example-bap.com/prod/trv10",
+      "domain": "example-domain",
+      "location": {
+        "city": {
+          "code": "PUN"
+        },
+        "country": {
+          "code": "IND"
+        }
+      },
+      "message_id": "123e4567-e89b-12d3-a456-426614174000",
+      "timestamp": "2025-03-06T12:00:00Z",
+      "transaction_id": "123e4567-e89b-12d3-a456-426614174001",
+      "ttl": "PT30M",
+      "version": "1.0.0",
+      "extra_field": "unexpected_value"
+    },
+    "message": {
+      "intent": {
+        "fulfillment": {
+          "stops": [
+            {
+              "location": {
+                "gps": "19.0760,72.8777",
+                "created_at": "unexpected_value"
+              },
+              "type": "START"
+            },
+            {
+              "location": {
+                "gps": "18.5204,73.8567"
+              },
+              "type": "END"
+            }
+          ]
+        },
+        "payment": {
+          "collected_by": "BPP",
+          "tags": [
+            {
+              "descriptor": {
+                "code": "some-code"
+              },
+              "display": true,
+              "list": [
+                {
+                  "descriptor": {
+                    "code": "list-code"
+                  },
+                  "value": "list-value"
+                }
+              ]
+            }
+          ]
+        }
+      }
+    }
+  }
+  

pkg/plugin/testData/payloads/search_missingField.json

@@ -0,0 +1,65 @@
+{
+    "context": {
+      "action": "search",
+      "bap_id": "example-bap.com",
+      "bap_uri": "https://example-bap.com/prod/trv10",
+      "domain": "ONDC:TRV10",
+      "location": {
+        "city": {
+          "code": "std:080"
+        },
+        "country": {
+          "code": "IND"
+        }
+      },
+      "message_id": "40963dc1-e402-4f4d-ae70-7c5864ca682c",
+      "timestamp": "2023-12-09T13:39:56.645Z",
+      "transaction_id": "870782be-6757-43f1-945c-8eeaf9536259",
+      "ttl": "PT30S",
+      "version": "2.0.0"
+    },
+    "message": {
+      "intent": {
+        "payment": {
+          "collected_by": "BPP",
+          "tags": [
+            {
+              "descriptor": {
+                "code": "BUYER_FINDER_FEES"
+              },
+              "display": false,
+              "list": [
+                {
+                  "descriptor": {
+                    "code": "BUYER_FINDER_FEES_PERCENTAGE"
+                  },
+                  "value": "1"
+                }
+              ]
+            },
+            {
+              "descriptor": {
+                "code": "SETTLEMENT_TERMS"
+              },
+              "display": false,
+              "list": [
+                {
+                  "descriptor": {
+                    "code": "DELAY_INTEREST"
+                  },
+                  "value": "5"
+                },
+                {
+                  "descriptor": {
+                    "code": "STATIC_TERMS"
+                  },
+                  "value": "https://example-test-bap.com/static-terms.txt"
+                }
+              ]
+            }
+          ]
+        }
+      }
+    }
+  }
+  

pkg/plugin/testData/payloads/select.json

@@ -0,0 +1,352 @@
+{
+    "context": {
+      "action": "select",
+      "bap_id": "example-bap.com",
+      "bap_uri": "https://example-bap.com/prod/trv10",
+      "bpp_id": "example-bpp.com",
+      "bpp_uri": "https://example-bpp.com/prod/seller",
+      "domain": "ONDC:TRV10",
+      "location": {
+        "city": {
+          "code": "std:080"
+        },
+        "country": {
+          "code": "IND"
+        }
+      },
+      "message_id": "8926b747-0362-4fcc-b795-0994a6287700",
+      "timestamp": "2023-12-09T14:11:32.859Z",
+      "transaction_id": "870782be-6757-43f1-945c-8eeaf9536259",
+      "ttl": "PT30S",
+      "version": "2.0.0"
+    },
+    "message": {
+      "order": {
+        "cancellation_terms": [
+          {
+            "cancellation_fee": {
+              "percentage": "0"
+            },
+            "fulfillment_state": {
+              "descriptor": {
+                "code": "RIDE_ASSIGNED"
+              }
+            },
+            "reason_required": true
+          },
+          {
+            "cancellation_fee": {
+              "amount": {
+                "currency": "INR",
+                "value": "30"
+              }
+            },
+            "fulfillment_state": {
+              "descriptor": {
+                "code": "RIDE_ENROUTE_PICKUP"
+              }
+            },
+            "reason_required": true
+          },
+          {
+            "cancellation_fee": {
+              "amount": {
+                "currency": "INR",
+                "value": "50"
+              }
+            },
+            "fulfillment_state": {
+              "descriptor": {
+                "code": "RIDE_ARRIVED_PICKUP"
+              }
+            },
+            "reason_required": true
+          },
+          {
+            "cancellation_fee": {
+              "percentage": "100"
+            },
+            "fulfillment_state": {
+              "descriptor": {
+                "code": "RIDE_STARTED"
+              }
+            },
+            "reason_required": true
+          }
+        ],
+        "fulfillments": [
+          {
+            "id": "F1",
+            "customer": {
+              "contact": {
+                "phone": "9876556789"
+              },
+              "person": {
+                "name": "Joe Adams"
+              }
+            },
+            "stops": [
+              {
+                "location": {
+                  "gps": "13.008935, 77.644408"
+                },
+                "type": "START"
+              },
+              {
+                "location": {
+                  "gps": "12.971186, 77.586812"
+                },
+                "type": "END"
+              }
+            ],
+            "tags": [
+              {
+                "descriptor": {
+                  "code": "ROUTE_INFO",
+                  "name": "Route Information"
+                },
+                "display": true,
+                "list": [
+                  {
+                    "descriptor": {
+                      "code": "ENCODED_POLYLINE",
+                      "name": "Path"
+                    },
+                    "value": "_p~iF~ps|U_ulLnnqC_mqNvxq`@"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "WAYPOINTS",
+                      "name": "Waypoints"
+                    },
+                    "value": "[{\"gps\":\"12.909982, 77.611822\"},{\"gps\":\"12.909982,77.611822\"},{\"gps\":\"12.909982,77.611822\"},{\"gps\":\"12.909982, 77.611822\"}]"
+                  }
+                ]
+              }
+            ],
+            "type": "DELIVERY",
+            "vehicle": {
+              "category": "AUTO_RICKSHAW"
+            }
+          }
+        ],
+        "items": [
+          {
+            "descriptor": {
+              "code": "RIDE",
+              "name": "Auto Ride"
+            },
+            "fulfillment_ids": [
+              "F1"
+            ],
+            "id": "I1",
+            "location_ids": [
+              "L1",
+              "L3"
+            ],
+            "payment_ids": [
+              "PA1"
+            ],
+            "price": {
+              "currency": "INR",
+              "maximum_value": "176",
+              "minimum_value": "136",
+              "value": "146"
+            },
+            "tags": [
+              {
+                "descriptor": {
+                  "code": "FARE_POLICY",
+                  "name": "Daytime Charges"
+                },
+                "display": true,
+                "list": [
+                  {
+                    "descriptor": {
+                      "code": "MIN_FARE"
+                    },
+                    "value": "30"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "MIN_FARE_DISTANCE_KM"
+                    },
+                    "value": "2"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "PER_KM_CHARGE"
+                    },
+                    "value": "15"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "PICKUP_CHARGE"
+                    },
+                    "value": "10"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "WAITING_CHARGE_PER_MIN"
+                    },
+                    "value": "2"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "NIGHT_CHARGE_MULTIPLIER"
+                    },
+                    "value": "1.5"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "NIGHT_SHIFT_START_TIME"
+                    },
+                    "value": "22:00:00"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "NIGHT_SHIFT_END_TIME"
+                    },
+                    "value": "05:00:00"
+                  }
+                ]
+              },
+              {
+                "descriptor": {
+                  "code": "INFO",
+                  "name": "General Information"
+                },
+                "display": true,
+                "list": [
+                  {
+                    "descriptor": {
+                      "code": "DISTANCE_TO_NEAREST_DRIVER_METER"
+                    },
+                    "value": "661"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "ETA_TO_NEAREST_DRIVER_MIN"
+                    },
+                    "value": "3"
+                  }
+                ]
+              }
+            ]
+          }
+        ],
+        "payments": [
+          {
+            "collected_by": "BPP",
+            "id": "PA1",
+            "params": {
+              "bank_account_number": "xxxxxxxxxxxxxx",
+              "bank_code": "XXXXXXXX",
+              "virtual_payment_address": "9988199772@okicic"
+            },
+            "status": "NOT-PAID",
+            "tags": [
+              {
+                "descriptor": {
+                  "code": "BUYER_FINDER_FEES"
+                },
+                "display": false,
+                "list": [
+                  {
+                    "descriptor": {
+                      "code": "BUYER_FINDER_FEES_PERCENTAGE"
+                    },
+                    "value": "1"
+                  }
+                ]
+              },
+              {
+                "descriptor": {
+                  "code": "SETTLEMENT_TERMS"
+                },
+                "display": false,
+                "list": [
+                  {
+                    "descriptor": {
+                      "code": "DELAY_INTEREST"
+                    },
+                    "value": "5"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "SETTLEMENT_TYPE"
+                    },
+                    "value": "UPI"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "SETTLEMENT_WINDOW"
+                    },
+                    "value": "PT2D"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "SETTLEMENT_BASIS"
+                    },
+                    "value": "DELIVERY"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "MANDATORY_ARBITRATION"
+                    },
+                    "value": "true"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "COURT_JURISDICTION"
+                    },
+                    "value": "New Delhi"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "STATIC_TERMS"
+                    },
+                    "value": "https://example-test-bpp.com/static-terms.txt"
+                  },
+                  {
+                    "descriptor": {
+                      "code": "SETTLEMENT_AMOUNT"
+                    },
+                    "value": "1.46"
+                  }
+                ]
+              }
+            ],
+            "type": "ON-FULFILLMENT"
+          }
+        ],
+        "provider": {
+          "id": "P1"
+        },
+        "quote": {
+          "breakup": [
+            {
+              "price": {
+                "currency": "INR",
+                "value": "30"
+              },
+              "title": "BASE_FARE"
+            },
+            {
+              "price": {
+                "currency": "INR",
+                "value": "116"
+              },
+              "title": "DISTANCE_FARE"
+            }
+          ],
+          "price": {
+            "currency": "INR",
+            "value": "146"
+          },
+          "ttl": "PT30S"
+        }
+      }
+    }
+  }
+  

pkg/plugin/testData/schema_valid/ondc_trv10/v2.0.0/search.json

@@ -0,0 +1,129 @@
+{
+  "$id": "http://example.com/schema/searchSchema",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "context": {
+      "type": "object",
+      "properties": {
+        "action": { "type": "string" },
+        "bap_id": { "type": "string" },
+        "bap_uri": { "type": "string", "format": "uri" },
+        "domain": { "type": "string" },
+        "location": {
+          "type": "object",
+          "properties": {
+            "city": {
+              "type": "object",
+              "properties": {
+                "code": { "type": "string" }
+              },
+              "required": ["code"]
+            },
+            "country": {
+              "type": "object",
+              "properties": {
+                "code": { "type": "string" }
+              },
+              "required": ["code"]
+            }
+          },
+          "required": ["city", "country"]
+        },
+        "message_id": { "type": "string", "format": "uuid" },
+        "timestamp": { "type": "string", "format": "date-time" },
+        "transaction_id": { "type": "string", "format": "uuid" },
+        "ttl": { "type": "string" },
+        "version": { "type": "string" }
+      },
+      "required": [
+        "action",
+        "bap_id",
+        "bap_uri",
+        "domain",
+        "location",
+        "message_id",
+        "timestamp",
+        "transaction_id",
+        "ttl",
+        "version"
+      ]
+    },
+    "message": {
+      "type": "object",
+      "properties": {
+        "intent": {
+          "type": "object",
+          "properties": {
+            "fulfillment": {
+              "type": "object",
+              "properties": {
+                "stops": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "location": {
+                        "type": "object",
+                        "properties": {
+                          "gps": { "type": "string", "pattern": "^\\d{1,3}\\.\\d+,\\s?\\d{1,3}\\.\\d+$" }
+                        },
+                        "required": ["gps"]
+                      },
+                      "type": { "type": "string", "enum": ["START", "END"] }
+                    },
+                    "required": ["location", "type"]
+                  }
+                }
+              },
+              "required": ["stops"]
+            },
+            "payment": {
+              "type": "object",
+              "properties": {
+                "collected_by": { "type": "string", "enum": ["BPP", "BAP"] },
+                "tags": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "properties": {
+                      "descriptor": {
+                        "type": "object",
+                        "properties": {
+                          "code": { "type": "string" }
+                        },
+                        "required": ["code"]
+                      },
+                      "display": { "type": "boolean" },
+                      "list": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "properties": {
+                            "descriptor": {
+                              "type": "object",
+                              "properties": {
+                                "code": { "type": "string" }
+                              },
+                              "required": ["code"]
+                            },
+                            "value": { "type": "string" }
+                          },
+                          "required": ["descriptor", "value"]
+                        }
+                      }
+                    },
+                    "required": ["descriptor", "display", "list"]
+                  }
+                }
+              },
+              "required": ["collected_by", "tags"]
+            }
+          },
+          "required": ["fulfillment", "payment"]
+        }
+      }
+    }
+  },
+  "required": ["context", "message"]
+}