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

add new schemas

Browse Source
This commit is contained in:
AshwiniK-protean
2025-02-27 10:23:49 +05:30
parent 87d546ea8a
commit 113aadbb0a
65 changed files with 7578 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
plugins/implementations/plugin_impl.go
View File

@@ -6,9 +6,8 @@ import (
"fmt"
"io/ioutil"
"path/filepath"
"time"
"beckn-onix/plugins/plugin_definition"
"beckn-onix/plugins"
"github.com/santhosh-tekuri/jsonschema/v6"
)
@@ -19,157 +18,132 @@ type tekuriValidator struct {
}
type tekuriValidatorProvider struct {
//schemaCache map[string]map[string]*jsonschema.Schema
schemaCache map[string]*jsonschema.Schema
schemaCache map[string]map[string]*jsonschema.Schema
//schemaCache map[string]*jsonschema.Schema
}
// Validate validates the given data against the schema.
func (v *tekuriValidator) Validate(ctx context.Context, data []byte) error {
start := time.Now()
// start := time.Now()
var jsonData interface{}
if err := json.Unmarshal(data, &jsonData); err != nil {
return err
}
fmt.Println("json data : ", jsonData)
err := v.schema.Validate(jsonData)
if err != nil {
fmt.Printf("Validation error: %v\n", err)
}
fmt.Printf("validate executed in %s\n", time.Since(start))
// fmt.Printf("validate executed in %s\n", time.Since(start))
return err
}
//(Approach 2)(all json files)
//(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]plugin_definition.Validator, error) {
// start := time.Now()
// // Initialize the cache
// vp.schemaCache = make(map[string]map[string]*jsonschema.Schema)
// validatorCache := make(map[string]plugin_definition.Validator)
// 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)
// // Read the directory
// files, err := ioutil.ReadDir(schemaDir)
// if err != nil {
// return nil, fmt.Errorf("failed to read schema directory: %v", err)
// return nil, fmt.Errorf("failed to read schema directory: %w", err)
// }
// for _, file := range files {
// if filepath.Ext(file.Name()) == ".json" {
// // Read the JSON file
// filePath := filepath.Join(schemaDir, file.Name())
// compiler := jsonschema.NewCompiler()
// compiledSchema, err := compiler.Compile(filePath)
// // Read the file content
// content, err := ioutil.ReadFile(filePath)
// if err != nil {
// return nil, fmt.Errorf("failed to compile JSON schema from file %s: %v", file.Name(), err)
// return nil, fmt.Errorf("failed to read file %s: %v", filePath, 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}
// 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))
// // fmt.Printf("Initialize executed in %s\n", time.Since(start))
// return validatorCache, nil
// }
// func (vp *tekuriValidatorProvider) Get(schemaKey string) (plugin_definition.Validator, error) {
// // Extract domain, version, and defKey from the schemaKey
// fmt.Println("before printing key :", schemaKey)
// schemaKey = strings.Replace(schemaKey, ":", "_", -1)
// fmt.Println("after printing key :", schemaKey)
// parts := strings.Split(schemaKey, "_")
// if len(parts) != 3 {
// return nil, fmt.Errorf("invalid schema key format: %s", schemaKey)
// }
// domain := parts[0] + "_" + parts[1]
// defKey := parts[2]
// // Look up the compiled schema in the nested map
// if domainMap, ok := vp.schemaCache[domain]; ok {
// if schema, ok := domainMap[defKey]; ok {
// return &tekuriValidator{schema: schema}, nil
// }
// }
// return nil, fmt.Errorf("schema not found: %s", schemaKey)
// }
// (Approach 1)
func (vp *tekuriValidatorProvider) Initialize(schemaDir string) (map[string]plugin_definition.Validator, error) {
start := time.Now()
vp.schemaCache = make(map[string]*jsonschema.Schema)
validatorCache := make(map[string]plugin_definition.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())
fmt.Println("Compiling filePath:", filePath)
// 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
}
// Ensure tekuriValidatorProvider implements ValidatorProvider
var _ plugin_definition.ValidatorProvider = (*tekuriValidatorProvider)(nil)
var _ plugins.ValidatorProvider = (*tekuriValidatorProvider)(nil)
var providerInstance = &tekuriValidatorProvider{}
// Exported function to return the provider instance
func GetProvider() plugin_definition.ValidatorProvider {
func GetProvider() plugins.ValidatorProvider {
return providerInstance
}