ondc-code-generator 0.8.8 → 0.9.0

package/alpha/golang/newPkg/validationutils/validation_utils.go

@@ -1,429 +0,0 @@
-// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
-
-package validationutils
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/dlclark/regexp2"
-)
-
-// toStringSlice converts []interface{} to []string, returns false if any element is not a string
-func toStringSlice(operand []interface{}) ([]string, bool) {
-	result := make([]string, len(operand))
-	for i, v := range operand {
-		str, ok := v.(string)
-		if !ok {
-			// Try to convert to string
-			if v == nil {
-				result[i] = "null"
-			} else {
-				result[i] = fmt.Sprintf("%v", v)
-			}
-		} else {
-			result[i] = str
-		}
-	}
-	return result, true
-}
-
-func AreUnique(operand []interface{}) bool {
-	strs, ok := toStringSlice(operand)
-	if !ok {
-		return false
-	}
-
-	valuesSet := make(map[string]struct{})
-	for _, v := range strs {
-		valuesSet[v] = struct{}{}
-	}
-	return len(valuesSet) == len(strs)
-}
-
-func ArePresent(operand []interface{}) bool {
-	strs, ok := toStringSlice(operand)
-	if !ok {
-		return false
-	}
-	return NoneIn(operand, []interface{}{"null", "undefined"}) && len(strs) > 0
-}
-
-// Lookup interface for abstraction
-type lookup interface {
-	contains(string) bool
-	isEmpty() bool
-}
-
-// Map-based lookup (O(1))
-type mapLookup struct {
-	items map[string]bool
-}
-
-func (m *mapLookup) contains(item string) bool {
-	return m.items[item]
-}
-
-func (m *mapLookup) isEmpty() bool {
-	return len(m.items) == 0
-}
-
-// Slice-based lookup (O(n))
-type sliceLookup struct {
-	items []string
-}
-
-func (s *sliceLookup) contains(item string) bool {
-	for _, v := range s.items {
-		if v == item {
-			return true
-		}
-	}
-	return false
-}
-
-func (s *sliceLookup) isEmpty() bool {
-	return len(s.items) == 0
-}
-
-// Smart lookup creation - auto-detects and optimizes
-func createLookup(right []interface{}) (lookup, bool) {
-	// Case 1: Check if right contains a single map
-	if len(right) == 1 {
-		switch m := right[0].(type) {
-		case map[string]interface{}:
-			result := make(map[string]bool, len(m))
-			for k := range m {
-				result[k] = true
-			}
-			return &mapLookup{items: result}, true
-		case map[string]bool:
-			return &mapLookup{items: m}, true
-		case map[string]string:
-			result := make(map[string]bool, len(m))
-			for k := range m {
-				result[k] = true
-			}
-			return &mapLookup{items: result}, true
-		}
-	}
-
-	// Case 2: Convert slice to string slice
-	rightStrs, ok := toStringSlice(right)
-	if !ok {
-		return nil, false
-	}
-
-	// Optimization: Convert large slices to maps for better performance
-	const threshold = 10
-	if len(rightStrs) > threshold {
-		m := make(map[string]bool, len(rightStrs))
-		for _, v := range rightStrs {
-			m[v] = true
-		}
-		return &mapLookup{items: m}, true
-	}
-
-	return &sliceLookup{items: rightStrs}, true
-}
-
-// Updated comparison functions
-func AllIn(left []interface{}, right []interface{}) bool {
-	leftStrs, ok1 := toStringSlice(left)
-	if !ok1 {
-		return false
-	}
-
-	rightLookup, ok2 := createLookup(right)
-	if !ok2 {
-		return false
-	}
-
-	if len(leftStrs) == 0 && !rightLookup.isEmpty() {
-		return false
-	}
-
-	for _, v := range leftStrs {
-		if !rightLookup.contains(v) {
-			return false
-		}
-	}
-	return true
-}
-
-func AnyIn(left []interface{}, right []interface{}) bool {
-	leftStrs, ok1 := toStringSlice(left)
-	if !ok1 {
-		return false
-	}
-
-	rightLookup, ok2 := createLookup(right)
-	if !ok2 {
-		return false
-	}
-
-	if len(leftStrs) == 0 && !rightLookup.isEmpty() {
-		return false
-	}
-
-	for _, v := range leftStrs {
-		if rightLookup.contains(v) {
-			return true
-		}
-	}
-	return false
-}
-
-func NoneIn(left []interface{}, right []interface{}) bool {
-	leftStrs, ok1 := toStringSlice(left)
-	if !ok1 {
-		return false
-	}
-
-	rightLookup, ok2 := createLookup(right)
-	if !ok2 {
-		return false
-	}
-
-	for _, v := range leftStrs {
-		if rightLookup.contains(v) {
-			return false
-		}
-	}
-	return true
-}
-func EqualTo(left []interface{}, right []interface{}) bool {
-	leftStrs, ok1 := toStringSlice(left)
-	rightStrs, ok2 := toStringSlice(right)
-	if !ok1 || !ok2 {
-		return false
-	}
-
-	if len(leftStrs) != len(rightStrs) {
-		return false
-	}
-	for i, v := range leftStrs {
-		if v != rightStrs[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func GreaterThan(left []interface{}, right []interface{}) bool {
-	leftStrs, ok1 := toStringSlice(left)
-	rightStrs, ok2 := toStringSlice(right)
-	if !ok1 || !ok2 {
-		return false
-	}
-
-	areAllISO := func(arr []string) bool {
-		for _, v := range arr {
-			if !isISO8601(v) {
-				return false
-			}
-		}
-		return true
-	}
-
-	areAllNumbers := func(arr []string) bool {
-		for _, v := range arr {
-			if _, err := strconv.ParseFloat(v, 64); err != nil {
-				return false
-			}
-		}
-		return true
-	}
-
-	if areAllISO(leftStrs) && areAllISO(rightStrs) {
-		leftDates := make([]int64, len(leftStrs))
-		for i, date := range leftStrs {
-			t, _ := time.Parse(time.RFC3339, date)
-			leftDates[i] = t.UnixMilli()
-		}
-
-		rightDates := make([]int64, len(rightStrs))
-		for i, date := range rightStrs {
-			t, _ := time.Parse(time.RFC3339, date)
-			rightDates[i] = t.UnixMilli()
-		}
-
-		for i, ld := range leftDates {
-			if i >= len(rightDates) || ld <= rightDates[i] {
-				if i < len(rightDates) {
-					return false
-				}
-			}
-		}
-		return true
-	} else if areAllNumbers(leftStrs) && areAllNumbers(rightStrs) {
-		leftNumbers := make([]float64, len(leftStrs))
-		for i, v := range leftStrs {
-			leftNumbers[i], _ = strconv.ParseFloat(v, 64)
-		}
-
-		rightNumbers := make([]float64, len(rightStrs))
-		for i, v := range rightStrs {
-			rightNumbers[i], _ = strconv.ParseFloat(v, 64)
-		}
-
-		for i, ln := range leftNumbers {
-			if i >= len(rightNumbers) || ln <= rightNumbers[i] {
-				if i < len(rightNumbers) {
-					return false
-				}
-			}
-		}
-		return true
-	}
-
-	return false
-}
-
-func LessThan(left []interface{}, right []interface{}) bool {
-	leftStrs, ok1 := toStringSlice(left)
-	rightStrs, ok2 := toStringSlice(right)
-	if !ok1 || !ok2 {
-		return false
-	}
-
-	areAllISO := func(arr []string) bool {
-		for _, v := range arr {
-			if !isISO8601(v) {
-				return false
-			}
-		}
-		return true
-	}
-
-	areAllNumbers := func(arr []string) bool {
-		for _, v := range arr {
-			if _, err := strconv.ParseFloat(v, 64); err != nil {
-				return false
-			}
-		}
-		return true
-	}
-
-	if areAllISO(leftStrs) && areAllISO(rightStrs) {
-		leftDates := make([]int64, len(leftStrs))
-		for i, date := range leftStrs {
-			t, _ := time.Parse(time.RFC3339, date)
-			leftDates[i] = t.UnixMilli()
-		}
-
-		rightDates := make([]int64, len(rightStrs))
-		for i, date := range rightStrs {
-			t, _ := time.Parse(time.RFC3339, date)
-			rightDates[i] = t.UnixMilli()
-		}
-
-		for i, ld := range leftDates {
-			if i >= len(rightDates) || ld >= rightDates[i] {
-				if i < len(rightDates) {
-					return false
-				}
-			}
-		}
-		return true
-	} else if areAllNumbers(leftStrs) && areAllNumbers(rightStrs) {
-		leftNumbers := make([]float64, len(leftStrs))
-		for i, v := range leftStrs {
-			leftNumbers[i], _ = strconv.ParseFloat(v, 64)
-		}
-
-		rightNumbers := make([]float64, len(rightStrs))
-		for i, v := range rightStrs {
-			rightNumbers[i], _ = strconv.ParseFloat(v, 64)
-		}
-
-		for i, ln := range leftNumbers {
-			if i >= len(rightNumbers) || ln >= rightNumbers[i] {
-				if i < len(rightNumbers) {
-					return false
-				}
-			}
-		}
-		return true
-	}
-
-	return false
-}
-
-var regexCache sync.Map // cache compiled regexes
-
-func FollowRegex(left []interface{}, regexArray []interface{}) bool {
-	leftStrs, ok1 := toStringSlice(left)
-	regexStrs, ok2 := toStringSlice(regexArray)
-	if !ok1 || !ok2 {
-		return false
-	}
-
-	if len(leftStrs) == 0 && len(regexStrs) != 0 {
-		return false
-	}
-
-	for _, regexStr := range regexStrs {
-		var re *regexp2.Regexp
-		regexStr = sanitizeRegex(regexStr)
-		fmt.Printf("Using regex: %s\n", regexStr)
-		// Check cache first
-		if cached, ok := regexCache.Load(regexStr); ok {
-			re = cached.(*regexp2.Regexp)
-		} else {
-			compiled, err := regexp2.Compile(regexStr, 0)
-			if err != nil {
-				fmt.Printf("Invalid regex '%s': %v\n", regexStr, err)
-				return false
-			}
-			regexCache.Store(regexStr, compiled)
-			re = compiled
-		}
-
-		for _, v := range leftStrs {
-			match, err := re.MatchString(v)
-			if err != nil || !match {
-				return false
-			}
-		}
-	}
-
-	return true
-}
-
-// Only fixes escapes that are invalid in regexp2
-func sanitizeRegex(regex string) string {
-	regex = strings.ReplaceAll(regex, `\_`, `_`) // escaped underscore → literal
-	regex = strings.ReplaceAll(regex, `\-`, `-`) // escaped hyphen → literal
-	return regex
-}
-
-func isISO8601(str string) bool {
-	iso8601Regex, err := regexp2.Compile(`^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$`, 0)
-	if err != nil {
-		return false
-	}
-
-	match, err := iso8601Regex.MatchString(str)
-	if err != nil || !match {
-		return false
-	}
-
-	_, err = time.Parse(time.RFC3339, str)
-	return err == nil
-}
-
-// StringSliceToInterface converts []string to []interface{}
-func StringSliceToInterface(strs []string) []interface{} {
-	result := make([]interface{}, len(strs))
-	for i, v := range strs {
-		result[i] = v
-	}
-	return result
-}
-
-// UnusedFunction to avoid unused variable errors
-func UnusedFunction(item interface{}) {}