+
+
package main
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "beckn-onix/plugins/definitions"
+
+ "github.com/santhosh-tekuri/jsonschema/v6"
+)
+
+// TekuriValidator implements the Validator interface using the santhosh-tekuri/jsonschema package.
+type TekuriValidator struct {
+ schema *jsonschema.Schema
+}
+
+// TekuriValidatorProvider is responsible for managing and providing access to the JSON schema validators.
+type TekuriValidatorProvider struct {
+ SchemaCache map[string]*jsonschema.Schema
+}
+
+// Validate validates the given data against the schema.
+func (v *TekuriValidator) Validate(ctx context.Context, data []byte) error {
+ var jsonData interface{}
+ if err := json.Unmarshal(data, &jsonData); err != nil {
+ return err
+ }
+ err := v.schema.Validate(jsonData)
+ if err != nil {
+ // TODO: Integrate with the logging module once it is ready
+ fmt.Printf("Validation error: %v\n", err)
+ }
+
+ return err
+}
+
+// Initialize initializes the validator provider by compiling all the JSON schema files
+// from the specified directory and storing them in a cache. It returns a map of validators
+// indexed by their schema filenames.
+func (vp *TekuriValidatorProvider) Initialize(schemaDir string) (map[string]definitions.Validator, error) {
+ // Initialize SchemaCache if it's nil
+ if vp.SchemaCache == nil {
+ vp.SchemaCache = make(map[string]*jsonschema.Schema)
+ }
+ // Check if the directory exists and is accessible
+ info, err := os.Stat(schemaDir)
+ if err != nil {
+ if os.IsNotExist(err) {
+ return nil, fmt.Errorf("schema directory does not exist: %s", schemaDir)
+ }
+ return nil, fmt.Errorf("failed to access schema directory: %v", err)
+ }
+ if !info.IsDir() {
+ return nil, fmt.Errorf("provided schema path is not a directory: %s", schemaDir)
+ }
+
+ // Initialize the validatorCache map to store the Validator instances associated with each schema.
+ validatorCache := make(map[string]definitions.Validator)
+ 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)
+ }
+ if compiledSchema == nil {
+ return fmt.Errorf("compiled schema is nil for file %s", entry.Name())
+ }
+
+ // 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)
+ }
+ // Ensure relativePath is not empty
+ if relativePath == "" {
+ return fmt.Errorf("relative path is empty for file: %s", path)
+ }
+ // 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])
+
+ 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.json).
+ uniqueKey := fmt.Sprintf("%s/%s/%s", domain, version, schemaFileName)
+ // Store the compiled schema in the SchemaCache using the unique key.
+ vp.SchemaCache[uniqueKey] = compiledSchema
+ // Store the corresponding validator in the validatorCache using the same unique key.
+ validatorCache[uniqueKey] = &TekuriValidator{schema: compiledSchema}
+ }
+ }
+ return nil
+ }
+
+ // Start processing from the root schema directory
+ if err := processDir(schemaDir); err != nil {
+ return nil, fmt.Errorf("failed to read schema directory: %v", err)
+ }
+
+ return validatorCache, nil
+}
+
+var _ definitions.ValidatorProvider = (*TekuriValidatorProvider)(nil)
+
+var providerInstance = &TekuriValidatorProvider{}
+
+// GetProvider returns the ValidatorProvider instance.
+func GetProvider() definitions.ValidatorProvider {
+ return providerInstance
+}
+
+
+