ondc-code-generator 0.8.7 → 0.8.9

package/alpha/validationpkg/validationutils/json_path_utils.go

@@ -0,0 +1,173 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/AsaiYusuke/jsonpath"
+)
+
+// Global cache for parsed JSONPath functions
+var (
+	pathParserCache = make(map[string]func(interface{}) ([]interface{}, error))
+	parserCacheMu   sync.RWMutex
+	cacheHits       uint64
+	cacheMisses     uint64
+	statsMu         sync.Mutex
+)
+
+// getOrParseJSONPath retrieves a cached parser or parses and caches a new one
+func getOrParseJSONPath(path string) (func(interface{}) ([]interface{}, error), error) {
+	// Try to get from cache first (read lock for fast concurrent reads)
+	parserCacheMu.RLock()
+	parser, exists := pathParserCache[path]
+	parserCacheMu.RUnlock()
+
+	if exists {
+		// Cache hit - use existing parser
+		statsMu.Lock()
+		cacheHits++
+		statsMu.Unlock()
+		return parser, nil
+	}
+
+	// Cache miss - need to parse
+	statsMu.Lock()
+	cacheMisses++
+	statsMu.Unlock()
+
+	// Acquire write lock to add to cache
+	parserCacheMu.Lock()
+	defer parserCacheMu.Unlock()
+
+	// Double-check after acquiring write lock (another goroutine might have added it)
+	if parser, exists := pathParserCache[path]; exists {
+		return parser, nil
+	}
+
+	// Parse the JSONPath expression
+	parser, err := jsonpath.Parse(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse JSONPath %s: %w", path, err)
+	}
+
+	// Cache it for future use
+	pathParserCache[path] = parser
+	return parser, nil
+}
+
+// GetParserCacheStats returns cache statistics
+func GetParserCacheStats() (hits, misses uint64, size int) {
+	statsMu.Lock()
+	h, m := cacheHits, cacheMisses
+	statsMu.Unlock()
+
+	parserCacheMu.RLock()
+	s := len(pathParserCache)
+	parserCacheMu.RUnlock()
+
+	return h, m, s
+}
+
+// ClearParserCache clears the cache (useful for testing)
+func ClearParserCache() {
+	parserCacheMu.Lock()
+	pathParserCache = make(map[string]func(interface{}) ([]interface{}, error))
+	parserCacheMu.Unlock()
+
+	statsMu.Lock()
+	cacheHits = 0
+	cacheMisses = 0
+	statsMu.Unlock()
+}
+
+// isListOfStringsOrNull checks if the variable is a slice containing only strings or nil values
+func isListOfStringsOrNull(variable interface{}) bool {
+	slice, ok := variable.([]interface{})
+	if !ok {
+		return false
+	}
+
+	for _, item := range slice {
+		if item == nil {
+			continue
+		}
+		if _, isString := item.(string); !isString {
+			return false
+		}
+	}
+	return true
+}
+
+// GetJsonPath queries a payload using JSONPath and returns the results
+func GetJsonPath(payload interface{}, path string, flattenResult bool) []interface{} {
+	resolvedPath, resolvedData, err := resolveJSONPathData(path, payload)
+	if err != nil {
+		// fmt.Printf("Error resolving JSONPath %s: %v\n", path, err)
+		return []interface{}{}
+	}
+
+	// Get or parse the JSONPath - uses cache if available
+	parser, err := getOrParseJSONPath(resolvedPath)
+	if err != nil {
+		// fmt.Printf("Error parsing JSONPath %s: %v\n", resolvedPath, err)
+		return []interface{}{}
+	}
+
+	// Execute the parsed JSONPath function
+	result, err := parser(resolvedData)
+	if err != nil {
+		// fmt.Printf("Error retrieving JSONPath %s: %v\n", resolvedPath, err)
+		return []interface{}{}
+	}
+
+	// Result is already []interface{}
+	output := result
+
+	if len(output) == 0 {
+		return []interface{}{}
+	}
+
+	if isListOfStringsOrNull(output) {
+		for i, item := range output {
+			if item == nil {
+				output[i] = "null"
+			}
+		}
+	}
+
+	if flattenResult {
+		output = flattenSlice(output)
+	}
+
+	return output
+}
+
+// flattenSlice recursively flattens nested slices
+func flattenSlice(slice []interface{}) []interface{} {
+	result := make([]interface{}, 0)
+	for _, item := range slice {
+		if nestedSlice, ok := item.([]interface{}); ok {
+			result = append(result, flattenSlice(nestedSlice)...)
+		} else {
+			result = append(result, item)
+		}
+	}
+	return result
+}
+
+func resolveJSONPathData(path string, data interface{}) (string, interface{}, error) {
+	if input, ok := data.(ValidationInput); ok {
+		if strings.HasPrefix(path, "$._EXTERNAL._SELF") {
+			resolvedPath := strings.Replace(path, "$._EXTERNAL._SELF", "$", 1)
+			return resolvedPath, input.ExternalData["_SELF"], nil
+		} else if strings.HasPrefix(path, "$._EXTERNAL") {
+			resolvedPath := strings.Replace(path, "$._EXTERNAL", "$", 1)
+			return resolvedPath, input.ExternalData, nil
+		}
+	}
+	return path, data, nil
+}

package/alpha/validationpkg/validationutils/storage-interface.go

@@ -0,0 +1,107 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+// StorageInterface provides a standardized abstraction layer for storage operations
+// that can be implemented by different storage backends (Redis, Memory, File, etc.).
+//
+// Implementation Notes:
+//   - Keys should be strings and values are stored as strings
+//   - Implementations should handle serialization/deserialization as needed
+//   - Prefix-based operations allow for namespacing and bulk operations
+//
+// Example:
+//
+//	type RedisStorage struct {
+//	    client *redis.Client
+//	}
+//
+//	func (r *RedisStorage) SaveKey(uniquePrefix, key, value string) error {
+//	    fullKey := fmt.Sprintf("%s:%s", uniquePrefix, key)
+//	    return r.client.Set(ctx, fullKey, value, 0).Err()
+//	}
+//
+//	storage := &RedisStorage{client: redisClient}
+//	userData, _ := json.Marshal(user)
+//	storage.SaveKey("app1", "user:123", string(userData))
+type StorageInterface interface {
+	// SaveKey saves a key-value pair to storage with a unique prefix for namespacing.
+	//
+	// Parameters:
+	//   - uniquePrefix: A unique identifier/namespace prefix to prevent key collisions
+	//   - key: The unique identifier for the stored value within the prefix namespace
+	//   - value: The string value to store
+	//
+	// Returns error if the operation fails
+	//
+	// Example:
+	//   sessionData, _ := json.Marshal(session)
+	//   err := storage.SaveKey("app1", "session:abc123", string(sessionData))
+	SaveKey(uniquePrefix string, key string, value string) error
+
+	// GetKey retrieves a value by its key from storage within a specific namespace.
+	//
+	// Parameters:
+	//   - uniquePrefix: The unique identifier/namespace prefix used when storing
+	//   - key: The unique identifier for the value to retrieve within the prefix namespace
+	//
+	// Returns the stored value and error if the key does not exist
+	//
+	// Example:
+	//   sessionData, err := storage.GetKey("app1", "session:abc123")
+	//   if err != nil {
+	//       // handle key not found
+	//   }
+	GetKey(uniquePrefix string, key string) (string, error)
+
+	// DeleteKey removes a key-value pair from storage within a specific namespace.
+	//
+	// Parameters:
+	//   - uniquePrefix: The unique identifier/namespace prefix used when storing
+	//   - key: The unique identifier for the value to delete within the prefix namespace
+	//
+	// Returns error if the operation fails
+	//
+	// Example:
+	//   err := storage.DeleteKey("app1", "session:abc123")
+	DeleteKey(uniquePrefix string, key string) error
+
+	// ListKeys lists all keys within a specific namespace/prefix.
+	//
+	// Parameters:
+	//   - uniquePrefix: The unique identifier/namespace prefix to list keys from
+	//
+	// Returns an array of keys within that namespace
+	//
+	// Example:
+	//   app1Keys, err := storage.ListKeys("app1")
+	//   // Returns keys stored under the "app1" namespace
+	//   // e.g., []string{"session:abc123", "user:456", "config:settings"}
+	ListKeys(uniquePrefix string) ([]string, error)
+
+	// ClearStorage clears all stored data from the storage backend.
+	//
+	// WARNING: This operation is destructive and cannot be undone.
+	// Use with caution, especially in production environments.
+	//
+	// Returns error if the operation fails
+	//
+	// Example:
+	//   err := storage.ClearStorage() // All data is now removed
+	ClearStorage() error
+
+	// KeyExists checks if a key exists in storage within a specific namespace.
+	//
+	// Parameters:
+	//   - uniquePrefix: The unique identifier/namespace prefix to check within
+	//   - key: The unique identifier to check for existence within the prefix namespace
+	//
+	// Returns true if the key exists, false otherwise
+	//
+	// Example:
+	//   exists, err := storage.KeyExists("app1", "user:123")
+	//   if err == nil && exists {
+	//       userData, _ := storage.GetKey("app1", "user:123")
+	//   }
+	KeyExists(uniquePrefix string, key string) (bool, error)
+}

package/alpha/validationpkg/validationutils/test-config.go

@@ -0,0 +1,69 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+// ValidationConfig holds configuration options for running validation routines.
+type ValidationConfig struct {
+	// StateFullValidations enables stateful validations that may depend on previous data
+	StateFullValidations bool
+	// SkipTests is a list of test names to be skipped during validation
+	SkipTests []string
+	// UniqueKey is an optional unique key for the validation instance
+	UniqueKey *string
+	// Store is an optional implementation of StorageInterface for persisting data across validations
+	Store StorageInterface
+	// OnlyInvalid if true, only invalid results will be returned
+	OnlyInvalid bool
+	// HideParentErrors hides nested error details if set to true
+	HideParentErrors bool
+	// Debug enables debug mode for additional diagnostic information
+	Debug bool
+	// SkipTestsDict is an internal map for quick lookup of tests to skip
+	SkipTestsDict map[string]bool
+}
+
+// ValidationOutput represents the output of a validation run.
+// Each element corresponds to a single validation test result.
+type ValidationOutput struct {
+	// TestName is the name of the validation test
+	TestName string `json:"testName"`
+	// Valid indicates whether the test passed (true) or failed (false)
+	Valid bool `json:"valid"`
+	// Code is a numeric code representing the result or error type
+	Code int `json:"code"`
+	// Description provides additional details about the test result
+	Description string `json:"description,omitempty"`
+	// DebugInfo contains diagnostic information useful for debugging
+	DebugInfo *DebugInfo `json:"_debugInfo,omitempty"`
+}
+
+// DebugInfo contains diagnostic information for validation results
+type DebugInfo struct {
+	// FedConfig is the configuration used to generate the validation
+	FedConfig interface{} `json:"fedConfig"`
+}
+
+// ExternalData holds external data references for validation as a map structure.
+//
+// Expected keys:
+//   - "_SELF": (interface{}) The current validation context object
+//
+// Example usage:
+//
+//	data := ExternalData{
+//	    "_SELF": currentObject,
+//	}
+type ExternalData = map[string]interface{}
+
+// ValidationInput represents the input data for validation functions
+type ValidationInput struct {
+	Payload      interface{}      `json:"payload"`
+	ExternalData ExternalData     `json:"_EXTERNAL,omitempty"`
+	Config       ValidationConfig `json:"_CONFIG,omitempty"`
+}
+
+// TestFunction is a function type that takes ValidationInput and returns a slice of ValidationOutput
+type TestFunction func(input ValidationInput) ([]ValidationOutput, error)
+
+// TestFunctionArray is a slice of test functions
+type TestFunctionArray []TestFunction