eric/onix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update nested map to flat map

Browse Source
This commit is contained in:
AshwiniK-protean
2025-03-04 16:33:49 +05:30
parent 4559ac3e5f
commit 02ebd9fd38
10 changed files with 625 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
plugins/implementations/plugin_impl.go
View File

@@ -6,48 +6,56 @@ import (
"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 {
// TekuriValidator implements the Validator interface using the santhosh-tekuri/jsonschema package.
type TekuriValidator struct {
schema *jsonschema.Schema
}
type tekuriValidatorProvider struct {
schemaCache map[string]map[string]*jsonschema.Schema
//schemaCache map[string]*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 {
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
}
// (Approach 2)(all json files for each schema from sub directories)
func (vp *tekuriValidatorProvider) Initialize(schemaDir string) (map[string]plugins.Validator, error) {
vp.schemaCache = make(map[string]map[string]*jsonschema.Schema)
// 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" {
filePath := filepath.Join(schemaDir, info.Name())
compiler := jsonschema.NewCompiler()
compiledSchema, err := compiler.Compile(path)
if err != nil {
return fmt.Errorf("failed to compile JSON schema from file %s: %v", info.Name(), err)
@@ -56,12 +64,31 @@ func (vp *tekuriValidatorProvider) Initialize(schemaDir string) (map[string]plug
return fmt.Errorf("compiled schema is nil for file %s", info.Name())
}
dir := filepath.Base(filepath.Dir(filePath))
if vp.schemaCache[dir] == nil {
vp.schemaCache[dir] = make(map[string]*jsonschema.Schema)
// 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)
}
vp.schemaCache[dir][info.Name()] = compiledSchema
validatorCache[info.Name()] = &tekuriValidator{schema: compiledSchema}
// 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
})
@@ -72,110 +99,11 @@ func (vp *tekuriValidatorProvider) Initialize(schemaDir string) (map[string]plug
return validatorCache, nil
}
var _ plugins.ValidatorProvider = (*tekuriValidatorProvider)(nil)
var _ plugins.ValidatorProvider = (*TekuriValidatorProvider)(nil)
var providerInstance = &tekuriValidatorProvider{}
var providerInstance = &TekuriValidatorProvider{}
// GetProvider returns the ValidatorProvider instance.
func GetProvider() plugins.ValidatorProvider {
return providerInstance
}
///////////////////////
//(Approach 2)(all json files for each schema)
// Initialize reads all .json files from the given schema directory, validates them using JSON Schema, and prints the result.
// func (vp *tekuriValidatorProvider) Initialize(schemaDir string) (map[string]plugins.Validator, error) {
// //start := time.Now()
// // Initialize the cache
// vp.schemaCache = make(map[string]map[string]*jsonschema.Schema)
// validatorCache := make(map[string]plugins.Validator)
// // Read the directory
// files, err := ioutil.ReadDir(schemaDir)
// if err != nil {
// return nil, fmt.Errorf("failed to read schema directory: %v", err)
// }
// for _, file := range files {
// if filepath.Ext(file.Name()) == ".json" {
// // Read the JSON file
// filePath := filepath.Join(schemaDir, file.Name())
// fmt.Println("file path : ", filePath)
// compiler := jsonschema.NewCompiler()
// compiledSchema, err := compiler.Compile(filePath)
// if err != nil {
// return nil, fmt.Errorf("failed to compile JSON schema from file %s: %v", file.Name(), err)
// }
// if compiledSchema == nil {
// return nil, fmt.Errorf("compiled schema is nil for file %s", file.Name())
// }
// // Extract directory and filename to use in the nested map
// dir := filepath.Base(filepath.Dir(filePath))
// if vp.schemaCache[dir] == nil {
// vp.schemaCache[dir] = make(map[string]*jsonschema.Schema)
// }
// // Store the compiled schema in the nested cache
// vp.schemaCache[dir][file.Name()] = compiledSchema
// validatorCache[file.Name()] = &tekuriValidator{schema: compiledSchema}
// }
// }
// // fmt.Printf("initialize executed in %s\n", time.Since(start))
// return validatorCache, nil
//////////////////////////////////////////////////////////
// (Approach 1)
// func (vp *tekuriValidatorProvider) Initialize(schemaDir string) (map[string]plugins.Validator, error) {
// // start := time.Now()
// vp.schemaCache = make(map[string]*jsonschema.Schema)
// validatorCache := make(map[string]plugins.Validator)
// files, err := ioutil.ReadDir(schemaDir)
// if err != nil {
// return nil, fmt.Errorf("failed to read schema directory: %w", err)
// }
// for _, file := range files {
// if filepath.Ext(file.Name()) == ".json" {
// filePath := filepath.Join(schemaDir, file.Name())
// // Read the file content
// content, err := ioutil.ReadFile(filePath)
// if err != nil {
// return nil, fmt.Errorf("failed to read file %s: %v", filePath, err)
// }
// var schemaDoc map[string]interface{}
// if err := json.Unmarshal(content, &schemaDoc); err != nil {
// return nil, fmt.Errorf("failed to unmarshal JSON schema from file %s: %v", filePath, err)
// }
// if defs, exists := schemaDoc["$defs"]; exists {
// defsMap := defs.(map[string]interface{})
// for name, defSchema := range defsMap {
// _, err := json.Marshal(defSchema)
// if err != nil {
// return nil, fmt.Errorf("failed to marshal schema definition %s: %v", name, err)
// }
// compiler := jsonschema.NewCompiler()
// if err := compiler.AddResource(name, filepath.Dir(filePath)); err != nil {
// return nil, fmt.Errorf("failed to add resource for schema definition %s: %v", name, err)
// }
// compiledSchema, err := compiler.Compile(filePath)
// if err != nil {
// return nil, fmt.Errorf("failed to compile schema definition: %v", err)
// }
// schemaKey := fmt.Sprintf("%s.%s", file.Name(), name)
// vp.schemaCache[schemaKey] = compiledSchema
// validatorCache[schemaKey] = &tekuriValidator{schema: compiledSchema}
// }
// }
// }
// }
// // fmt.Printf("Initialize executed in %s\n", time.Since(start))
// return validatorCache, nil
// }

28
plugins/implementations/plugin_impl_test.go
View File

@@ -20,7 +20,7 @@ type Context struct{}
type Message struct{}
func TestInitializeValidDirectory(t *testing.T) {
provider := &tekuriValidatorProvider{}
provider := &TekuriValidatorProvider{}
schemaDir := "../schemas/"
_, err := provider.Initialize(schemaDir)
if err != nil {
@@ -29,7 +29,7 @@ func TestInitializeValidDirectory(t *testing.T) {
}
func TestInitializeInValidDirectory(t *testing.T) {
provider := &tekuriValidatorProvider{}
provider := &TekuriValidatorProvider{}
schemaDir := "../schema/ondc_trv10_2.0.0/"
_, err := provider.Initialize(schemaDir)
if err != nil {
@@ -42,7 +42,7 @@ func TestInvalidCompileFile(t *testing.T) {
if _, err := os.Stat(schemaDir); os.IsNotExist(err) {
t.Fatalf("Schema directory does not exist: %v", schemaDir)
}
provider := &tekuriValidatorProvider{}
provider := &TekuriValidatorProvider{}
compiledSchema, err := provider.Initialize(schemaDir)
if err != nil {
t.Fatalf("failed to compile JSON schema : %v", err)
@@ -58,7 +58,7 @@ func TestInvalidCompileSchema(t *testing.T) {
if _, err := os.Stat(schemaDir); os.IsNotExist(err) {
t.Fatalf("Schema directory does not exist: %v", schemaDir)
}
provider := &tekuriValidatorProvider{}
provider := &TekuriValidatorProvider{}
compiledSchema, _ := provider.Initialize(schemaDir)
fmt.Println(compiledSchema)
if compiledSchema == nil {
@@ -72,15 +72,15 @@ func TestValidateData(t *testing.T) {
if _, err := os.Stat(schemaDir); os.IsNotExist(err) {
t.Fatalf("Schema directory does not exist: %v", schemaDir)
}
provider := &tekuriValidatorProvider{}
provider := &TekuriValidatorProvider{}
validators, err := provider.Initialize(schemaDir)
if err != nil {
t.Fatalf("Failed to initialize schema provider: %v", err)
}
var validator *tekuriValidator
var validator *TekuriValidator
for _, v := range validators {
var ok bool
validator, ok = v.(*tekuriValidator)
validator, ok = v.(*TekuriValidator)
if ok {
break
}
@@ -89,7 +89,7 @@ func TestValidateData(t *testing.T) {
t.Fatalf("No validators found in the map")
}
payloadFilePath := "../test/payload.json"
payloadFilePath := "../testData/payload.json"
payloadData, err := ioutil.ReadFile(payloadFilePath)
if err != nil {
t.Fatalf("Failed to read payload data: %v", err)
@@ -114,15 +114,15 @@ func TestInValidateData(t *testing.T) {
t.Fatalf("Schema directory does not exist: %v", schemaDir)
}
provider := &tekuriValidatorProvider{}
provider := &TekuriValidatorProvider{}
validators, err := provider.Initialize(schemaDir)
if err != nil {
t.Fatalf("Failed to initialize schema provider: %v", err)
}
var validator *tekuriValidator
var validator *TekuriValidator
for _, v := range validators {
var ok bool
validator, ok = v.(*tekuriValidator)
validator, ok = v.(*TekuriValidator)
if ok {
break
}
@@ -144,15 +144,15 @@ func TestInValidateUnmarshalData(t *testing.T) {
t.Fatalf("Schema directory does not exist: %v", schemaDir)
}
provider := &tekuriValidatorProvider{}
provider := &TekuriValidatorProvider{}
validators, err := provider.Initialize(schemaDir)
if err != nil {
t.Fatalf("Failed to initialize schema provider: %v", err)
}
var validator *tekuriValidator
var validator *TekuriValidator
for _, v := range validators {
var ok bool
validator, ok = v.(*tekuriValidator)
validator, ok = v.(*TekuriValidator)
if ok {
break
}

BIN
plugins/implementations/tekuriValidator.so
View File

Binary file not shown.