ondc-code-generator 0.7.0 → 0.7.4

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

@@ -0,0 +1,322 @@
+import { readFileSync } from "fs";
+import { CodeGenerator, } from "../classes/abstract-generator.js";
+import path from "path";
+import { fileURLToPath } from "url";
+import Mustache from "mustache";
+import { ConfigSyntax, ExternalDataSyntax, TestObjectSyntax, } from "../../../constants/syntax.js";
+import { writeAndFormatCode } from "../../../utils/fs-utils.js";
+import { collectLoadData } from "../../../utils/config-utils/load-variables.js";
+import { compileInputToGo } from "./go-ast.js";
+import { getVariablesFromTest } from "../../../utils/general-utils/test-object-utils.js";
+import { ConvertArrayToStringGoStyle } from "../../../utils/general-utils/string-utils.js";
+import { markdownMessageGenerator } from "../documentation/markdown-message-generator.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageName = "validationpkg";
+export class GoGenerator extends CodeGenerator {
+    constructor() {
+        super(...arguments);
+        this.generateCode = async (codeConfig) => {
+            this.codeConfig = codeConfig;
+            const jsonPathUtilsCode = readFileSync(path.resolve(__dirname, "./templates/json-path-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 goMod = readFileSync(path.resolve(__dirname, "./templates/go-mod.mustache"), "utf-8");
+            const typesCode = Mustache.render(typesTemplate, {
+                externalData: this.getExternalKeys(),
+            });
+            writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/json_path_utils.go`, jsonPathUtilsCode, "go");
+            writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/validation_utils.go`, validationUtils, "go");
+            writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/test-config.go`, typesCode, "go");
+            writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/json_normalizer.go`, normalizerTemplate, "go");
+            await this.generateValidationCode();
+            await writeAndFormatCode(this.rootPath, `./${packageName}/main-validator.go`, this.generateIndexFile(Object.keys(this.validationConfig[ConfigSyntax.Tests]), codeConfig.codeName), "go");
+            await writeAndFormatCode(this.rootPath, `./${packageName}/go.mod`, goMod, "text");
+            await this.generateSessionDataCode();
+        };
+        this.generateTestFunction = async (testObject) => {
+            const template = readFileSync(path.resolve(__dirname, "./templates/test-object.mustache"), "utf-8");
+            const view = {
+                name: stringToCaps(testObject[TestObjectSyntax.Name]),
+                scopePath: testObject[TestObjectSyntax.Scope] ?? "$",
+                variables: this.createVariablesCode(testObject),
+                hasContinue: testObject[TestObjectSyntax.Continue] ? true : false,
+                skipCheckStatement: testObject[TestObjectSyntax.Continue]
+                    ? compileInputToGo(testObject[TestObjectSyntax.Continue])
+                    : undefined,
+                validationCode: await this.createValidationLogicCode(testObject),
+                successCode: testObject[TestObjectSyntax.SuccessCode] ?? 200,
+                errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
+                testName: testObject[TestObjectSyntax.Name],
+                TEST_OBJECT: `${JSON.stringify(testObject)}`,
+            };
+            return {
+                funcName: testObject[TestObjectSyntax.Name],
+                code: Mustache.render(template, view),
+            };
+        };
+    }
+    async generateSessionDataCode() {
+        if (!this.codeConfig) {
+            throw new Error("Code config is not set");
+        }
+        const sessionData = this.validationConfig[ConfigSyntax.SessionData];
+        const tests = this.validationConfig[ConfigSyntax.Tests];
+        const relevantSessionData = {};
+        collectLoadData(tests, 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 indexTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/index.mustache"), "utf-8");
+        const saveActionTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/api-save.mustache"), "utf-8");
+        const saveActionUtilsTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/api-save-utils.mustache"), "utf-8");
+        const allActions = Object.keys(tests);
+        const indexCode = Mustache.render(indexTemplate, {
+            actions: Array.from(allActions).map((action) => {
+                return { action: action };
+            }),
+            functionName: this.codeConfig.codeName.replace(/[^a-zA-Z0-9_]/g, ""),
+        });
+        for (const action of allActions) {
+            const loadData = relevantSessionData[action] || {};
+            const saveData = sessionData[action] || {};
+            const saveCode = Mustache.render(saveActionTemplate, {
+                storeActions: Object.keys(saveData).map((key) => {
+                    return {
+                        key: key,
+                        value: saveData[key],
+                    };
+                }),
+                loadActions: Object.keys(loadData).map((key) => {
+                    console.log(loadData[key]);
+                    return {
+                        key: loadData[key],
+                    };
+                }),
+                action: action,
+            });
+            await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/${action}.go`, saveCode, "go");
+        }
+        await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/save_utils.go`, sessionDataUtilsTemplate, "go");
+        await writeAndFormatCode(this.rootPath, `./${packageName}/validationutils/storage-interface.go`, storageInterfaceTemplate, "go");
+        await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/index.go`, indexCode, "go");
+        await writeAndFormatCode(this.rootPath, `./${packageName}/storageutils/api_save_utils.go`, saveActionUtilsTemplate, "go");
+    }
+    async generateValidationCode() {
+        const testConfig = this.validationConfig[ConfigSyntax.Tests];
+        for (const key in testConfig) {
+            const testObjects = testConfig[key];
+            const betaConfig = {
+                [TestObjectSyntax.Name]: key + "Validations",
+                [TestObjectSyntax.Return]: testObjects,
+            };
+            const testFunction = await this.generateTestFunction(betaConfig);
+            const apiTestTemplate = readFileSync(path.resolve(__dirname, "./templates/api-tests.mustache"), "utf-8");
+            const finalCode = Mustache.render(apiTestTemplate, {
+                functionCode: testFunction.code,
+                apiName: stringToCaps(key),
+            });
+            await writeAndFormatCode(this.rootPath, `./${packageName}/jsonvalidations/${key}.go`, finalCode, "go");
+        }
+    }
+    generateIndexFile(apis, functionName = "L1Validations") {
+        functionName = functionName.replace(/[^a-zA-Z0-9_]/g, "");
+        let importList = [
+            `"validationpkg/validationutils"`,
+            `"validationpkg/jsonvalidations"`,
+            `"fmt"`,
+            `"encoding/json"`,
+            `"validationpkg/storageutils"`,
+        ];
+        const masterTemplate = readFileSync(path.resolve(__dirname, "./templates/index.mustache"), "utf-8");
+        const masterFunction = `func Perform${functionName}(
+            action string,
+	        payload interface{},
+	        config *validationutils.ValidationConfig,
+	        externalData validationutils.ExternalData,
+            ) ([]validationutils.ValidationOutput, error) {
+                completeConfig := getCompleteConfig(config)
+
+                // Validate stateful requirements
+	            if completeConfig.StateFullValidations {
+                    if completeConfig.Store == nil {
+                        return nil, fmt.Errorf("stateful validations require a storage interface to be provided in the config")
+                    }
+                    if completeConfig.UniqueKey == nil || *completeConfig.UniqueKey == "" {
+                        return nil, fmt.Errorf("stateful validations require a uniqueKey to be provided in the config")
+                    }
+                }
+                        
+                
+                normalizedPayload := validationutils.NormalizeKeys(payload)
+
+                // Set _SELF
+	            externalData.Self = normalizedPayload
+
+                // Load stateful data if needed
+                if completeConfig.StateFullValidations {
+                    loadedData, err := Perform${functionName}Load(action, *completeConfig.UniqueKey, completeConfig.Store)
+                    if err != nil {
+                        return nil, fmt.Errorf("failed to load stateful data: %w", err)
+                    }
+                    // Merge loaded data with external data
+                    externalData = mergeExternalData(loadedData, externalData)
+                }
+
+                // Create validation input
+                input := validationutils.ValidationInput {
+                    Payload:      normalizedPayload,
+                    ExternalData: externalData,
+                    Config:       completeConfig,
+                }
+
+                // Route to action-specific validation
+                switch action {
+                ${apis
+            .map((api) => `
+                case "${api}":
+                    return jsonvalidations.${stringToCaps(api)}_Tests(input)
+                `)
+            .join("\n")}
+                default:
+                    return nil, fmt.Errorf("action not found: %s", action)
+                }
+            }
+
+            // getCompleteConfig returns a complete config with defaults
+func getCompleteConfig(config *validationutils.ValidationConfig) validationutils.ValidationConfig {
+	if config == nil {
+		return validationutils.ValidationConfig{
+			OnlyInvalid:          true,
+			HideParentErrors:     true,
+			StateFullValidations: false,
+			Debug:                false,
+		}
+	}
+
+	// Return copy with defaults for unset fields
+	completeConfig := *config
+	// Go doesn't have a clean way to check if bool was explicitly set,
+	// so we assume false means "use default true" only if it seems intentional
+	// In practice, you might want to use pointers for optional bools
+	return completeConfig
+}
+
+// mergeExternalData merges loaded data with provided external data
+// using JSON marshal/unmarshal for a generic merge strategy.
+// Non-null fields in provided override loaded fields.
+func mergeExternalData(loaded, provided validationutils.ExternalData) validationutils.ExternalData {
+	// Convert to maps
+	loadedBytes, _ := json.Marshal(loaded)
+	providedBytes, _ := json.Marshal(provided)
+	
+	var loadedMap, providedMap map[string]interface{}
+	json.Unmarshal(loadedBytes, &loadedMap)
+	json.Unmarshal(providedBytes, &providedMap)
+	
+	// Merge provided into loaded
+	for key, value := range providedMap {
+		if value != nil {
+			loadedMap[key] = value
+		}
+	}
+	
+	// Convert back
+	var result validationutils.ExternalData
+	mergedBytes, _ := json.Marshal(loadedMap)
+	json.Unmarshal(mergedBytes, &result)
+	
+	return result
+}
+
+var Perform${functionName}Load = storageutils.Perform${functionName}Load
+var Perform${functionName}Save = storageutils.Perform${functionName}Save
+            `;
+        const importCode = `import (
+${importList.map((imp) => `\t${imp}`).join("\n")}
+            )`;
+        return Mustache.render(masterTemplate, {
+            importCode: importCode,
+            masterFunction: masterFunction,
+        });
+    }
+    getExternalKeys() {
+        const apis = Object.keys(this.validationConfig[ConfigSyntax.SessionData]);
+        let result = [];
+        for (const api of apis) {
+            const keys = Object.keys(this.validationConfig[ConfigSyntax.SessionData][api]);
+            for (const key of keys) {
+                result.push({ name: key });
+            }
+        }
+        result = result.filter((v) => v.name !== "_SELF");
+        return result;
+    }
+    createVariablesCode(testObject) {
+        const variables = [];
+        const varNames = getVariablesFromTest(testObject);
+        for (const name of varNames) {
+            const value = testObject[name];
+            const final = typeof value === "string"
+                ? `validationutils.GetJsonPath(testObjMap, "${value}",true)`
+                : ConvertArrayToStringGoStyle(value);
+            variables.push({
+                name: name,
+                value: final,
+            });
+        }
+        return variables;
+    }
+    async createValidationLogicCode(testObject) {
+        const template = readFileSync(path.resolve(__dirname, "./templates/validation-code.mustache"), "utf-8");
+        const skip = testObject[TestObjectSyntax.Continue];
+        const skipList = skip ? [skip] : undefined;
+        if (typeof testObject[TestObjectSyntax.Return] === "string") {
+            const returnStatement = compileInputToGo(testObject[TestObjectSyntax.Return]);
+            let isStateFull = false;
+            for (const k in testObject) {
+                const value = testObject[k];
+                if (typeof value === "string") {
+                    if (value.includes(`${ExternalDataSyntax}.`) &&
+                        !value.includes("_SELF")) {
+                        isStateFull = true;
+                        break;
+                    }
+                }
+            }
+            return Mustache.render(template, {
+                isNested: false,
+                isStateFull: isStateFull,
+                returnStatement: returnStatement,
+                errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
+                errorDescription: this.CreateErrorMarkdown(testObject, skipList),
+                testName: testObject[TestObjectSyntax.Name],
+                TEST_OBJECT: `${JSON.stringify(testObject)}`,
+            });
+        }
+        else {
+            const subObjects = testObject[TestObjectSyntax.Return];
+            const functionCodes = [];
+            for (const subObject of subObjects) {
+                const func = await this.generateTestFunction(subObject);
+                functionCodes.push(func);
+            }
+            const names = functionCodes.map((f) => {
+                return { name: f.funcName };
+            });
+            return Mustache.render(template, {
+                isNested: true,
+                nestedFunctions: functionCodes.map((f) => f.code).join("\n"),
+                names: names,
+                testName: testObject[TestObjectSyntax.Name],
+                TEST_OBJECT: `${JSON.stringify(testObject)}`,
+            });
+        }
+    }
+    CreateErrorMarkdown(testObject, skipList) {
+        return markdownMessageGenerator(testObject[TestObjectSyntax.Return], testObject, testObject[TestObjectSyntax.Name], skipList);
+    }
+}
+function stringToCaps(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/generator/generators/go/templates/api-tests.mustache

@@ -0,0 +1,65 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package jsonvalidations
+
+import (
+    "validationpkg/validationutils"
+	"fmt"
+)
+
+func {{apiName}}_Tests(input validationutils.ValidationInput) ([]validationutils.ValidationOutput, error) {
+	totalResults, err := {{apiName}}Validations(input)
+	if err != nil {
+		return nil, err
+	}
+
+	if !input.Config.Debug {
+		for i := range totalResults {
+			totalResults[i].DebugInfo = nil
+		}
+	}
+
+	if input.Config.HideParentErrors {
+		// Delete results with valid false and no description
+		filtered := make([]validationutils.ValidationOutput, 0)
+		for _, r := range totalResults {
+			if !r.Valid && r.Description == "" {
+				continue
+			}
+			filtered = append(filtered, r)
+		}
+		totalResults = filtered
+	}
+
+	if input.Config.OnlyInvalid {
+		res := make([]validationutils.ValidationOutput, 0)
+		for _, r := range totalResults {
+			if !r.Valid {
+				res = append(res, r)
+			}
+		}
+
+		if len(res) == 0 {
+			// Find the overall test result
+			var targetSuccess *validationutils.ValidationOutput
+			for i := range totalResults {
+				if totalResults[i].TestName == "{{apiName}}Validations" {
+					targetSuccess = &totalResults[i]
+					break
+				}
+			}
+
+			if targetSuccess == nil {
+				panic("Critical: Overall test result not found")
+			}
+
+			return []validationutils.ValidationOutput{*targetSuccess}, nil
+		}
+
+		return res, nil
+	}
+
+	return totalResults, nil
+}
+
+{{{functionCode}}}

package/dist/generator/generators/go/templates/go-mod.mustache

@@ -0,0 +1,3 @@
+module validationpkg
+
+go 1.24.4

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

@@ -0,0 +1,34 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+package main
+
+{{{importCode}}}
+
+// PerformL1Validations performs Level-1 validations against a payload for a given action.
+//
+// Output shape - ValidationOutput is a slice of:
+//   - TestName: string
+//   - Valid: boolean
+//   - Code: number
+//   - Description: *string (optional)
+//   - DebugInfo: *DebugInfo (optional) with FedConfig
+//
+// Config - ValidationConfig (all fields optional):
+//   - OnlyInvalid (default true)
+//   - HideParentErrors (default true)
+//   - Debug (default false)
+//   - StateFullValidations (default false)
+//   - UniqueKey (optional)
+//   - Store (optional)
+//
+// Parameters:
+//   - action: The action name to validate against
+//   - payload: The JSON payload to validate (map[string]interface{} or struct)
+//   - config: Partial ValidationConfig. Merged with defaults
+//   - externalData: Extra data accessible to rules (Self will be set to normalized payload)
+//
+// Returns: []ValidationOutput
+//
+// Example:
+//   results := PerformL1Validations("search", payload, ValidationConfig{OnlyInvalid: false}, ExternalData{})
+//   // results[0] => ValidationOutput{ TestName, Valid, Code, Description, DebugInfo }
+{{{masterFunction}}}

package/dist/generator/generators/go/templates/json-normalizer.mustache

@@ -0,0 +1,155 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+import (
+	"github.com/bytedance/sonic"
+)
+
+// NormalizeKeys normalizes JSON structures so that:
+//   - All objects with the same property name share the union of keys seen anywhere
+//   - All objects inside the same array share the union of keys at that array level
+//   - Missing keys are filled with nil
+func NormalizeKeys(input interface{}) interface{} {
+	// Step 1: Collect templates by property name
+	templatesByPropName := make(map[string]map[string]struct{})
+	collectTemplates(input, templatesByPropName)
+
+	// Step 2: Apply templates and within-array unions
+	return applyTemplates(input, templatesByPropName)
+}
+
+// collectTemplates walks the data structure and collects all keys for each property name
+func collectTemplates(node interface{}, templates map[string]map[string]struct{}) {
+	switch v := node.(type) {
+	case []interface{}:
+		// Recurse into array items
+		for _, item := range v {
+			collectTemplates(item, templates)
+		}
+
+	case map[string]interface{}:
+		// For each property: if it's an object (non-array), record its keys
+		for propName, propValue := range v {
+			if obj, ok := propValue.(map[string]interface{}); ok {
+				// Initialize set for this property name if needed
+				if templates[propName] == nil {
+					templates[propName] = make(map[string]struct{})
+				}
+				// Add all keys from this object to the template
+				for childKey := range obj {
+					templates[propName][childKey] = struct{}{}
+				}
+			}
+			// Recurse into the value
+			collectTemplates(propValue, templates)
+		}
+	}
+}
+
+// applyTemplates applies the collected templates and array-level unions
+func applyTemplates(node interface{}, templates map[string]map[string]struct{}) interface{} {
+	switch v := node.(type) {
+	case []interface{}:
+		// Compute union of keys across all object elements at this array level
+		arrayUnion := make(map[string]struct{})
+		for _, item := range v {
+			if obj, ok := item.(map[string]interface{}); ok {
+				for key := range obj {
+					arrayUnion[key] = struct{}{}
+				}
+			}
+		}
+
+		// Apply union to each array element
+		result := make([]interface{}, len(v))
+		for i, item := range v {
+			if obj, ok := item.(map[string]interface{}); ok {
+				// Create new object with array union keys
+				next := make(map[string]interface{})
+
+				// Copy existing keys
+				for k, val := range obj {
+					next[k] = val
+				}
+
+				// Add missing keys from array union
+				for key := range arrayUnion {
+					if _, exists := next[key]; !exists {
+						next[key] = nil
+					}
+				}
+
+				// Now apply templates per property name for nested objects
+				for propName, propValue := range next {
+					if nestedObj, ok := propValue.(map[string]interface{}); ok {
+						// Align to template for this property name
+						next[propName] = fillFromTemplate(propName, nestedObj, templates)
+					} else {
+						// Recurse for arrays or other structures
+						next[propName] = applyTemplates(propValue, templates)
+					}
+				}
+				result[i] = next
+			} else {
+				// Not an object, just recurse
+				result[i] = applyTemplates(item, templates)
+			}
+		}
+		return result
+
+	case map[string]interface{}:
+		out := make(map[string]interface{})
+		for propName, propValue := range v {
+			if nestedObj, ok := propValue.(map[string]interface{}); ok {
+				// Align object to the template for this property name
+				out[propName] = fillFromTemplate(propName, nestedObj, templates)
+			} else {
+				out[propName] = applyTemplates(propValue, templates)
+			}
+		}
+		return out
+
+	default:
+		// Primitives unchanged
+		return v
+	}
+}
+
+// fillFromTemplate applies the template for a given property name
+func fillFromTemplate(propName string, obj map[string]interface{}, templates map[string]map[string]struct{}) interface{} {
+	// First recurse on children so nested arrays/objects also normalize
+	base := applyTemplates(obj, templates).(map[string]interface{})
+
+	// Get template for this property name
+	template, hasTemplate := templates[propName]
+	if !hasTemplate {
+		return base // No known template keys for this prop
+	}
+
+	// Fill missing keys with nil
+	filled := make(map[string]interface{})
+	for k, v := range base {
+		filled[k] = v
+	}
+	for key := range template {
+		if _, exists := filled[key]; !exists {
+			filled[key] = nil
+		}
+	}
+
+	return filled
+}
+
+// DeepCloneJSON creates a deep clone of a JSON-serializable structure using sonic
+func DeepCloneJSON(v interface{}) interface{} {
+	b, err := sonic.Marshal(v)
+	if err != nil {
+		panic(err) // or handle error
+	}
+	var out interface{}
+	if err := sonic.Unmarshal(b, &out); err != nil {
+		panic(err)
+	}
+	return out
+}

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

@@ -0,0 +1,63 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationutils
+
+import (
+	"github.com/AsaiYusuke/jsonpath"
+)
+
+// isListOfStringsOrNull checks if the variable is a slice containing only strings or nil values
+func isListOfStringsOrNull(variable interface{}) bool {
+	slice, ok := variable.([]interface{})
+	if !ok {
+		return false
+	}
+
+	for _, item := range slice {
+		if item == nil {
+			continue
+		}
+		if _, isString := item.(string); !isString {
+			return false
+		}
+	}
+	return true
+}
+
+// GetJsonPath queries a payload using JSONPath and returns the results
+func GetJsonPath(payload interface{}, path string, flattenResult bool) []interface{} {
+	output, err := jsonpath.Retrieve(path, payload)
+	if err != nil {
+		return []interface{}{}
+	}
+
+	if isListOfStringsOrNull(output) {
+		for i, item := range output {
+			if item == nil {
+				output[i] = "null"
+			}
+		}
+	}
+
+	if flattenResult {
+		output = flattenSlice(output)
+	}
+
+	if len(output) == 0 {
+		return []interface{}{}
+	}
+	return output
+}
+
+// flattenSlice recursively flattens nested slices
+func flattenSlice(slice []interface{}) []interface{} {
+	result := make([]interface{}, 0)
+	for _, item := range slice {
+		if nestedSlice, ok := item.([]interface{}); ok {
+			result = append(result, flattenSlice(nestedSlice)...)
+		} else {
+			result = append(result, item)
+		}
+	}
+	return result
+}