-
-
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
-}
-
-
-