ondc-code-generator 0.7.0 → 0.7.3

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

@@ -1,41 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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-types.mustache

@@ -1,15 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,51 +0,0 @@
-{{#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}}

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

@@ -1,246 +0,0 @@
-package utils
-
-import (
-	"fmt"
-	"regexp"
-	"strconv"
-	"time"
-)
-
-// UNUSED suppresses "declared and not used" compiler errors
-func UNUSED(x ...interface{}) {}
-
-// toString converts interface{} to string representation
-func toString(v interface{}) string {
-	if v == nil {
-		return "null"
-	}
-	return fmt.Sprintf("%v", v)
-}
-
-// AreUnique checks if all values in the slice are unique
-func AreUnique(operand []interface{}) bool {
-	seen := make(map[string]bool)
-	for _, v := range operand {
-		s := toString(v)
-		if seen[s] {
-			return false
-		}
-		seen[s] = true
-	}
-	return true
-}
-
-// ArePresent checks if there are no null, undefined, or empty strings in the slice
-func ArePresent(operand []interface{}) bool {
-	return NoneIn(operand, []interface{}{"null", "undefined", ""}) && len(operand) > 0
-}
-
-// AllIn checks if all values in left are present in right
-func AllIn(left, right []interface{}) bool {
-	if len(left) == 0 && len(right) != 0 {
-		return false
-	}
-	rightMap := make(map[string]bool)
-	for _, v := range right {
-		rightMap[toString(v)] = true
-	}
-	for _, v := range left {
-		if !rightMap[toString(v)] {
-			return false
-		}
-	}
-	return true
-}
-
-// AnyIn checks if any value in left is present in right
-func AnyIn(left, right []interface{}) bool {
-	if len(left) == 0 && len(right) != 0 {
-		return false
-	}
-	rightMap := make(map[string]bool)
-	for _, v := range right {
-		rightMap[toString(v)] = true
-	}
-	for _, v := range left {
-		if rightMap[toString(v)] {
-			return true
-		}
-	}
-	return false
-}
-
-// NoneIn checks if none of the values in left are present in right
-func NoneIn(left, right []interface{}) bool {
-	rightMap := make(map[string]bool)
-	for _, v := range right {
-		rightMap[toString(v)] = true
-	}
-	for _, v := range left {
-		if rightMap[toString(v)] {
-			return false
-		}
-	}
-	return true
-}
-
-// EqualTo checks if left and right are equal (same values in same order)
-func EqualTo(left, right []interface{}) bool {
-	if len(left) != len(right) {
-		return false
-	}
-	for i, v := range left {
-		if toString(v) != toString(right[i]) {
-			return false
-		}
-	}
-	return true
-}
-
-// isISO8601 checks if a string is in ISO 8601 format
-func isISO8601(s string) bool {
-	iso8601Regex := `^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$`
-	matched, _ := regexp.MatchString(iso8601Regex, s)
-	if !matched {
-		return false
-	}
-	_, err := time.Parse(time.RFC3339, s)
-	return err == nil
-}
-
-// isNumber checks if a string can be parsed as a number
-func isNumber(s string) bool {
-	_, err := strconv.ParseFloat(s, 64)
-	return err == nil
-}
-
-// areAllISO checks if all values in the slice are ISO 8601 dates
-func areAllISO(arr []interface{}) bool {
-	for _, v := range arr {
-		if !isISO8601(toString(v)) {
-			return false
-		}
-	}
-	return true
-}
-
-// areAllNumbers checks if all values in the slice are numbers
-func areAllNumbers(arr []interface{}) bool {
-	for _, v := range arr {
-		if !isNumber(toString(v)) {
-			return false
-		}
-	}
-	return true
-}
-
-// GreaterThan checks if all values in left are greater than corresponding values in right
-func GreaterThan(left, right []interface{}) bool {
-	if areAllISO(left) && areAllISO(right) {
-		leftDates := make([]time.Time, len(left))
-		rightDates := make([]time.Time, len(right))
-		
-		for i, d := range left {
-			leftDates[i], _ = time.Parse(time.RFC3339, toString(d))
-		}
-		for i, d := range right {
-			rightDates[i], _ = time.Parse(time.RFC3339, toString(d))
-		}
-		
-		for i, ld := range leftDates {
-			if i >= len(rightDates) {
-				continue
-			}
-			if !ld.After(rightDates[i]) {
-				return false
-			}
-		}
-		return true
-	} else if areAllNumbers(left) && areAllNumbers(right) {
-		leftNumbers := make([]float64, len(left))
-		rightNumbers := make([]float64, len(right))
-		
-		for i, n := range left {
-			leftNumbers[i], _ = strconv.ParseFloat(toString(n), 64)
-		}
-		for i, n := range right {
-			rightNumbers[i], _ = strconv.ParseFloat(toString(n), 64)
-		}
-		
-		for i, ln := range leftNumbers {
-			if i >= len(rightNumbers) {
-				continue
-			}
-			if ln <= rightNumbers[i] {
-				return false
-			}
-		}
-		return true
-	}
-	return false
-}
-
-// LessThan checks if all values in left are less than corresponding values in right
-func LessThan(left, right []interface{}) bool {
-	if areAllISO(left) && areAllISO(right) {
-		leftDates := make([]time.Time, len(left))
-		rightDates := make([]time.Time, len(right))
-		
-		for i, d := range left {
-			leftDates[i], _ = time.Parse(time.RFC3339, toString(d))
-		}
-		for i, d := range right {
-			rightDates[i], _ = time.Parse(time.RFC3339, toString(d))
-		}
-		
-		for i, ld := range leftDates {
-			if i >= len(rightDates) {
-				continue
-			}
-			if !ld.Before(rightDates[i]) {
-				return false
-			}
-		}
-		return true
-	} else if areAllNumbers(left) && areAllNumbers(right) {
-		leftNumbers := make([]float64, len(left))
-		rightNumbers := make([]float64, len(right))
-		
-		for i, n := range left {
-			leftNumbers[i], _ = strconv.ParseFloat(toString(n), 64)
-		}
-		for i, n := range right {
-			rightNumbers[i], _ = strconv.ParseFloat(toString(n), 64)
-		}
-		
-		for i, ln := range leftNumbers {
-			if i >= len(rightNumbers) {
-				continue
-			}
-			if ln >= rightNumbers[i] {
-				return false
-			}
-		}
-		return true
-	}
-	return false
-}
-
-// FollowRegex checks if all values in left match all regex patterns in regexArray
-func FollowRegex(left, regexArray []interface{}) bool {
-	if len(left) == 0 && len(regexArray) != 0 {
-		return false
-	}
-	for _, pattern := range regexArray {
-		re, err := regexp.Compile(toString(pattern))
-		if err != nil {
-			return false
-		}
-		for _, v := range left {
-			if !re.MatchString(toString(v)) {
-				return false
-			}
-		}
-	}
-	return true
-}