ondc-code-generator 0.8.0 → 0.8.2

package/dist/generator/config-compiler.js

@@ -58,43 +58,54 @@ export class ConfigCompiler {
         };
         // };
         this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./", absolutePath = false) => {
-            valConfig = JSON.parse(JSON.stringify(valConfig));
-            if (this.generatorConfig?.duplicateVariablesInChildren) {
-                valConfig = duplicateVariablesInChildren(valConfig);
-            }
-            if (minimal) {
-                await this.withMinimalValidations(valConfig);
-            }
-            else {
-                await this.performValidations(valConfig);
+            try {
+                console.log("[ CODE GENERATION ] Starting code generation...");
+                valConfig = JSON.parse(JSON.stringify(valConfig));
+                if (this.generatorConfig?.duplicateVariablesInChildren) {
+                    valConfig = duplicateVariablesInChildren(valConfig);
+                }
+                if (minimal) {
+                    await this.withMinimalValidations(valConfig);
+                }
+                else {
+                    await this.performValidations(valConfig);
+                }
+                // Generate code based on the language
+                const targetPath = absolutePath
+                    ? outputPath
+                    : `${outputPath}generated/${codeName}`;
+                switch (this.language) {
+                    case SupportedLanguages.Typescript:
+                        await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                            codeName: codeName,
+                        });
+                        break;
+                    case SupportedLanguages.Python:
+                        await new PythonGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                            codeName: codeName,
+                        });
+                        break;
+                    case SupportedLanguages.Javascript:
+                        await new JavascriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                            codeName: codeName,
+                        });
+                        break;
+                    case SupportedLanguages.Golang:
+                        await new GoGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                            codeName: codeName,
+                        });
+                        break;
+                    default:
+                        throw new Error("Language not supported");
+                }
+                console.log("[ CODE GENERATION ] Code generation completed successfully.");
             }
-            // Generate code based on the language
-            const targetPath = absolutePath
-                ? outputPath
-                : `${outputPath}generated/${codeName}`;
-            switch (this.language) {
-                case SupportedLanguages.Typescript:
-                    await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
-                        codeName: codeName,
-                    });
-                    break;
-                case SupportedLanguages.Python:
-                    await new PythonGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
-                        codeName: codeName,
-                    });
-                    break;
-                case SupportedLanguages.Javascript:
-                    await new JavascriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
-                        codeName: codeName,
-                    });
-                    break;
-                case SupportedLanguages.Golang:
-                    await new GoGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
-                        codeName: codeName,
-                    });
-                    break;
-                default:
-                    throw new Error("Language not supported");
+            catch (e) {
+                console.error(`\n [ CODE GENERATION ERROR ] ${e?.message || e}\n`);
+                if (e?.stack) {
+                    console.error("Stack trace:");
+                    console.error(e.stack);
+                }
             }
         };
         this.generateL0Schema = async (outputPath = "./", type = "typescript", absolutePath = false) => {

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

@@ -82,13 +82,17 @@ export class GoGenerator extends CodeGenerator {
             const loadData = relevantSessionData[action] || {};
             const saveData = sessionData[action] || {};
             const saveCode = Mustache.render(saveActionTemplate, {
-                storeActions: Object.keys(saveData).map((key) => {
+                storeActions: Object.keys(saveData)
+                    .filter((f) => f !== "_SELF")
+                    .map((key) => {
                     return {
                         key: key,
                         value: saveData[key],
                     };
                 }),
-                loadActions: Object.keys(loadData).map((key) => {
+                loadActions: Object.keys(loadData)
+                    .filter((f) => f !== "_SELF")
+                    .map((key) => {
                     console.log(loadData[key]);
                     return {
                         key: loadData[key],
@@ -159,7 +163,7 @@ export class GoGenerator extends CodeGenerator {
                 normalizedPayload := validationutils.NormalizeKeys(payload)
 
                 // Set _SELF
-	            externalData.Self = normalizedPayload
+	            externalData["_SELF"] = normalizedPayload
 
                 // Load stateful data if needed
                 if completeConfig.StateFullValidations {
@@ -256,7 +260,8 @@ ${importList.map((imp) => `\t${imp}`).join("\n")}
         for (const api of apis) {
             const keys = Object.keys(this.validationConfig[ConfigSyntax.SessionData][api]);
             for (const key of keys) {
-                result.push({ name: key });
+                const goVarName = key;
+                result.push({ name: key, keyName: goVarName });
             }
         }
         result = result.filter((v) => v.name !== "_SELF");
@@ -287,7 +292,9 @@ ${importList.map((imp) => `\t${imp}`).join("\n")}
             }
             let final = "";
             if (value.includes("_EXTERNAL")) {
-                final = `validationutils.GetJsonPath(input, "${value}",true)`;
+                // $._EXTERNAL.some.path -> $.some.path
+                const converted = value.replace("$._EXTERNAL", "$");
+                final = `validationutils.GetJsonPath(input.ExternalData, "${converted}",true)`;
             }
             else {
                 final =

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

@@ -73,7 +73,7 @@ func resolveJSONPathData(path string, data interface{}) (string, interface{}, er
     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
+            return resolvedPath, input.ExternalData["_SELF"], nil
         }else if( strings.HasPrefix(path, "$._EXTERNAL")){
 			resolvedPath := strings.Replace(path, "$._EXTERNAL", "$", 1)
 			return resolvedPath, input.ExternalData, nil

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

@@ -35,7 +35,7 @@ func LoadFor_{{action}}(
 	if err != nil {
 		return result, fmt.Errorf("failed to load key {{{key}}}: %w", err)
 	}
-	result.{{{key}}} = {{{key}}}_value
+	result["{{{key}}}"] = {{{key}}}_value
 	{{/loadActions}}
 	
 	fmt.Printf("Loaded external data for action {{action}}: %+v\n", result)

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

@@ -43,13 +43,22 @@ type DebugInfo struct {
 	FedConfig interface{} `json:"fedConfig"`
 }
 
-// ExternalData holds external data references for validation
-type ExternalData struct {
-	Self interface{} `json:"_SELF,omitempty"`
-    {{#externalData}}
-    {{name}} []string `json:"{{name}},omitempty"`
-    {{/externalData}}
-}
+// ExternalData holds external data references for validation as a map structure.
+//
+// Expected keys:
+//   - "_SELF": (interface{}) The current validation context object
+{{#externalData}}
+//   - "{{name}}": (any) {{keyName}} data reference
+{{/externalData}}
+//
+// Example usage:
+//   data := ExternalData{
+//       "_SELF": currentObject,
+{{#externalData}}
+//       "{{name}}": {{keyName}}Value,
+{{/externalData}}
+//   }
+type ExternalData = map[string]interface{}
 
 // ValidationInput represents the input data for validation functions
 type ValidationInput struct {

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

@@ -50,18 +50,102 @@ func ArePresent(operand []interface{}) bool {
 	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)
-	rightStrs, ok2 := toStringSlice(right)
-	if !ok1 || !ok2 {
+	if !ok1 {
 		return false
 	}
-	
-	if len(leftStrs) == 0 && len(rightStrs) != 0 {
+
+	rightLookup, ok2 := createLookup(right)
+	if !ok2 {
 		return false
 	}
+
+	if len(leftStrs) == 0 && !rightLookup.isEmpty() {
+		return false
+	}
+
 	for _, v := range leftStrs {
-		if !contains(rightStrs, v) {
+		if !rightLookup.contains(v) {
 			return false
 		}
 	}
@@ -70,16 +154,21 @@ func AllIn(left []interface{}, right []interface{}) bool {
 
 func AnyIn(left []interface{}, right []interface{}) bool {
 	leftStrs, ok1 := toStringSlice(left)
-	rightStrs, ok2 := toStringSlice(right)
-	if !ok1 || !ok2 {
+	if !ok1 {
 		return false
 	}
-	
-	if len(leftStrs) == 0 && len(rightStrs) != 0 {
+
+	rightLookup, ok2 := createLookup(right)
+	if !ok2 {
 		return false
 	}
+
+	if len(leftStrs) == 0 && !rightLookup.isEmpty() {
+		return false
+	}
+
 	for _, v := range leftStrs {
-		if contains(rightStrs, v) {
+		if rightLookup.contains(v) {
 			return true
 		}
 	}
@@ -88,19 +177,22 @@ func AnyIn(left []interface{}, right []interface{}) bool {
 
 func NoneIn(left []interface{}, right []interface{}) bool {
 	leftStrs, ok1 := toStringSlice(left)
-	rightStrs, ok2 := toStringSlice(right)
-	if !ok1 || !ok2 {
+	if !ok1 {
 		return false
 	}
-	
+
+	rightLookup, ok2 := createLookup(right)
+	if !ok2 {
+		return false
+	}
+
 	for _, v := range leftStrs {
-		if contains(rightStrs, v) {
+		if rightLookup.contains(v) {
 			return false
 		}
 	}
 	return true
 }
-
 func EqualTo(left []interface{}, right []interface{}) bool {
 	leftStrs, ok1 := toStringSlice(left)
 	rightStrs, ok2 := toStringSlice(right)
@@ -299,15 +391,6 @@ func isISO8601(str string) bool {
 	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))

package/dist/generator/generators/python/py-generator.js

@@ -23,7 +23,6 @@ export class PythonGenerator extends CodeGenerator {
             const tests = this.validationConfig[ConfigSyntax.Tests];
             const relevantSessionData = {};
             collectLoadData(tests, relevantSessionData);
-            console.log("Relevant Session Data for Loading:", relevantSessionData);
             const sessionDataUtilsTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/save-utils.mustache"), "utf-8");
             const storageInterfaceTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-interface.mustache"), "utf-8");
             const storageTypesTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-types.mustache"), "utf-8");

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

@@ -24,8 +24,6 @@ export class TypescriptGenerator extends CodeGenerator {
             const tests = this.validationConfig[ConfigSyntax.Tests];
             const relevantSessionData = {};
             collectLoadData(tests, relevantSessionData);
-            console.log("Relevant Session Data for Loading:", relevantSessionData);
-            const actions = Object.keys(sessionData);
             const sessionDataUtilsTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/save-utils.mustache"), "utf-8");
             const storageInterfaceTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-interface.mustache"), "utf-8");
             const storageTypesTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-types.mustache"), "utf-8");

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

@@ -119,7 +119,12 @@ export class VariableValidator extends TestObjectValidator {
                     if (this.targetObject[TestObjectSyntax.Scope]) {
                         const scope = this.targetObject[TestObjectSyntax.Scope];
                         const pathWithoutDollar = cleanseDollarDot(path);
-                        path = `${scope}.${pathWithoutDollar}`;
+                        if (pathWithoutDollar.startsWith("[")) {
+                            path = `${scope}${pathWithoutDollar}`;
+                        }
+                        else {
+                            path = `${scope}.${pathWithoutDollar}`;
+                        }
                     }
                     const replaced = replaceBracketsWithAsteriskNested(path);
                     if (this.minimal)
@@ -153,6 +158,12 @@ export class VariableValidator extends TestObjectValidator {
         if (!definedExternalValues.includes(externalData)) {
             throw new Error(`${externalData} is not defined in ${ConfigSyntax.SessionData} data at path ${this.validationPath}`);
         }
+        if (!path.includes("_SELF")) {
+            if (this.targetObject[TestObjectSyntax.Description] === undefined ||
+                this.targetObject[TestObjectSyntax.Description] === "") {
+                throw new Error(`Variable with path: ${path} is using external data but ${TestObjectSyntax.Description} is not provided at path ${this.validationPath}`);
+            }
+        }
     }
 }
 export class ContinueValidator extends TestObjectValidator {
@@ -204,10 +215,10 @@ export class ReturnValidator extends TestObjectValidator {
 }
 function cleanseDollarDot(path) {
     if (path.startsWith(`$.`)) {
-        return path.slice(2);
+        return path.slice(2).trim();
     }
     else if (path.startsWith(`$`)) {
-        return path.slice(1);
+        return path.slice(1).trim();
     }
-    return path;
+    return path.trim();
 }

package/package.json

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

package/sample.md

@@ -271,3 +271,50 @@ This document outlines best practices for writing effective JVAL (JSON Validatio
 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
+
+## some complex test examples
+
+```json
+{
+	"_NAME_": "ITEMS_RETURNABLE",
+	"_SCOPE_": "$.message.catalog['bpp/providers'][*].items[*]",
+	"typeCode": "$.tags[?(@.code=='type')].list[*].code",
+	"typeValue": "$.tags[?(@.code=='type')].list[*].value",
+	"validCode": ["type"],
+	"valueValue": ["customization"],
+	"attr": "$['@ondc/org/returnable']",
+	"_CONTINUE_": "validCode all in typeCode && valueValue all in typeValue",
+	"_RETURN_": "attr are present"
+}
+```
+
+```json
+{
+	"_TESTS_": {
+		"search": [
+			{
+				"_NAME_": "sample_testing",
+				"ids": "$._EXTERNAL.full_ids",
+				"var1": "$.context.domain",
+				"_RETURN_": "var1 all in ids"
+			}
+		]
+	},
+	"_SESSION_DATA_": {
+		"search": {
+			"full_ids": null
+		}
+	}
+}
+```
+
+```go
+
+results, runErr := PerformL1_validations(action, payload, cfg, validationutils.ExternalData{
+					"full_ids" : map[string]bool{
+						"test": true,
+						"test2": false,
+					},
+				})
+
+```