ondc-code-generator 0.6.22 → 0.7.3

package/dist/generator/generators/go/templates/json-normalizer.mustache

@@ -0,0 +1,155 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+import (
+	"encoding/json"
+)
+
+// NormalizeKeys normalizes JSON structures so that:
+//  - All objects with the same property name share the union of keys seen anywhere
+//  - All objects inside the same array share the union of keys at that array level
+//  - Missing keys are filled with nil
+func NormalizeKeys(input interface{}) interface{} {
+	// Step 1: Collect templates by property name
+	templatesByPropName := make(map[string]map[string]struct{})
+	collectTemplates(input, templatesByPropName)
+
+	// Step 2: Apply templates and within-array unions
+	return applyTemplates(input, templatesByPropName)
+}
+
+// collectTemplates walks the data structure and collects all keys for each property name
+func collectTemplates(node interface{}, templates map[string]map[string]struct{}) {
+	switch v := node.(type) {
+	case []interface{}:
+		// Recurse into array items
+		for _, item := range v {
+			collectTemplates(item, templates)
+		}
+
+	case map[string]interface{}:
+		// For each property: if it's an object (non-array), record its keys
+		for propName, propValue := range v {
+			if obj, ok := propValue.(map[string]interface{}); ok {
+				// Initialize set for this property name if needed
+				if templates[propName] == nil {
+					templates[propName] = make(map[string]struct{})
+				}
+				// Add all keys from this object to the template
+				for childKey := range obj {
+					templates[propName][childKey] = struct{}{}
+				}
+			}
+			// Recurse into the value
+			collectTemplates(propValue, templates)
+		}
+	}
+}
+
+// applyTemplates applies the collected templates and array-level unions
+func applyTemplates(node interface{}, templates map[string]map[string]struct{}) interface{} {
+	switch v := node.(type) {
+	case []interface{}:
+		// Compute union of keys across all object elements at this array level
+		arrayUnion := make(map[string]struct{})
+		for _, item := range v {
+			if obj, ok := item.(map[string]interface{}); ok {
+				for key := range obj {
+					arrayUnion[key] = struct{}{}
+				}
+			}
+		}
+
+		// Apply union to each array element
+		result := make([]interface{}, len(v))
+		for i, item := range v {
+			if obj, ok := item.(map[string]interface{}); ok {
+				// Create new object with array union keys
+				next := make(map[string]interface{})
+				
+				// Copy existing keys
+				for k, val := range obj {
+					next[k] = val
+				}
+				
+				// Add missing keys from array union
+				for key := range arrayUnion {
+					if _, exists := next[key]; !exists {
+						next[key] = nil
+					}
+				}
+
+				// Now apply templates per property name for nested objects
+				for propName, propValue := range next {
+					if nestedObj, ok := propValue.(map[string]interface{}); ok {
+						// Align to template for this property name
+						next[propName] = fillFromTemplate(propName, nestedObj, templates)
+					} else {
+						// Recurse for arrays or other structures
+						next[propName] = applyTemplates(propValue, templates)
+					}
+				}
+				result[i] = next
+			} else {
+				// Not an object, just recurse
+				result[i] = applyTemplates(item, templates)
+			}
+		}
+		return result
+
+	case map[string]interface{}:
+		out := make(map[string]interface{})
+		for propName, propValue := range v {
+			if nestedObj, ok := propValue.(map[string]interface{}); ok {
+				// Align object to the template for this property name
+				out[propName] = fillFromTemplate(propName, nestedObj, templates)
+			} else {
+				out[propName] = applyTemplates(propValue, templates)
+			}
+		}
+		return out
+
+	default:
+		// Primitives unchanged
+		return v
+	}
+}
+
+// fillFromTemplate applies the template for a given property name
+func fillFromTemplate(propName string, obj map[string]interface{}, templates map[string]map[string]struct{}) interface{} {
+	// First recurse on children so nested arrays/objects also normalize
+	base := applyTemplates(obj, templates).(map[string]interface{})
+
+	// Get template for this property name
+	template, hasTemplate := templates[propName]
+	if !hasTemplate {
+		return base // No known template keys for this prop
+	}
+
+	// Fill missing keys with nil
+	filled := make(map[string]interface{})
+	for k, v := range base {
+		filled[k] = v
+	}
+	for key := range template {
+		if _, exists := filled[key]; !exists {
+			filled[key] = nil
+		}
+	}
+
+	return filled
+}
+
+// DeepCloneJSON creates a deep clone of a JSON-serializable structure
+func DeepCloneJSON(v interface{}) interface{} {
+	b, err := json.Marshal(v)
+	if err != nil {
+		panic(err) // or handle error
+	}
+	var out interface{}
+	if err := json.Unmarshal(b, &out); err != nil {
+		panic(err)
+	}
+	return out
+}

package/dist/generator/generators/go/templates/json-path-utils.mustache

@@ -0,0 +1,63 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+import (
+	"github.com/AsaiYusuke/jsonpath"
+)
+
+// 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{} {
+	output, err := jsonpath.Retrieve(path, payload)
+	if err != nil {
+		return []interface{}{}
+	}
+
+	if isListOfStringsOrNull(output) {
+		for i, item := range output {
+			if item == nil {
+				output[i] = "null"
+			}
+		}
+	}
+
+	if flattenResult {
+		output = flattenSlice(output)
+	}
+
+	if len(output) == 0 {
+		return []interface{}{}
+	}
+	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
+}

package/dist/generator/generators/go/templates/storage-templates/api-save-utils.mustache

@@ -0,0 +1,84 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package storageutils
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+	"validationpkg/validationutils"
+)
+
+
+// saveFunction saves extracted data from payload to storage
+func saveFunction(
+	payload interface{},
+	uniquePrefix string,
+	key string,
+	path string,
+	store validationutils.StorageInterface,
+	config StorageConfig,
+	action string,
+) error {
+	if path == "" || key == "_SELF" {
+		return nil
+	}
+
+	// Extract value using JSONPath
+	value := validationutils.GetJsonPath(payload, path, true)
+
+	// Create data structure
+	data := map[string]interface{}{
+		"stored_from": action + "_action",
+		"key_path":    path,
+		"value":       value,
+		"timestamp":   time.Now().UTC().Format(time.RFC3339),
+	}
+
+	// Serialize to JSON
+	dataBytes, err := json.Marshal(data)
+	if err != nil {
+		return fmt.Errorf("failed to marshal data: %w", err)
+	}
+
+	// Save with retry logic
+	return SaveData(uniquePrefix, key, string(dataBytes), store, config)
+}
+
+// loadFunction loads and parses stored data from storage
+func loadFunction(
+	store validationutils.StorageInterface,
+	uniquePrefix string,
+	key string,
+) ([]string, error) {
+	value, err := store.GetKey(uniquePrefix, key)
+	if err != nil {
+		// Return empty slice on error (matches TS behavior)
+		return []string{}, nil
+	}
+
+	if value == "" {
+		return []string{}, nil
+	}
+
+	// Parse JSON
+	var data struct {
+		Value []interface{} `json:"value"`
+	}
+
+	if err := json.Unmarshal([]byte(value), &data); err != nil {
+		return []string{}, nil
+	}
+
+	// Convert to string slice
+	result := make([]string, 0, len(data.Value))
+	for _, v := range data.Value {
+		if v == nil {
+			result = append(result, "null")
+		} else {
+			result = append(result, fmt.Sprintf("%v", v))
+		}
+	}
+
+	return result, nil
+}

package/dist/generator/generators/go/templates/storage-templates/api-save.mustache

@@ -0,0 +1,44 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package storageutils
+
+import (
+	"validationpkg/validationutils"
+	"fmt"
+)
+
+// Store_{{action}} stores data from payload to storage for the {{action}} action
+func Store_{{action}}(
+	uniquePrefix string,
+	payload interface{},
+	store validationutils.StorageInterface,
+	config StorageConfig,
+) error {
+	{{#storeActions}}
+	if err := saveFunction(payload, uniquePrefix, "{{{key}}}", "{{{value}}}", store, config, "{{$action}}"); err != nil {
+		return fmt.Errorf("failed to save key {{{key}}}: %w", err)
+	}
+	{{/storeActions}}
+	fmt.Printf("Stored data for action {{action}} successfully\n")
+	return nil
+}
+
+// LoadFor_{{action}} loads stored data for the {{action}} action
+func LoadFor_{{action}}(
+	uniquePrefix string,
+	store validationutils.StorageInterface,
+) (validationutils.ExternalData, error) {
+	result := validationutils.ExternalData{}
+	
+	{{#loadActions}}
+	{{{key}}}_value, err := loadFunction(store, uniquePrefix, "{{{key}}}")
+	if err != nil {
+		return result, fmt.Errorf("failed to load key {{{key}}}: %w", err)
+	}
+	result.{{{key}}} = {{{key}}}_value
+	{{/loadActions}}
+	
+	fmt.Printf("Loaded external data for action {{action}}: %+v\n", result)
+	return result, nil
+}
+

package/dist/generator/generators/go/templates/storage-templates/index.mustache

@@ -0,0 +1,72 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+package storageutils
+
+import (
+	"fmt"
+	"validationpkg/validationutils"
+)
+
+// Perform{{functionName}}Save saves validation state data for a given action
+//
+// Parameters:
+//   - action: The action name
+//   - uniquePrefix: Unique namespace prefix
+//   - payload: The payload data to extract and save
+//   - store: Storage interface implementation
+//   - config: Optional storage configuration (nil uses defaults)
+//
+// Returns error if the action is not found or save fails
+func Perform{{functionName}}Save(
+	action string,
+	uniquePrefix string,
+	payload interface{},
+	store validationutils.StorageInterface,
+	config *StorageConfig,
+) error {
+	// Set default config if not provided
+	completeConfig := StorageConfig{
+		RetryAttempts: 3,
+		RetryDelayMs:  1000,
+	}
+
+	if config != nil {
+		if config.RetryAttempts > 0 {
+			completeConfig.RetryAttempts = config.RetryAttempts
+		}
+		if config.RetryDelayMs > 0 {
+			completeConfig.RetryDelayMs = config.RetryDelayMs
+		}
+	}
+
+	switch action {
+	{{#actions}}
+	case "{{action}}":
+		return Store_{{{action}}}(uniquePrefix, payload, store, completeConfig)
+	{{/actions}}
+	default:
+		return fmt.Errorf("action not found: %s", action)
+	}
+}
+
+// Perform{{functionName}}Load loads validation state data for a given action
+//
+// Parameters:
+//   - action: The action name
+//   - uniquePrefix: Unique namespace prefix
+//   - store: Storage interface implementation
+//
+// Returns ExternalData with loaded values and error if action not found
+func Perform{{functionName}}Load(
+	action string,
+	uniquePrefix string,
+	store validationutils.StorageInterface,
+) (validationutils.ExternalData, error) {
+	switch action {
+	{{#actions}}
+	case "{{action}}":
+		return LoadFor_{{{action}}}(uniquePrefix, store)
+	{{/actions}}
+	default:
+		return validationutils.ExternalData{}, fmt.Errorf("action not found: %s", action)
+	}
+}

package/dist/generator/generators/go/templates/storage-templates/save-utils.mustache

@@ -0,0 +1,75 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package storageutils
+
+import (
+	"fmt"
+	"time"
+	"validationpkg/validationutils"
+)
+
+// StorageConfig holds configuration for storage operations
+type StorageConfig struct {
+	// RetryAttempts is the number of times to retry a failed operation
+	RetryAttempts int
+	// RetryDelayMs is the delay in milliseconds between retry attempts
+	RetryDelayMs int
+}
+
+// DefaultStorageConfig returns a StorageConfig with sensible defaults
+func DefaultStorageConfig() StorageConfig {
+	return StorageConfig{
+		RetryAttempts: 3,
+		RetryDelayMs:  100,
+	}
+}
+
+// SaveData saves data to storage with retry logic
+//
+// Parameters:
+//   - uniquePrefix: The namespace prefix for the key
+//   - key: The key to store the data under
+//   - saveData: The string data to save
+//   - store: The storage interface implementation
+//   - config: Configuration including retry settings
+//
+// Returns error if all retry attempts fail
+func SaveData(
+	uniquePrefix string,
+	key string,
+	saveData string,
+	store validationutils.StorageInterface,
+	config StorageConfig,
+) error {
+	finalKey := key
+	retryTimes := config.RetryAttempts
+	delayMs := config.RetryDelayMs
+	attempts := 0
+
+	for attempts < retryTimes {
+		err := store.SaveKey(uniquePrefix, finalKey, saveData)
+		if err == nil {
+			return nil
+		}
+
+		attempts++
+		if attempts >= retryTimes {
+			return fmt.Errorf("failed to save data after %d attempts: %w", retryTimes, err)
+		}
+
+		time.Sleep(time.Duration(delayMs) * time.Millisecond)
+	}
+
+	return nil
+}
+
+// CreateKey creates a fully qualified storage key from prefix and key
+//
+// Parameters:
+//   - uniquePrefix: The namespace prefix
+//   - key: The key within the namespace
+//
+// Returns the combined key in format "prefix:key"
+func CreateKey(uniquePrefix string, key string) string {
+	return fmt.Sprintf("%s:%s", uniquePrefix, key)
+}

package/dist/generator/generators/go/templates/storage-templates/storage-interface.mustache

@@ -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/dist/generator/generators/go/templates/test-config.mustache

@@ -0,0 +1,62 @@
+// 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
+	// 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
+}
+
+// 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
+type ExternalData struct {
+	Self interface{} `json:"_SELF,omitempty"`
+    {{#externalData}}
+    {{name}} []string `json:"{{name}},omitempty"`
+    {{/externalData}}
+}
+
+// ValidationInput represents the input data for validation functions
+type ValidationInput struct {
+	Payload      interface{}
+	ExternalData ExternalData
+	Config       ValidationConfig
+}
+
+// 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
+