ondc-code-generator 0.8.4 → 0.8.6

package/alpha/validPaths.json

@@ -176,73 +176,73 @@
     "$.message.catalog['bpp/fulfillments'][*].contact.phone",
     "$.message.catalog['bpp/fulfillments'][*].contact.email"
   ],
-  "item": [
-    "$.items[*].id",
-    "$.items[*].parent_item_id",
-    "$.items[*].descriptor.name",
-    "$.items[*].descriptor.code",
-    "$.items[*].descriptor.symbol",
-    "$.items[*].descriptor.short_desc",
-    "$.items[*].descriptor.long_desc",
-    "$.items[*].descriptor.images[*]",
-    "$.items[*].descriptor.tags[*].code",
-    "$.items[*].descriptor.tags[*].list[*].code",
-    "$.items[*].descriptor.tags[*].list[*].name",
-    "$.items[*].descriptor.tags[*].list[*].value",
-    "$.items[*].descriptor.additional_desc.content_type",
-    "$.items[*].price.currency",
-    "$.items[*].price.value",
-    "$.items[*].price.maximum_value",
-    "$.items[*].price.tags[*].code",
-    "$.items[*].price.tags[*].list[*].code",
-    "$.items[*].price.tags[*].list[*].name",
-    "$.items[*].price.tags[*].list[*].value",
-    "$.items[*].quantity.available.count",
-    "$.items[*].quantity.maximum.count",
-    "$.items[*].quantity.unitized.count",
-    "$.items[*].quantity.unitized.measure.unit",
-    "$.items[*].quantity.unitized.measure.value",
-    "$.items[*].quantity.count",
-    "$.items[*].category_id",
-    "$.items[*].category_ids[*]",
-    "$.items[*].fulfillment_id",
-    "$.items[*].fulfillment_ids[*]",
-    "$.items[*].replacement_terms[*].replace_within.duration",
-    "$.items[*].rating",
-    "$.items[*].location_id",
-    "$.items[*].time.label",
-    "$.items[*].time.timestamp",
-    "$.items[*].time.range.start",
-    "$.items[*].time.range.end",
-    "$.items[*].time.days",
-    "$.items[*].time.schedule.frequency",
-    "$.items[*].time.schedule.holidays[*]",
-    "$.items[*].time.schedule.times[*]",
-    "$.items[*].related",
-    "$.items[*].recommended",
-    "$.items[*]['@ondc/org/returnable']",
-    "$.items[*]['@ondc/org/seller_pickup_return']",
-    "$.items[*]['@ondc/org/return_window']",
-    "$.items[*]['@ondc/org/cancellable']",
-    "$.items[*]['@ondc/org/time_to_ship']",
-    "$.items[*]['@ondc/org/available_on_cod']",
-    "$.items[*]['@ondc/org/contact_details_consumer_care']",
-    "$.items[*]['@ondc/org/statutory_reqs_packaged_commodities'].common_or_generic_name_of_commodity",
-    "$.items[*]['@ondc/org/statutory_reqs_packaged_commodities'].month_year_of_manufacture_packing_import",
-    "$.items[*]['@ondc/org/statutory_reqs_packaged_commodities'].manufacturer_or_packer_name",
-    "$.items[*]['@ondc/org/statutory_reqs_packaged_commodities'].manufacturer_or_packer_address",
-    "$.items[*]['@ondc/org/statutory_reqs_packaged_commodities'].mfg_license_no",
-    "$.items[*]['@ondc/org/statutory_reqs_packaged_commodities'].multiple_products_name_number_or_qty",
-    "$.items[*]['@ondc/org/statutory_reqs_packaged_commodities'].net_quantity_or_measure_of_commodity_in_pkg",
-    "$.items[*]['@ondc/org/statutory_reqs_packaged_commodities'].expiry_date",
-    "$.items[*]['@ondc/org/statutory_reqs_prepackaged_food'].nutritional_info",
-    "$.items[*]['@ondc/org/statutory_reqs_prepackaged_food'].additives_info",
-    "$.items[*]['@ondc/org/statutory_reqs_prepackaged_food'].brand_owner_FSSAI_license_no",
-    "$.items[*]['@ondc/org/statutory_reqs_prepackaged_food'].other_FSSAI_license_no",
-    "$.items[*]['@ondc/org/statutory_reqs_prepackaged_food'].importer_FSSAI_license_no",
-    "$.items[*].tags[*].code",
-    "$.items[*].tags[*].list[*].code",
-    "$.items[*].tags[*].list[*].name",
-    "$.items[*].tags[*].list[*].value"
+  "items": [
+    "$.id",
+    "$.parent_item_id",
+    "$.descriptor.name",
+    "$.descriptor.code",
+    "$.descriptor.symbol",
+    "$.descriptor.short_desc",
+    "$.descriptor.long_desc",
+    "$.descriptor.images[*]",
+    "$.descriptor.tags[*].code",
+    "$.descriptor.tags[*].list[*].code",
+    "$.descriptor.tags[*].list[*].name",
+    "$.descriptor.tags[*].list[*].value",
+    "$.descriptor.additional_desc.content_type",
+    "$.price.currency",
+    "$.price.value",
+    "$.price.maximum_value",
+    "$.price.tags[*].code",
+    "$.price.tags[*].list[*].code",
+    "$.price.tags[*].list[*].name",
+    "$.price.tags[*].list[*].value",
+    "$.quantity.available.count",
+    "$.quantity.maximum.count",
+    "$.quantity.unitized.count",
+    "$.quantity.unitized.measure.unit",
+    "$.quantity.unitized.measure.value",
+    "$.quantity.count",
+    "$.category_id",
+    "$.category_ids[*]",
+    "$.fulfillment_id",
+    "$.fulfillment_ids[*]",
+    "$.replacement_terms[*].replace_within.duration",
+    "$.rating",
+    "$.location_id",
+    "$.time.label",
+    "$.time.timestamp",
+    "$.time.range.start",
+    "$.time.range.end",
+    "$.time.days",
+    "$.time.schedule.frequency",
+    "$.time.schedule.holidays[*]",
+    "$.time.schedule.times[*]",
+    "$.related",
+    "$.recommended",
+    "$['@ondc/org/returnable']",
+    "$['@ondc/org/seller_pickup_return']",
+    "$['@ondc/org/return_window']",
+    "$['@ondc/org/cancellable']",
+    "$['@ondc/org/time_to_ship']",
+    "$['@ondc/org/available_on_cod']",
+    "$['@ondc/org/contact_details_consumer_care']",
+    "$['@ondc/org/statutory_reqs_packaged_commodities'].common_or_generic_name_of_commodity",
+    "$['@ondc/org/statutory_reqs_packaged_commodities'].month_year_of_manufacture_packing_import",
+    "$['@ondc/org/statutory_reqs_packaged_commodities'].manufacturer_or_packer_name",
+    "$['@ondc/org/statutory_reqs_packaged_commodities'].manufacturer_or_packer_address",
+    "$['@ondc/org/statutory_reqs_packaged_commodities'].mfg_license_no",
+    "$['@ondc/org/statutory_reqs_packaged_commodities'].multiple_products_name_number_or_qty",
+    "$['@ondc/org/statutory_reqs_packaged_commodities'].net_quantity_or_measure_of_commodity_in_pkg",
+    "$['@ondc/org/statutory_reqs_packaged_commodities'].expiry_date",
+    "$['@ondc/org/statutory_reqs_prepackaged_food'].nutritional_info",
+    "$['@ondc/org/statutory_reqs_prepackaged_food'].additives_info",
+    "$['@ondc/org/statutory_reqs_prepackaged_food'].brand_owner_FSSAI_license_no",
+    "$['@ondc/org/statutory_reqs_prepackaged_food'].other_FSSAI_license_no",
+    "$['@ondc/org/statutory_reqs_prepackaged_food'].importer_FSSAI_license_no",
+    "$.tags[*].code",
+    "$.tags[*].list[*].code",
+    "$.tags[*].list[*].name",
+    "$.tags[*].list[*].value"
   ]
 }

package/dist/generator/generators/go/go-generator.js

@@ -82,24 +82,24 @@ export class GoGenerator extends CodeGenerator {
         });
         for (const action of allActions) {
             const loadData = relevantSessionData[action] || {};
+            console.log("Load data for action", action, loadData);
             const saveData = sessionData[action] || {};
             const saveCode = Mustache.render(saveActionTemplate, {
-                storeActions: Object.keys(saveData)
-                    .filter((f) => f !== "_SELF")
-                    .map((key) => {
-                    return {
-                        key: key,
-                        value: saveData[key],
-                    };
-                }),
-                loadActions: Object.keys(loadData)
-                    .filter((f) => f !== "_SELF")
-                    .map((key) => {
-                    console.log(loadData[key]);
-                    return {
-                        key: loadData[key],
-                    };
-                }),
+                storeActions: [
+                    ...new Set(Object.keys(saveData)
+                        .filter((f) => f !== "_SELF")
+                        .map((key) => saveData[key])),
+                ].map((value) => ({
+                    key: Object.keys(saveData).find((k) => saveData[k] === value), // original key
+                    value: value,
+                })),
+                loadActions: [
+                    ...new Set(Object.keys(loadData)
+                        .filter((f) => f !== "_SELF")
+                        .map((key) => loadData[key])),
+                ].map((value) => ({
+                    key: value,
+                })),
                 action: action,
             });
             await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/${action}.go`, saveCode, "go");
@@ -277,7 +277,8 @@ ${importList.map((imp) => `\t${imp}`).join("\n")}
         let elementsList = [];
         // REPLACE ALL special WITH empty AND SPLIT
         if (typeof returnStatement === "string") {
-            elementsList = removeAllSpecialCharacters(returnStatement).split(" ");
+            elementsList =
+                removeAllSpecialCharacters(returnStatement).split(" ");
         }
         if (continueStatement) {
             const contElements = removeAllSpecialCharacters(continueStatement).split(" ");

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

@@ -5,10 +5,85 @@ 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{})
@@ -29,10 +104,30 @@ func isListOfStringsOrNull(variable interface{}) bool {
 
 // 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)
-	output, err := jsonpath.Retrieve(resolvedPath, resolvedData)
+	resolvedPath, resolvedData, err := resolveJSONPathData(path, payload)
 	if err != nil {
-		fmt.Printf("Error retrieving JSONPath %s: %v\n", path, err)
+		// 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{}{}
 	}
 
@@ -48,9 +143,6 @@ func GetJsonPath(payload interface{}, path string, flattenResult bool) []interfa
 		output = flattenSlice(output)
 	}
 
-	if len(output) == 0 {
-		return []interface{}{}
-	}
 	return output
 }
 
@@ -67,17 +159,15 @@ func flattenSlice(slice []interface{}) []interface{} {
 	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")){
+	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
-}
+	}
+	return path, data, nil
+}

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

@@ -5,6 +5,8 @@ package validationutils
 import (
 	"fmt"
 	"strconv"
+	"strings"
+	"sync"
 	"time"
 
 	"github.com/dlclark/regexp2"
@@ -34,7 +36,7 @@ func AreUnique(operand []interface{}) bool {
 	if !ok {
 		return false
 	}
-	
+
 	valuesSet := make(map[string]struct{})
 	for _, v := range strs {
 		valuesSet[v] = struct{}{}
@@ -199,7 +201,7 @@ func EqualTo(left []interface{}, right []interface{}) bool {
 	if !ok1 || !ok2 {
 		return false
 	}
-	
+
 	if len(leftStrs) != len(rightStrs) {
 		return false
 	}
@@ -217,7 +219,7 @@ func GreaterThan(left []interface{}, right []interface{}) bool {
 	if !ok1 || !ok2 {
 		return false
 	}
-	
+
 	areAllISO := func(arr []string) bool {
 		for _, v := range arr {
 			if !isISO8601(v) {
@@ -287,7 +289,7 @@ func LessThan(left []interface{}, right []interface{}) bool {
 	if !ok1 || !ok2 {
 		return false
 	}
-	
+
 	areAllISO := func(arr []string) bool {
 		for _, v := range arr {
 			if !isISO8601(v) {
@@ -351,21 +353,36 @@ func LessThan(left []interface{}, right []interface{}) bool {
 	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 {
-		re, err := regexp2.Compile(regexStr, 0)
-		if err != nil {
-			return false
+		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 {
@@ -373,15 +390,23 @@ func FollowRegex(left []interface{}, regexArray []interface{}) bool {
 			}
 		}
 	}
+
 	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
@@ -401,4 +426,4 @@ func StringSliceToInterface(strs []string) []interface{} {
 }
 
 // UnusedFunction to avoid unused variable errors
-func UnusedFunction(item interface{}) {}
+func UnusedFunction(item interface{}) {}

package/dist/generator/generators/go/templates/validation-utils_test.mustache

@@ -0,0 +1,132 @@
+package validationutils
+
+import "testing"
+
+func TestToStringSlice(t *testing.T) {
+	got, ok := toStringSlice([]interface{}{"a", 10, true, nil})
+	if !ok {
+		t.Fatalf("expected conversion to succeed")
+	}
+	want := []string{"a", "10", "true", "null"}
+	if len(got) != len(want) {
+		t.Fatalf("length mismatch: got=%d want=%d", len(got), len(want))
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("unexpected value at %d: got=%q want=%q", i, got[i], want[i])
+		}
+	}
+}
+
+func TestAreUniqueAndPresent(t *testing.T) {
+	if !AreUnique([]interface{}{"x", "y"}) {
+		t.Fatalf("expected unique slice to pass")
+	}
+	if AreUnique([]interface{}{"x", "x"}) {
+		t.Fatalf("expected duplicate slice to fail")
+	}
+	if !ArePresent([]interface{}{"value"}) {
+		t.Fatalf("expected non-empty non-null values to be present")
+	}
+	if ArePresent([]interface{}{}) || ArePresent([]interface{}{"null"}) || ArePresent([]interface{}{"undefined"}) {
+		t.Fatalf("expected empty/null/undefined slices to fail presence")
+	}
+}
+
+func TestSetComparators(t *testing.T) {
+	tests := []struct {
+		name string
+		fn   func([]interface{}, []interface{}) bool
+		left []interface{}
+		right []interface{}
+		want bool
+	}{
+		{"allin true", AllIn, []interface{}{"a", "b"}, []interface{}{"a", "b", "c"}, true},
+		{"allin false", AllIn, []interface{}{"a", "z"}, []interface{}{"a", "b", "c"}, false},
+		{"anyin true", AnyIn, []interface{}{"x", "b"}, []interface{}{"a", "b", "c"}, true},
+		{"anyin false", AnyIn, []interface{}{"x", "y"}, []interface{}{"a", "b", "c"}, false},
+		{"nonein true", NoneIn, []interface{}{"x", "y"}, []interface{}{"a", "b", "c"}, true},
+		{"nonein false", NoneIn, []interface{}{"x", "b"}, []interface{}{"a", "b", "c"}, false},
+		{"regression empty-left allin false", AllIn, []interface{}{}, []interface{}{"a"}, false},
+		{"regression empty-left anyin false", AnyIn, []interface{}{}, []interface{}{"a"}, false},
+		{"empty-left nonein true", NoneIn, []interface{}{}, []interface{}{"a"}, true},
+		{"map lookup", AllIn, []interface{}{"k1", "k2"}, []interface{}{map[string]interface{}{"k1": 1, "k2": 2}}, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.fn(tt.left, tt.right); got != tt.want {
+				t.Fatalf("unexpected result: got=%v want=%v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestEqualTo(t *testing.T) {
+	if !EqualTo([]interface{}{"1", "2"}, []interface{}{"1", "2"}) {
+		t.Fatalf("expected equal slices to match")
+	}
+	if EqualTo([]interface{}{"1", "2"}, []interface{}{"2", "1"}) {
+		t.Fatalf("expected different-order slices to fail")
+	}
+	if EqualTo([]interface{}{"1"}, []interface{}{"1", "2"}) {
+		t.Fatalf("expected different-length slices to fail")
+	}
+}
+
+func TestGreaterThanAndLessThan(t *testing.T) {
+	if !GreaterThan([]interface{}{"10", "20"}, []interface{}{"1", "2"}) {
+		t.Fatalf("expected numeric greater-than to pass")
+	}
+	if GreaterThan([]interface{}{"1"}, []interface{}{"2"}) {
+		t.Fatalf("expected numeric greater-than to fail")
+	}
+	if !LessThan([]interface{}{"1", "2"}, []interface{}{"10", "20"}) {
+		t.Fatalf("expected numeric less-than to pass")
+	}
+	if LessThan([]interface{}{"2"}, []interface{}{"1"}) {
+		t.Fatalf("expected numeric less-than to fail")
+	}
+
+	leftDates := []interface{}{"2025-01-02T00:00:00Z", "2025-01-03T00:00:00Z"}
+	rightDates := []interface{}{"2025-01-01T00:00:00Z", "2025-01-02T00:00:00Z"}
+	if !GreaterThan(leftDates, rightDates) {
+		t.Fatalf("expected date greater-than to pass")
+	}
+
+	leftOlderDates := []interface{}{"2025-01-01T00:00:00Z", "2025-01-02T00:00:00Z"}
+	rightNewerDates := []interface{}{"2025-01-02T00:00:00Z", "2025-01-03T00:00:00Z"}
+	if !LessThan(leftOlderDates, rightNewerDates) {
+		t.Fatalf("expected date less-than to pass")
+	}
+
+	if GreaterThan([]interface{}{"abc"}, []interface{}{"1"}) || LessThan([]interface{}{"abc"}, []interface{}{"1"}) {
+		t.Fatalf("expected non-comparable values to fail")
+	}
+}
+
+func TestRegexAndISOHelpers(t *testing.T) {
+	if !FollowRegex([]interface{}{"123", "456"}, []interface{}{`^\d+$`}) {
+		t.Fatalf("expected all values to match regex")
+	}
+	if FollowRegex([]interface{}{"123", "abc"}, []interface{}{`^\d+$`}) {
+		t.Fatalf("expected mixed values to fail regex check")
+	}
+	if FollowRegex([]interface{}{"123"}, []interface{}{`[`}) {
+		t.Fatalf("expected invalid regex to fail")
+	}
+
+	if !isISO8601("2025-01-02T03:04:05Z") {
+		t.Fatalf("expected valid RFC3339 timestamp")
+	}
+	if isISO8601("2025-01-02") {
+		t.Fatalf("expected date-only string to fail")
+	}
+}
+
+func TestStringSliceToInterface(t *testing.T) {
+	got := StringSliceToInterface([]string{"a", "b"})
+	if len(got) != 2 || got[0] != "a" || got[1] != "b" {
+		t.Fatalf("unexpected conversion result: %#v", got)
+	}
+}

package/dist/generator/validators/tests-config/sub-validations.js

@@ -129,6 +129,9 @@ export class VariableValidator extends TestObjectValidator {
                     const replaced = replaceBracketsWithAsteriskNested(path);
                     if (this.minimal)
                         return;
+                    // skip validation for paths that include both xinput and data as they are dynamic paths that can't be validated against the schema
+                    if (replaced.includes("xinput") && replaced.includes("data"))
+                        return;
                     if (!this.possibleJsonPaths.includes(replaced)) {
                         throw new Error(`Variable: ${key} should be a jsonPath that returns a array of strings or the path don't exist in the schema, at ${this.validationPath} found original ${path} replaces: ${replaced}`);
                     }

package/package.json

@@ -1,48 +1,48 @@
 {
-	"name": "ondc-code-generator",
-	"version": "0.8.4",
-	"description": "generate code from build.yaml ",
-	"main": "dist/index.js",
-	"type": "module",
-	"bin": {
-		"ondc-code-generator": "dist/bin/cli.js"
-	},
-	"scripts": {
-		"build": "tsc && copyfiles -u 1 \"src/**/*.{yaml,html,css,mustache}\" dist/",
-		"start": "node ./dist/index.js",
-		"test": "npm run build && node ./dist/index.test.js",
-		"dev": "nodemon",
-		"clean": "rm -rf dist",
-		"prepare": "npm run clean && npm run build"
-	},
-	"author": "extedcoud",
-	"license": "MIT",
-	"devDependencies": {
-		"@types/fs-extra": "^11.0.4",
-		"@types/js-yaml": "^4.0.9",
-		"@types/json-schema": "^7.0.15",
-		"@types/jsonpath": "^0.2.4",
-		"@types/mustache": "^4.2.5",
-		"@types/node": "^22.10.1",
-		"copyfiles": "^2.4.1",
-		"esm-loader-typescript": "^1.0.6",
-		"nodemon": "^3.1.7",
-		"ts-node": "^10.9.2",
-		"typescript": "^5.7.2"
-	},
-	"dependencies": {
-		"@apidevtools/json-schema-ref-parser": "^11.7.2",
-		"chalk": "^4.1.2",
-		"chevrotain": "^11.0.3",
-		"commander": "^14.0.2",
-		"fs-extra": "^11.2.0",
-		"js-yaml": "^4.1.0",
-		"json-schema": "^0.4.0",
-		"json-to-yaml-ref": "^1.0.0",
-		"jsonpath": "^1.1.1",
-		"marked": "^15.0.3",
-		"mustache": "^4.2.0",
-		"prettier": "^3.4.2",
-		"winston": "^3.17.0"
-	}
+    "name": "ondc-code-generator",
+    "version": "0.8.6",
+    "description": "generate code from build.yaml ",
+    "main": "dist/index.js",
+    "type": "module",
+    "bin": {
+        "ondc-code-generator": "dist/bin/cli.js"
+    },
+    "scripts": {
+        "build": "tsc && copyfiles -u 1 \"src/**/*.{yaml,html,css,mustache}\" dist/",
+        "start": "node ./dist/index.js",
+        "test": "npm run build && node ./dist/index.test.js",
+        "dev": "nodemon",
+        "clean": "rm -rf dist",
+        "prepare": "npm run clean && npm run build"
+    },
+    "author": "extedcoud",
+    "license": "MIT",
+    "devDependencies": {
+        "@types/fs-extra": "^11.0.4",
+        "@types/js-yaml": "^4.0.9",
+        "@types/json-schema": "^7.0.15",
+        "@types/jsonpath": "^0.2.4",
+        "@types/mustache": "^4.2.5",
+        "@types/node": "^22.10.1",
+        "copyfiles": "^2.4.1",
+        "esm-loader-typescript": "^1.0.6",
+        "nodemon": "^3.1.7",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.7.2"
+    },
+    "dependencies": {
+        "@apidevtools/json-schema-ref-parser": "^11.7.2",
+        "chalk": "^4.1.2",
+        "chevrotain": "^11.0.3",
+        "commander": "^14.0.2",
+        "fs-extra": "^11.2.0",
+        "js-yaml": "^4.1.0",
+        "json-schema": "^0.4.0",
+        "json-to-yaml-ref": "^1.0.0",
+        "jsonpath": "^1.1.1",
+        "marked": "^15.0.3",
+        "mustache": "^4.2.0",
+        "prettier": "^3.4.2",
+        "winston": "^3.17.0"
+    }
 }

package/sample.md

@@ -312,8 +312,7 @@ This document outlines best practices for writing effective JVAL (JSON Validatio
 
 results, runErr := PerformL1_validations(action, payload, cfg, validationutils.ExternalData{
 					"full_ids" : map[string]bool{
-						"test": true,
-						"test2": false,
+						"10102": true,
 					},
 				})