ondc-code-generator 0.6.22 → 0.7.0

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

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

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 import { ConfigCompiler } from "./generator/config-compiler.js";
-export { ConfigCompiler };
+import { SupportedLanguages } from "./types/compiler-types.js";
+export { ConfigCompiler, SupportedLanguages };

package/dist/index.js

@@ -1,2 +1,3 @@
 import { ConfigCompiler } from "./generator/config-compiler.js";
-export { ConfigCompiler };
+import { SupportedLanguages } from "./types/compiler-types.js";
+export { ConfigCompiler, SupportedLanguages };

package/dist/index.test.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "fs";
+import { readFileSync, writeFileSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { ConfigCompiler } from "./generator/config-compiler.js";
@@ -12,10 +12,16 @@ const main = async () => {
     const buildYaml = readFileSync(buildPath, "utf-8");
     const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
     await compiler.initialize(buildYaml);
+    const validPaths = await compiler.generateValidPaths();
+    writeFileSync(path.resolve(__dirname, "../alpha/possible-json-paths.json"), JSON.stringify(validPaths, null, 2), "utf-8");
     await compiler.generateCode(valConfig, "L1_validations", false, "./alpha/python/");
     const compilerTy = new ConfigCompiler(SupportedLanguages.Typescript);
     await compilerTy.initialize(buildYaml);
     await compilerTy.generateCode(valConfig, "L1_validations", false, "./alpha/typescript/");
+    await compilerTy.generateL0Schema("./alpha/typescript/L0_schema/");
+    const compilerGo = new ConfigCompiler(SupportedLanguages.Golang);
+    await compilerGo.initialize(buildYaml);
+    await compilerGo.generateCode(valConfig, "L1_validations", false, "./alpha/golang/");
     // JavaScript generation example
     // const compilerJs = new ConfigCompiler(SupportedLanguages.Javascript);
     // await compilerJs.initialize(buildYaml);

package/dist/types/compiler-types.d.ts

@@ -1,5 +1,6 @@
 export declare enum SupportedLanguages {
     Typescript = "typescript",
     Python = "python",
-    Javascript = "javascript"
+    Javascript = "javascript",
+    Golang = "golang"
 }

package/dist/types/compiler-types.js

@@ -3,4 +3,5 @@ export var SupportedLanguages;
     SupportedLanguages["Typescript"] = "typescript";
     SupportedLanguages["Python"] = "python";
     SupportedLanguages["Javascript"] = "javascript";
+    SupportedLanguages["Golang"] = "golang";
 })(SupportedLanguages || (SupportedLanguages = {}));

package/dist/utils/fs-utils.js

@@ -17,6 +17,10 @@ export async function formatCode(code, lang) {
         // Basic Python formatting - clean up extra whitespace and blank lines
         return formatPythonCode(code);
     }
+    if (lang === "go") {
+        // Basic Go formatting - clean up extra whitespace and blank lines
+        return formatGoCode(code);
+    }
     return await prettier.format(code, {
         parser: lang,
         tabWidth: 4,
@@ -57,6 +61,42 @@ function formatPythonCode(code) {
     }
     return cleanedLines.join("\n") + "\n";
 }
+function formatGoCode(code) {
+    // Similar to Python formatting - basic cleanup
+    const lines = code.split("\n");
+    const formattedLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Skip lines that are only whitespace
+        if (line.trim() === "") {
+            // Only add empty line if the previous line wasn't empty
+            if (formattedLines.length > 0 &&
+                formattedLines[formattedLines.length - 1].trim() !== "") {
+                formattedLines.push("");
+            }
+            continue;
+        }
+        // Add the line as-is (preserve existing indentation)
+        formattedLines.push(line);
+    }
+    // Remove multiple consecutive empty lines
+    const cleanedLines = [];
+    let lastWasEmpty = false;
+    for (const line of formattedLines) {
+        const isEmpty = line.trim() === "";
+        if (isEmpty && lastWasEmpty) {
+            continue; // Skip consecutive empty lines
+        }
+        cleanedLines.push(line);
+        lastWasEmpty = isEmpty;
+    }
+    // Remove trailing empty lines
+    while (cleanedLines.length > 0 &&
+        cleanedLines[cleanedLines.length - 1].trim() === "") {
+        cleanedLines.pop();
+    }
+    return cleanedLines.join("\n") + "\n";
+}
 export async function writeAndFormatCode(rootPath, relativeFilePath, content, lang) {
     const formattedCode = await formatCode(content, lang);
     writeFileWithFsExtra(rootPath, relativeFilePath, formattedCode);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.6.22",
+	"version": "0.7.0",
 	"description": "generate code from build.yaml ",
 	"main": "dist/index.js",
 	"type": "module",

package/sample.md

@@ -0,0 +1,273 @@
+# JVAL DSL Best Practices & Naming Conventions
+
+## Overview
+
+This document outlines best practices for writing effective JVAL (JSON Validation Language) configurations for the ONDC Code Generator.
+
+## Naming Conventions
+
+### Test Object Names (`_NAME_`)
+
+- **Use snake_case** for consistency with generated function names
+- **Be descriptive and specific** about what the test validates
+- **Include context** when validating nested objects
+
+```json
+// ✅ Good
+"_NAME_": "validate_context_action_search"
+"_NAME_": "check_provider_locations_present"
+"_NAME_": "verify_payment_settlement_terms"
+
+// ❌ Avoid
+"_NAME_": "test1"
+"_NAME_": "checkAction"
+"_NAME_": "validate"
+```
+
+### Variable Names
+
+- **Use descriptive names** that clearly indicate the data being extracted
+- **Follow snake_case** convention
+- **Include data type hints** when helpful (e.g., `_codes`, `_ids`, `_values`)
+
+```json
+// ✅ Good
+"context_action": "$.context.action",
+"provider_location_codes": "$.message.catalog.providers[*].locations[*].id",
+"settlement_terms": "$.message.order.tags[?(@.descriptor.code=='SETTLEMENT_TERMS')].list[*].code"
+
+// ❌ Avoid
+"var1": "$.context.action",
+"x": "$.message.catalog.providers[*].locations[*].id",
+"data": "$.some.path"
+```
+
+### Test Set Names
+
+- **Use lowercase with underscores** for test set keys
+- **Group by API action** or logical functionality
+- **Be specific about the validation scope**
+
+```json
+// ✅ Good
+"search_validations": [...],
+"on_search_catalog_validations": [...],
+"payment_settlement_checks": [...]
+
+// ❌ Avoid
+"Search": [...],
+"tests": [...],
+"validations": [...]
+```
+
+## JSONPath Best Practices
+
+### Path Structure
+
+- **Always start with `$`** for root-level paths
+- **Use specific filters** instead of broad wildcards when possible
+- **Test paths** with sample data before implementation
+
+```json
+// ✅ Good - Specific filtering
+"settlement_codes": "$.message.order.tags[?(@.descriptor.code=='SETTLEMENT_TERMS')].list[*].code"
+
+// ⚠️ Less optimal - Too broad
+"all_codes": "$.message..code"
+```
+
+### Scoping Strategy
+
+- **Use `_SCOPE_`** to iterate over arrays of objects
+- **Keep variables relative** to the scope when possible
+- **Avoid deep nesting** in scoped validations
+
+```json
+// ✅ Good - Proper scoping
+{
+    "_SCOPE_": "$.message.catalog.providers[*]",
+    "provider_id": "$.id",
+    "location_ids": "$.locations[*].id",
+    "_RETURN_": "provider_id are present && location_ids are present"
+}
+
+// ❌ Avoid - Absolute paths in scope
+{
+    "_SCOPE_": "$.message.catalog.providers[*]",
+    "provider_id": "$.message.catalog.providers[*].id",  // Redundant
+    "_RETURN_": "provider_id are present"
+}
+```
+
+## JVAL Expression Guidelines
+
+### Readability
+
+- **Use parentheses** to clarify complex logic
+- **Break complex expressions** into multiple test objects
+- **Write descriptive variable names** that make expressions self-documenting
+
+```json
+// ✅ Good - Clear logic flow
+"_RETURN_": "(context_action are present) && (context_action all in valid_actions)"
+
+// ✅ Good - Complex logic broken down
+"_RETURN_": [
+    {
+        "_NAME_": "check_required_fields",
+        "context_action": "$.context.action",
+        "message_intent": "$.message.intent",
+        "_RETURN_": "context_action are present && message_intent are present"
+    },
+    {
+        "_NAME_": "validate_action_values",
+        "context_action": "$.context.action",
+        "valid_actions": ["search", "select", "init"],
+        "_RETURN_": "context_action all in valid_actions"
+    }
+]
+```
+
+### Error Handling
+
+- **Always provide `_DESCRIPTION_`** for meaningful error messages
+- **Use consistent error codes** within logical groups
+- **Make descriptions actionable** for developers
+
+```json
+// ✅ Good - Clear, actionable descriptions
+{
+	"_NAME_": "validate_context_action_search",
+	"context_action": "$.context.action",
+	"valid_actions": ["search"],
+	"_ERROR_CODE_": 30001,
+	"_DESCRIPTION_": "context.action must be 'search' for search API calls",
+	"_RETURN_": "context_action all in valid_actions"
+}
+```
+
+## Configuration Structure
+
+### Test Organization
+
+- **Group related validations** in the same test set
+- **Order tests logically** (basic → complex)
+- **Use consistent error code ranges** per validation group
+
+```json
+{
+	"x-validations": {
+		"_TESTS_": {
+			"basic_structure_validations": [
+				// Basic field presence checks first
+			],
+			"business_logic_validations": [
+				// Complex business rules second
+			],
+			"cross_field_validations": [
+				// Inter-field dependency checks last
+			]
+		},
+		"_SESSION_DATA_": {
+			"search": {
+				"transaction_id": "$.context.transaction_id"
+			}
+		}
+	}
+}
+```
+
+## Example: Complete Validation Set
+
+```json
+{
+	"x-validations": {
+		"_TESTS_": {
+			"search_api_validations": [
+				{
+					"_NAME_": "validate_required_context_fields",
+					"context_action": "$.context.action",
+					"context_domain": "$.context.domain",
+					"transaction_id": "$.context.transaction_id",
+					"_ERROR_CODE_": 30001,
+					"_DESCRIPTION_": "Required context fields must be present in search request",
+					"_RETURN_": "context_action are present && context_domain are present && transaction_id are present"
+				},
+				{
+					"_NAME_": "validate_search_action_value",
+					"context_action": "$.context.action",
+					"expected_action": ["search"],
+					"_ERROR_CODE_": 30002,
+					"_DESCRIPTION_": "context.action must be 'search' for search API calls",
+					"_RETURN_": "context_action all in expected_action"
+				},
+				{
+					"_NAME_": "validate_intent_structure",
+					"_SCOPE_": "$.message.intent",
+					"item_descriptor_name": "$.item.descriptor.name",
+					"fulfillment_locations": "$.fulfillment.end.location.area_code",
+					"_ERROR_CODE_": 30003,
+					"_DESCRIPTION_": "Search intent must contain item descriptor and fulfillment location",
+					"_RETURN_": "item_descriptor_name are present || fulfillment_locations are present"
+				}
+			]
+		},
+		"_SESSION_DATA_": {
+			"search": {
+				"transaction_id": "$.context.transaction_id",
+				"domain": "$.context.domain"
+			}
+		}
+	}
+}
+```
+
+## Common Patterns
+
+### Enum Validation
+
+```json
+{
+	"field_value": "$.path.to.field",
+	"allowed_values": ["value1", "value2", "value3"],
+	"_RETURN_": "field_value all in allowed_values"
+}
+```
+
+### Presence Validation
+
+```json
+{
+	"required_fields": ["$.field1", "$.field2", "$.field3"],
+	"_RETURN_": "required_fields are present"
+}
+```
+
+### Uniqueness Validation
+
+```json
+{
+	"_SCOPE_": "$.array.path[*]",
+	"id_values": "$.id",
+	"_RETURN_": "id_values are unique"
+}
+```
+
+### Regex Pattern Validation
+
+```json
+{
+	"email_field": "$.contact.email",
+	"email_pattern": ["^[\\w\\.-]+@[\\w\\.-]+\\.[a-zA-Z]{2,}$"],
+	"_RETURN_": "email_field follow regex email_pattern"
+}
+```
+
+## Anti-Patterns to Avoid
+
+1. **Generic variable names** like `var1`, `data`, `temp`
+2. **Overly complex single expressions** - break into multiple tests instead
+3. **Missing error descriptions** - always provide meaningful messages
+4. **Inconsistent naming** - stick to snake_case throughout
+5. **Hard-coded values in expressions** - use variables for maintainability
+6. **Too broad JSONPath selectors** - be as specific as possible