ondc-code-generator 0.6.21 → 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/generator/generators/python/py-generator.js

@@ -194,7 +194,7 @@ export class PythonGenerator extends CodeGenerator {
         for (const name of varNames) {
             const value = testObject[name];
             const final = typeof value === "string"
-                ? `payload_utils["get_json_path"](${testObject[TestObjectSyntax.Name]}_obj, "${value}")`
+                ? `payload_utils["get_json_path"](${testObject[TestObjectSyntax.Name]}_obj, "${value}", True)`
                 : this.convertArrayToStringPython(value);
             variables.push({
                 name: name,

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

@@ -8,13 +8,24 @@ def is_list_of_strings_or_none(value: Any) -> bool:
         and all((v is None) or isinstance(v, str) for v in value)
     )
 
-def get_json_path(payload: Any, path: str) -> List[Any]:
+def flatten_list(lst: List[Any]) -> List[Any]:
+    """Recursively flatten a nested list"""
+    result = []
+    for item in lst:
+        if isinstance(item, list):
+            result.extend(flatten_list(item))
+        else:
+            result.append(item)
+    return result
+
+def get_json_path(payload: Any, path: str, flatten_result: bool = False) -> List[Any]:
     """
     Evaluate a JSONPath against `payload`.
 
     - If the result is a list that contains only strings and/or None,
       convert None -> "null".
     - Return [] when there are no matches.
+    - If flatten_result is True, flatten nested arrays completely.
     """
     expr = parse(path)
     matches = [m.value for m in expr.find(payload)]  # extract raw values
@@ -22,6 +33,10 @@ def get_json_path(payload: Any, path: str) -> List[Any]:
     if is_list_of_strings_or_none(matches):
         matches = ["null" if v is None else v for v in matches]
 
+    # Flatten only if flag is true
+    if flatten_result:
+        matches = flatten_list(matches)
+
     # Explicitly mirror the TS return of [] for no matches
     return matches if len(matches) > 0 else []
 

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

@@ -21,7 +21,7 @@ async def save_function(payload: dict, unique_prefix: str, key: str, path: str,
     if path == "" or key == "_SELF":
         return
     
-    value = get_json_path(payload, path)
+    value = get_json_path(payload, path, True)
     data = {
         "stored_from": "{{action}}_action",
         "key_path": path,

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

@@ -1,17 +1,35 @@
 import jsonpath from "jsonpath";
-function getJsonPath(payload: any, path: string) {
-	let output = jsonpath.query(payload, path);
-	if (isListOfStringsOrNull(output)) {
-		output = output.map((o) => (o === null ? "null" : o));
-	}
-	return output.length === 0 ? [] : output;
-}
+
 function isListOfStringsOrNull(variable: any): boolean {
 	return (
 		Array.isArray(variable) &&
 		variable.every((item) => item === null || typeof item === "string")
 	);
 }
+
+function getJsonPath(
+	payload: any,
+	path: string,
+	flattenResult: boolean = false
+) {
+	let output = jsonpath.query(payload, path);
+
+	if (isListOfStringsOrNull(output)) {
+		output = output.map((o) => {
+			if (o === null) return "null";
+			if (o === null) return "null";
+			return o;
+		});
+	}
+
+	// flatten only if flag is true
+	if (flattenResult) {
+		output = output.flat(Infinity);
+	}
+
+	return output.length === 0 ? [] : output;
+}
+
 export default {
 	getJsonPath,
 };

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

@@ -30,7 +30,7 @@ config: StorageConfig): Promise<void> {
     if(path === "" || key === "_SELF"){
         return;
     }
-    const value = payloadUtils.getJsonPath(payload, path);
+    const value = payloadUtils.getJsonPath(payload, path,true);
     const data = {
         stored_from: "{{action}}_action",
         key_path: path,

package/dist/generator/generators/typescript/ts-generator.js

@@ -182,7 +182,7 @@ export class TypescriptGenerator extends CodeGenerator {
         for (const name of varNames) {
             const value = testObject[name];
             const final = typeof value === "string"
-                ? `payloadUtils.getJsonPath(testObj, "${value}")`
+                ? `payloadUtils.getJsonPath(testObj, "${value}",true)`
                 : ConvertArrayToString(value);
             variables.push({
                 name: name,

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,13 +1,13 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.6.21",
+	"version": "0.7.0",
 	"description": "generate code from build.yaml ",
 	"main": "dist/index.js",
 	"type": "module",
 	"scripts": {
 		"build": "tsc && copyfiles -u 1 \"src/**/*.{yaml,html,css,mustache}\" dist/",
 		"start": "node ./dist/index.js",
-		"test": "npm run build && node ./dist/test.js",
+		"test": "npm run build && node ./dist/index.test.js",
 		"dev": "nodemon",
 		"clean": "rm -rf dist",
 		"prepare": "npm run clean && npm run build"