ondc-code-generator 0.6.21 → 0.7.0

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

@@ -0,0 +1,46 @@
+package utils
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+// NormalizeKeys converts all keys in a JSON object to snake_case
+func NormalizeKeys(data interface{}) interface{} {
+	switch v := data.(type) {
+	case map[string]interface{}:
+		normalized := make(map[string]interface{})
+		for key, value := range v {
+			normalizedKey := toSnakeCase(key)
+			normalized[normalizedKey] = NormalizeKeys(value)
+		}
+		return normalized
+	case []interface{}:
+		normalized := make([]interface{}, len(v))
+		for i, value := range v {
+			normalized[i] = NormalizeKeys(value)
+		}
+		return normalized
+	default:
+		return v
+	}
+}
+
+// toSnakeCase converts a string to snake_case
+func toSnakeCase(s string) string {
+	var result strings.Builder
+	for i, r := range s {
+		if i > 0 && r >= 'A' && r <= 'Z' {
+			result.WriteRune('_')
+		}
+		result.WriteRune(r)
+	}
+	return strings.ToLower(result.String())
+}
+
+// FromJSON parses JSON bytes into interface{}
+func FromJSON(data []byte) (interface{}, error) {
+	var result interface{}
+	err := json.Unmarshal(data, &result)
+	return result, err
+}

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

@@ -0,0 +1,21 @@
+package utils
+
+import (
+	"github.com/PaesslerAG/jsonpath"
+)
+
+// GetJSONPath extracts values from a JSON object using JSONPath
+func GetJSONPath(data interface{}, path string) []interface{} {
+	result, err := jsonpath.Get(path, data)
+	if err != nil {
+		return []interface{}{}
+	}
+
+	// If result is already a slice, return it
+	if slice, ok := result.([]interface{}); ok {
+		return slice
+	}
+
+	// Otherwise, wrap the single result in a slice
+	return []interface{}{result}
+}

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

@@ -0,0 +1,30 @@
+package storageactions
+
+import (
+	"L1_validations/interfaces"
+	"L1_validations/types"
+)
+
+// Store_{{action}} saves data for the {{action}} action
+func Store_{{action}}(uniquePrefix string, payload map[string]interface{}, store interfaces.StorageInterface, config types.StorageConfig) error {
+	{{#storeActions}}
+	if err := SaveFunction(payload, uniquePrefix, "{{{key}}}", "{{{value}}}", "{{action}}", store, config); err != nil {
+		return err
+	}
+	{{/storeActions}}
+	return nil
+}
+
+// LoadFor_{{action}} loads data for the {{action}} action
+func LoadFor_{{action}}(uniquePrefix string, store interfaces.StorageInterface) (map[string]interface{}, error) {
+	result := make(map[string]interface{})
+	
+	{{#loadActions}}
+	{{{key}}}Data, err := LoadFunction(store, uniquePrefix, "{{{key}}}")
+	if err == nil {
+		result["{{{key}}}"] = {{{key}}}Data
+	}
+	{{/loadActions}}
+	
+	return result, nil
+}

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

@@ -0,0 +1,41 @@
+package storageactions
+
+import (
+	"fmt"
+	"L1_validations/interfaces"
+	"L1_validations/types"
+)
+
+// Perform{{functionName}}Save saves validation data based on the action
+func Perform{{functionName}}Save(action, uniquePrefix string, payload map[string]interface{}, store interfaces.StorageInterface, config *types.StorageConfig) error {
+	completeConfig := types.DefaultStorageConfig()
+	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 data based on the action
+func Perform{{functionName}}Load(action, uniquePrefix string, store interfaces.StorageInterface) (map[string]interface{}, error) {
+	switch action {
+	{{#actions}}
+	case "{{{action}}}":
+		return LoadFor_{{{action}}}(uniquePrefix, store)
+	{{/actions}}
+	default:
+		return nil, fmt.Errorf("action not found: %s", action)
+	}
+}

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

@@ -0,0 +1,37 @@
+package utils
+
+import (
+	"fmt"
+	"time"
+	"L1_validations/interfaces"
+	"L1_validations/types"
+)
+
+// SaveData saves data to storage with retry logic
+func SaveData(uniquePrefix, key, saveData string, store interfaces.StorageInterface, config types.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 err
+		}
+
+		time.Sleep(time.Duration(delayMs) * time.Millisecond)
+	}
+
+	return fmt.Errorf("failed to save data after %d attempts", retryTimes)
+}
+
+// CreateKey creates a composite key from prefix and key
+func CreateKey(uniquePrefix, key string) string {
+	return fmt.Sprintf("%s:%s", uniquePrefix, key)
+}

package/dist/generator/generators/golang/templates/storage-templates/storage-helpers.mustache

@@ -0,0 +1,51 @@
+package storageactions
+
+import (
+	"encoding/json"
+	"time"
+	"L1_validations/utils"
+	"L1_validations/interfaces"
+	"L1_validations/types"
+)
+
+// SaveFunction saves a value from payload at specified path to storage
+func SaveFunction(payload map[string]interface{}, uniquePrefix, key, path, action string, store interfaces.StorageInterface, config types.StorageConfig) error {
+	if path == "" || key == "_SELF" {
+		return nil
+	}
+
+	value := utils.GetJSONPath(payload, path)
+
+	data := map[string]interface{}{
+		"stored_from": action + "_action",
+		"key_path":    path,
+		"value":       value,
+		"timestamp":   time.Now().Format(time.RFC3339),
+	}
+
+	dataBytes, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	return utils.SaveData(uniquePrefix, key, string(dataBytes), store, config)
+}
+
+// LoadFunction loads a value from storage by key
+func LoadFunction(store interfaces.StorageInterface, uniquePrefix, key string) (interface{}, error) {
+	value, err := store.GetKey(uniquePrefix, key)
+	if err != nil {
+		return []interface{}{}, nil
+	}
+
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(value), &data); err != nil {
+		return []interface{}{}, nil
+	}
+
+	if val, ok := data["value"]; ok {
+		return val, nil
+	}
+
+	return []interface{}{}, nil
+}

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

@@ -0,0 +1,96 @@
+package interfaces
+
+// StorageInterface provides a standardized abstraction layer for storage operations
+// that can be implemented by different storage backends (Redis, Memory, File, etc.).
+//
+// All operations return errors for failure cases.
+// Keys are strings and values are stored as strings.
+// Implementations should handle serialization/deserialization as needed.
+// Prefix-based operations allow for namespacing and bulk operations.
+//
+// Example implementation:
+//
+//	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()
+//	}
+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 an error if the operation fails.
+	//
+	// Example:
+	//   err := storage.SaveKey("app1", "session:abc123", sessionDataJSON)
+	SaveKey(uniquePrefix, key, 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 or an error if the key does not exist.
+	//
+	// Example:
+	//   sessionData, err := storage.GetKey("app1", "session:abc123")
+	GetKey(uniquePrefix, 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 an error if the operation fails.
+	//
+	// Example:
+	//   err := storage.DeleteKey("app1", "session:abc123")
+	DeleteKey(uniquePrefix, key string) error
+
+	// ListKeys returns 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 or an error.
+	//
+	// Example:
+	//   app1Keys, err := storage.ListKeys("app1")
+	//   // Returns keys like: ["session:abc123", "user:456", "config:settings"]
+	ListKeys(uniquePrefix string) ([]string, error)
+
+	// ClearStorage removes all stored data from the storage backend.
+	//
+	// WARNING: This operation is destructive and cannot be undone.
+	// Use with caution, especially in production environments.
+	//
+	// Returns an 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, or an error.
+	//
+	// Example:
+	//   exists, err := storage.KeyExists("app1", "user:123")
+	//   if exists {
+	//       userData, _ := storage.GetKey("app1", "user:123")
+	//   }
+	KeyExists(uniquePrefix, key string) (bool, error)
+}

package/dist/generator/generators/golang/templates/storage-templates/storage-types.mustache

@@ -0,0 +1,15 @@
+package types
+
+// StorageConfig holds configuration for storage retry behavior
+type StorageConfig struct {
+	RetryAttempts int // Number of retry attempts for failed operations
+	RetryDelayMs  int // Delay in milliseconds between retry attempts
+}
+
+// DefaultStorageConfig returns the default storage configuration
+func DefaultStorageConfig() StorageConfig {
+	return StorageConfig{
+		RetryAttempts: 3,
+		RetryDelayMs:  1000,
+	}
+}

package/dist/generator/generators/golang/templates/test-config.mustache

@@ -0,0 +1,39 @@
+package types
+
+import "L1_validations/interfaces"
+
+// ValidationConfig holds configuration for validation execution
+type ValidationConfig struct {
+	OnlyInvalid           bool                          `json:"only_invalid"`
+	StandardLogs          bool                          `json:"standard_logs"`
+	Debug                 bool                          `json:"_debug"`
+	HideParentErrors      bool                          `json:"hide_parent_errors"`
+	StateFullValidations  bool                          `json:"state_full_validations"`
+	Store                 interfaces.StorageInterface   `json:"-"`
+	StorageConfig         *StorageConfig                `json:"storage_config,omitempty"`
+	UniqueKey             string                        `json:"unique_key,omitempty"`
+}
+
+// ValidationInput is the input structure for validation functions
+type ValidationInput struct {
+	Payload      map[string]interface{} `json:"payload"`
+	ExternalData map[string]interface{} `json:"external_data"`
+	Config       ValidationConfig       `json:"config"`
+}
+
+// ValidationOutput represents a single validation result
+type ValidationOutput struct {
+	TestName    string                 `json:"test_name,omitempty"`
+	Valid       bool                   `json:"valid"`
+	Code        int                    `json:"code"`
+	Description string                 `json:"description,omitempty"`
+	DebugInfo   map[string]interface{} `json:"_debug_info,omitempty"`
+}
+
+// ExternalData structure
+type ExternalData struct {
+	{{#externalData}}
+	{{name}} interface{} `json:"{{name}}"`
+	{{/externalData}}
+	Self interface{} `json:"_SELF"`
+}

package/dist/generator/generators/golang/templates/test-object.mustache

@@ -0,0 +1,39 @@
+func {{name}}(input types.ValidationInput) []types.ValidationOutput {
+	scope := utils.GetJSONPath(input.Payload, "{{{scopePath}}}")
+	subResults := []types.ValidationOutput{}
+	valid := true
+
+	for _, testObjRaw := range scope {
+		testObj, ok := testObjRaw.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		testObj["_EXTERNAL"] = input.ExternalData
+
+		{{#variables}}
+		{{name}} {{#isAssignment}}={{/isAssignment}}{{^isAssignment}}:={{/isAssignment}} {{{value}}}
+		{{^isAssignment}}utils.UNUSED({{name}}){{/isAssignment}}
+		{{/variables}}
+
+		{{#hasContinue}}
+		skipCheck := {{{skipCheckStatement}}}
+		if skipCheck {
+			continue
+		}
+		{{/hasContinue}}
+
+{{{validationCode}}}
+		// delete(testObj, "_EXTERNAL")
+	}
+
+	return append([]types.ValidationOutput{
+		{
+			TestName: "{{testName}}",
+			Valid:    valid,
+			Code:     func() int { if valid { return {{successCode}} } else { return {{errorCode}} } }(),
+			DebugInfo: map[string]interface{}{
+				"fed_config": `{{{TEST_OBJECT}}}`,
+			},
+		},
+	}, subResults...)
+}

package/dist/generator/generators/golang/templates/validation-code.mustache

@@ -0,0 +1,51 @@
+{{#isNested}}
+testFunctions := []func(types.ValidationInput) []types.ValidationOutput{
+	{{#names}}
+	{{name}},
+	{{/names}}
+}
+
+allResults := []types.ValidationOutput{}
+for _, fn := range testFunctions {
+	subResult := fn(input)
+	allResults = append(allResults, subResult...)
+}
+subResults = allResults
+valid = true
+for _, r := range subResults {
+	if !r.Valid {
+		valid = false
+		break
+	}
+}
+
+{{/isNested}}
+
+{{^isNested}}
+
+{{#isStateFull}}
+validate := true
+if input.Config.StateFullValidations {
+	validate = {{{returnStatement}}}
+}
+{{/isStateFull}}
+
+{{^isStateFull}}
+validate := {{{returnStatement}}}
+{{/isStateFull}}
+
+if !validate {
+	return []types.ValidationOutput{
+		{
+			TestName:    "{{testName}}",
+			Valid:       false,
+			Code:        {{errorCode}},
+			Description: `{{{errorDescription}}}`,
+			DebugInfo: map[string]interface{}{
+				"fed_config": `{{{TEST_OBJECT}}}`,
+			},
+		},
+	}
+}
+
+{{/isNested}}