110 lines
3.8 KiB
Go
110 lines
3.8 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"beckn-onix/plugins"
|
|
|
|
"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]plugins.Validator, error) {
|
|
// Initialize the SchemaCache map to store the compiled schemas using a unique key (domain/version/schema).
|
|
vp.SchemaCache = make(map[string]*jsonschema.Schema)
|
|
// Initialize the validatorCache map to store the Validator instances associated with each schema.
|
|
validatorCache := make(map[string]plugins.Validator)
|
|
compiler := jsonschema.NewCompiler()
|
|
|
|
// Walk through the schema directory and process each file.
|
|
err := filepath.Walk(schemaDir, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Only process files (ignore directories) and ensure the file has a ".json" extension.
|
|
if !info.IsDir() && filepath.Ext(info.Name()) == ".json" {
|
|
compiledSchema, err := compiler.Compile(path)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to compile JSON schema from file %s: %v", info.Name(), err)
|
|
}
|
|
if compiledSchema == nil {
|
|
return fmt.Errorf("compiled schema is nil for file %s", info.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", info.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.
|
|
domain := parts[0]
|
|
version := parts[1]
|
|
schemaFileName := parts[2]
|
|
|
|
// 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
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read schema directory: %v", err)
|
|
}
|
|
|
|
return validatorCache, nil
|
|
}
|
|
|
|
var _ plugins.ValidatorProvider = (*TekuriValidatorProvider)(nil)
|
|
|
|
var providerInstance = &TekuriValidatorProvider{}
|
|
|
|
// GetProvider returns the ValidatorProvider instance.
|
|
func GetProvider() plugins.ValidatorProvider {
|
|
return providerInstance
|
|
}
|