ondc-code-generator 0.6.22 → 0.7.3

package/dist/generator/generators/go/templates/test-object.mustache

@@ -0,0 +1,52 @@
+var {{name}} = func (input validationutils.ValidationInput) ([]validationutils.ValidationOutput, error) {
+    scope := validationutils.GetJsonPath(input.Payload,"{{{scopePath}}}",true)
+    
+    subResults := make([]validationutils.ValidationOutput, 0)
+    valid := true
+    configureDebugInfo := ""
+    for _, testObj := range scope {
+        testObjMap, ok := validationutils.DeepCloneJSON(testObj).(map[string]interface{})
+        if !ok {
+            return nil, fmt.Errorf("Invalid object structure in scope for test {{name}}")
+        }
+
+        testObjMap["_EXTERNAL"] = validationutils.DeepCloneJSON(input.ExternalData)
+        
+        {{#variables}}
+        {{name}} := {{{value}}}
+        validationutils.UnusedFunction({{name}})
+        {{/variables}}
+
+        {{#hasContinue}}
+        skipCheck := {{{skipCheckStatement}}}
+        if( skipCheck ) {
+            continue
+        }
+        {{/hasContinue}}
+
+        {{{validationCode}}}
+
+        delete(testObjMap, "_EXTERNAL")
+    }
+    
+    result := validationutils.ValidationOutput{
+        TestName: "{{name}}",
+        Valid: valid,
+        Code: 0,
+        DebugInfo: &validationutils.DebugInfo{
+            FedConfig: configureDebugInfo,
+        },
+    }
+
+    if valid {
+		result.Code = {{successCode}}
+	} else {
+		result.Code = {{errorCode}}
+	}
+
+	results := make([]validationutils.ValidationOutput, 0, len(subResults)+1)
+	results = append(results, result)
+	results = append(results, subResults...)
+
+	return results,nil
+}

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

@@ -0,0 +1,66 @@
+
+
+{{#isNested}}
+
+{{{nestedFunctions}}}
+
+var testFunctions = validationutils.TestFunctionArray{
+    {{#names}}
+    {{name}},
+    {{/names}}
+}
+
+allResults := make([]validationutils.ValidationOutput, 0)
+
+for _, testFunc := range testFunctions {
+    results, err := testFunc(input)
+    if err != nil {
+        return nil, err
+    }
+    allResults = append(allResults, results...)
+}
+
+subResults = allResults
+// if all subResults are valid, then valid is true
+valid = true
+for _, res := range subResults {
+    if !res.Valid {
+        valid = false
+        break
+    }
+}
+
+configureDebugInfo = `NESTED_TEST_OBJECT`
+
+{{/isNested}}
+
+{{^isNested}}
+
+{{#isStateFull}}
+    validate := true
+    if( input.Config.StateFullValidations == false ) {
+        validate = {{{returnStatement}}}
+    }
+{{/isStateFull}}
+
+{{^isStateFull}}
+    validate := {{{returnStatement}}}
+{{/isStateFull}}
+
+configureDebugInfo = `{{{TEST_OBJECT}}}`
+
+if(!validate){
+    result := validationutils.ValidationOutput{
+        TestName: "{{testName}}",
+        Valid: false,
+        Code: {{errorCode}},
+        Description: `{{{errorDescription}}}`,
+        DebugInfo: &validationutils.DebugInfo{
+            FedConfig: configureDebugInfo,
+        },
+    }
+    delete(testObjMap, "_EXTERNAL")
+    return []validationutils.ValidationOutput{result},nil
+}
+
+{{/isNested}}

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

@@ -0,0 +1,321 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+import (
+	"fmt"
+	"strconv"
+	"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
+}
+
+func AllIn(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	rightStrs, ok2 := toStringSlice(right)
+	if !ok1 || !ok2 {
+		return false
+	}
+	
+	if len(leftStrs) == 0 && len(rightStrs) != 0 {
+		return false
+	}
+	for _, v := range leftStrs {
+		if !contains(rightStrs, v) {
+			return false
+		}
+	}
+	return true
+}
+
+func AnyIn(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	rightStrs, ok2 := toStringSlice(right)
+	if !ok1 || !ok2 {
+		return false
+	}
+	
+	if len(leftStrs) == 0 && len(rightStrs) != 0 {
+		return false
+	}
+	for _, v := range leftStrs {
+		if contains(rightStrs, v) {
+			return true
+		}
+	}
+	return false
+}
+
+func NoneIn(left []interface{}, right []interface{}) bool {
+	leftStrs, ok1 := toStringSlice(left)
+	rightStrs, ok2 := toStringSlice(right)
+	if !ok1 || !ok2 {
+		return false
+	}
+	
+	for _, v := range leftStrs {
+		if contains(rightStrs, 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
+}
+
+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
+		}
+		for _, v := range leftStrs {
+			match, err := re.MatchString(v)
+			if err != nil || !match {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+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
+}
+
+func contains(slice []string, item string) bool {
+	for _, v := range slice {
+		if v == item {
+			return true
+		}
+	}
+	return false
+}
+
+// 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{}) {}

package/dist/generator/generators/typescript/templates/index.mustache

@@ -30,4 +30,4 @@
  * // e.g. out[0] => { testName, valid, code, description?, _debugInfo? }
  * ```
  */
- {{{masterFunction}}}
+{{{masterFunction}}}

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

@@ -89,7 +89,7 @@ export class TypescriptGenerator extends CodeGenerator {
         this.generateCode = async (codeConfig) => {
             this.codeConfig = codeConfig;
             const jsonPathUtilsCode = readFileSync(path.resolve(__dirname, "./templates/json-path-utils.mustache"), "utf-8");
-            const validtionUtils = readFileSync(path.resolve(__dirname, "./templates/validation-utils.mustache"), "utf-8");
+            const validationUtils = readFileSync(path.resolve(__dirname, "./templates/validation-utils.mustache"), "utf-8");
             const typesTemplate = readFileSync(path.resolve(__dirname, "./templates/test-config.mustache"), "utf-8");
             const normalizerTemplate = readFileSync(path.resolve(__dirname, "./templates/json-normalizer.mustache"), "utf-8");
             const typesCode = Mustache.render(typesTemplate, {
@@ -97,7 +97,7 @@ export class TypescriptGenerator extends CodeGenerator {
             });
             writeAndFormatCode(this.rootPath, "./utils/json-path-utils.ts", jsonPathUtilsCode, "typescript");
             writeAndFormatCode(this.rootPath, "./utils/json-normalizer.ts", normalizerTemplate, "typescript");
-            writeAndFormatCode(this.rootPath, "./utils/validation-utils.ts", validtionUtils, "typescript");
+            writeAndFormatCode(this.rootPath, "./utils/validation-utils.ts", validationUtils, "typescript");
             writeAndFormatCode(this.rootPath, "./types/test-config.ts", typesCode, "typescript");
             await this.generateValidationCode();
             await writeAndFormatCode(this.rootPath, "error.ts", this.generateErrorFile(this.errorCodes), "typescript");

package/dist/index.d.ts

@@ -1,2 +1,8 @@
 import { ConfigCompiler } from "./generator/config-compiler.js";
-export { ConfigCompiler };
+import { SupportedLanguages } from "./types/compiler-types.js";
+export { ConfigCompiler, SupportedLanguages };
+declare const _default: {
+    ConfigCompiler: typeof ConfigCompiler;
+    SupportedLanguages: typeof SupportedLanguages;
+};
+export default _default;

package/dist/index.js

@@ -1,2 +1,7 @@
 import { ConfigCompiler } from "./generator/config-compiler.js";
-export { ConfigCompiler };
+import { SupportedLanguages } from "./types/compiler-types.js";
+export { ConfigCompiler, SupportedLanguages };
+export default {
+    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,17 @@ 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/");
+    await compilerTy.generateL0Schema("./alpha/json/", "json");
+    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/build.d.ts

@@ -1,3 +1,4 @@
+import { ValidationConfig } from "./config-types";
 import { ErrorDefinition } from "./error-codes";
 export interface Xattributes {
     [key: string]: AttributeSet;
@@ -45,4 +46,5 @@ export interface BUILD_TYPE {
     "x-errorcodes": {
         code: ErrorDefinition[];
     };
+    "x-validations"?: ValidationConfig;
 }

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

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

package/dist/types/compiler-types.js

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

package/dist/utils/fs-utils.d.ts

@@ -1,3 +1,4 @@
 export declare function writeFileWithFsExtra(rootPath: string, relativeFilePath: string, content: string): void;
 export declare function formatCode(code: string, lang: string): Promise<string>;
+export declare function formatGo(code: string): string;
 export declare function writeAndFormatCode(rootPath: string, relativeFilePath: string, content: string, lang: string): Promise<void>;

package/dist/utils/fs-utils.js

@@ -2,6 +2,7 @@ import fs from "fs-extra";
 import * as path from "path";
 import prettier from "prettier";
 import logger from "./logger.js";
+import { spawnSync } from "node:child_process";
 export function writeFileWithFsExtra(rootPath, relativeFilePath, content) {
     // Resolve the full file path
     const filePath = path.resolve(rootPath, relativeFilePath);
@@ -17,6 +18,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 formatGo(code);
+    }
     return await prettier.format(code, {
         parser: lang,
         tabWidth: 4,
@@ -57,7 +62,26 @@ function formatPythonCode(code) {
     }
     return cleanedLines.join("\n") + "\n";
 }
+export function formatGo(code) {
+    // return code;
+    const result = spawnSync("gofmt", [], {
+        input: code,
+        encoding: "utf8",
+        // stdio: "inherit",
+        maxBuffer: 10 * 1024 * 1024, // 10MB (default is 200KB)
+    });
+    if (result.error) {
+        // throw result.error;
+        return code; // If gofmt is not available, return the original code
+    }
+    if (result.status !== 0) {
+        // throw new Error(result.stderr);
+        return code; // If gofmt fails, return the original code
+    }
+    return result.stdout;
+}
 export async function writeAndFormatCode(rootPath, relativeFilePath, content, lang) {
+    // console.log(`Formatting and writing file: ${relativeFilePath}`);
     const formattedCode = await formatCode(content, lang);
     writeFileWithFsExtra(rootPath, relativeFilePath, formattedCode);
 }

package/dist/utils/general-utils/string-utils.d.ts

@@ -25,4 +25,5 @@ export declare function ConvertArrayToStringsInTestObject(testObject: TestObject
     _DESCRIPTION_?: string;
 };
 export declare function ConvertArrayToString(arr: any[]): string;
+export declare function ConvertArrayToStringGoStyle(arr: any[]): string;
 export declare function addTabToMarkdown(markdown: string): string;

package/dist/utils/general-utils/string-utils.js

@@ -61,6 +61,17 @@ export function ConvertArrayToString(arr) {
     values = values.replace(/\\\\\\/g, "\\");
     return values;
 }
+export function ConvertArrayToStringGoStyle(arr) {
+    for (const a of arr) {
+        if (typeof a !== "string") {
+            console.log(arr);
+            throw new Error(`Array contains non-string element: ${a}`);
+        }
+    }
+    let values = arr.map((v) => `\`${v}\``).join(", ");
+    values = values.replace(/\\\\/g, "\\");
+    return `validationutils.StringSliceToInterface([]string{${values}})`;
+}
 export function addTabToMarkdown(markdown) {
     // Split the markdown into lines, add a tab to each line, and rejoin
     return markdown

package/package.json

@@ -1,9 +1,12 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.6.22",
+	"version": "0.7.3",
 	"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",
@@ -31,6 +34,7 @@
 		"@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",