ondc-code-generator 0.6.22 → 0.7.3

package/dist/bin/cli.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import path from "path";
+import fs from "fs/promises";
+import { fileURLToPath } from "url";
+import { program } from "commander";
+import { ConfigCompiler, SupportedLanguages } from "../index.js";
+import Cli from "./cli-tool.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// interface CLIOptions {
+// 	config: string;
+// 	output: string;
+// 	lang: string;
+// }
+program
+    .name("ondc-code-generator")
+    .description("Ondc Validation Code Generator")
+    .version("0.0.1");
+program
+    .command("ondc-validation-gen")
+    .alias("xval")
+    .option("-c, --config <path>", "Path to build.yaml file")
+    .option("-f, --function-name <name>", "Name of the validation function to generate")
+    .option("-o, --output <directory>", "Output directory for generated code")
+    .option("-l, --lang <language>", "Target programming language (typescript, python, javascript, go)")
+    .description("Generate validation code")
+    .action(async (options) => {
+    const { config, output, lang, functionName } = options;
+    console.log(Cli.title("Ondc Validation Code Generator"));
+    if (!config || !output || !lang) {
+        console.log(Cli.description.error("Please provide all required options: --config, --output, --lang"));
+        process.exit(1);
+    }
+    try {
+        console.log(Cli.description.info(`Generating validation code for language: ${lang}`));
+        const functionName = options.functionName || "L1validations";
+        const language = getSupportedLanguage(lang);
+        const compiler = new ConfigCompiler(language);
+        const buildPath = path.resolve(process.cwd(), config);
+        console.log(Cli.description.info(`Reading build file from ${buildPath}...`));
+        const buildYaml = await fs.readFile(buildPath, "utf-8");
+        console.log(Cli.description.info("Initializing compiler..."));
+        await compiler.initialize(buildYaml);
+        console.log(Cli.description.info("Generating validation code..."));
+        await compiler.generateValidationFromBuild(functionName, output);
+        console.log(Cli.description.success(`Validation code generated successfully in ${output} for language ${lang}`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(Cli.description.error(`Error: ${message}`));
+        process.exit(1);
+    }
+});
+program
+    .command("schema-gen")
+    .alias("schema")
+    .option("-c, --config <path>", "Path to build.yaml file")
+    .option("-o, --output <directory>", "Output directory for generated schema")
+    .option("-f, --format <format>", "Output format (json, yaml,typescript)")
+    .description("Generate L0 schema")
+    .action(async () => {
+    console.log("Schema generation command invoked");
+});
+program.parse();
+function getSupportedLanguage(lang) {
+    switch (lang.toLowerCase()) {
+        case "typescript":
+            return SupportedLanguages.Typescript;
+        case "python":
+            return SupportedLanguages.Python;
+        case "javascript":
+            return SupportedLanguages.Javascript;
+        case "go":
+            return SupportedLanguages.Golang;
+        default:
+            throw new Error(`Unsupported language: ${lang}. Supported languages are: ${getValidLanguageOptions()}`);
+    }
+}
+function getValidLanguageOptions() {
+    return Object.values(SupportedLanguages).join(", ");
+}

package/dist/generator/config-compiler.d.ts

@@ -23,5 +23,6 @@ export declare class ConfigCompiler {
     generateCode: (valConfig: ValidationConfig, codeName?: string, minimal?: boolean, outputPath?: string) => Promise<void>;
     generateL0Schema: (outputPath?: string, type?: "json" | "typescript") => Promise<void>;
     generateValidPaths: () => Promise<Record<string, string[]>>;
+    generateValidationFromBuild: (codeName: string, outputPath: string) => Promise<void>;
 }
 export {};

package/dist/generator/config-compiler.js

@@ -11,6 +11,7 @@ import path from "path";
 import { duplicateVariablesInChildren } from "../utils/config-utils/duplicateVariables.js";
 import { PythonGenerator } from "./generators/python/py-generator.js";
 import { JavascriptGenerator } from "./generators/javascript/js-generator.js";
+import { GoGenerator } from "./generators/go/go-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultConfig = {
@@ -85,6 +86,11 @@ export class ConfigCompiler {
                         codeName: codeName,
                     });
                     break;
+                case SupportedLanguages.Golang:
+                    await new GoGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                        codeName: codeName,
+                    });
+                    break;
                 default:
                     throw new Error("Language not supported");
             }
@@ -123,6 +129,14 @@ export class ConfigCompiler {
             // );
             return this.possibleJsonPaths;
         };
+        this.generateValidationFromBuild = async (codeName, outputPath) => {
+            if (!this.buildData)
+                throw new Error("Build data not initialized");
+            const valConfig = this.buildData["x-validations"];
+            if (!valConfig)
+                throw new Error("No validation config found in build data");
+            await this.generateCode(valConfig, codeName, false, outputPath);
+        };
         this.language = language;
         this.SchemaExtractionService = new SchemaExtractionService();
     }

package/dist/generator/generators/go/go-ast.d.ts

@@ -0,0 +1 @@
+export declare const compileInputToGo: (input: string) => string;

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

@@ -0,0 +1,60 @@
+import { buildAstFromInput } from "../../../services/return-complier/combined.js";
+import { AllIn, AnyIn, AreUnique, EqualTo, FollowRegex, GreaterThan, LessThan, NoneIn, ArePresent, } from "../../../services/return-complier/tokens.js";
+const uniaryFunction = {
+    [AreUnique.LABEL ?? "are unique"]: "AreUnique",
+    [ArePresent.LABEL ?? "are present"]: "ArePresent",
+};
+const binaryFunction = {
+    [AllIn.LABEL ?? "all in"]: "AllIn",
+    [AnyIn.LABEL ?? "any in"]: "AnyIn",
+    [FollowRegex.LABEL ?? "follow regex"]: "FollowRegex",
+    [NoneIn.LABEL ?? "none in"]: "NoneIn",
+    [EqualTo.LABEL ?? "equal to"]: "EqualTo",
+    [GreaterThan.LABEL ?? "greater than"]: "GreaterThan",
+    [LessThan.LABEL ?? "less than"]: "LessThan",
+};
+function getGoOperator(op) {
+    switch (op) {
+        case "&&":
+            return "&&";
+        case "||":
+            return "||";
+        default:
+            return op;
+    }
+}
+function compileToGo(node) {
+    if (node.type === "returnStatement") {
+        const returnNode = node;
+        return compileToGo(returnNode.expression);
+    }
+    if (node.type === "binaryOperator") {
+        const binaryNode = node;
+        const lhs = compileToGo(binaryNode.lhs);
+        const rhs = compileToGo(binaryNode.rhs);
+        return `(${lhs}) ${getGoOperator(binaryNode.operator)} (${rhs})`;
+    }
+    if (node.type === "notOperator") {
+        const notNode = node;
+        const expression = compileToGo(notNode.expression);
+        return `!(${expression})`;
+    }
+    if (node.type === "customUniaryFunction") {
+        const unary = node;
+        const func = uniaryFunction[unary.customFunction];
+        const varName = unary.expression.name;
+        return `validationutils.${func}(${varName})`;
+    }
+    if (node.type === "customBinaryFunction") {
+        const binary = node;
+        const func = binaryFunction[binary.customFunction];
+        const lhs = binary.lhs.name;
+        const rhs = binary.rhs.name;
+        return `validationutils.${func}(${lhs}, ${rhs})`;
+    }
+    throw new Error("Unknown node type");
+}
+export const compileInputToGo = (input) => {
+    const ast = buildAstFromInput(input);
+    return compileToGo(ast);
+};

package/dist/generator/generators/go/go-generator.d.ts

@@ -0,0 +1,13 @@
+import { CodeGenerator, CodeGeneratorProps } from "../classes/abstract-generator.js";
+export declare class GoGenerator extends CodeGenerator {
+    codeConfig: CodeGeneratorProps | undefined;
+    generateSessionDataCode(): Promise<void>;
+    generateValidationCode(): Promise<void>;
+    generateCode: (codeConfig: CodeGeneratorProps) => Promise<void>;
+    private generateIndexFile;
+    private getExternalKeys;
+    private generateTestFunction;
+    private createVariablesCode;
+    private createValidationLogicCode;
+    private CreateErrorMarkdown;
+}

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}}}