ondc-code-generator 0.7.4 → 0.7.5

package/dist/bin/cli.js

@@ -80,6 +80,34 @@ program
         process.exit(1);
     }
 });
+program
+    .command("extract-payloads")
+    .alias("ext-payloads")
+    .description("Extract sample payloads from build.yaml")
+    .option("-c, --config <path>", "Path to build.yaml file")
+    .option("-o, --output <directory>", "Output directory for extracted payloads")
+    .action(async (options) => {
+    console.log(Cli.title("Ondc Sample Payload Extractor"));
+    try {
+        const { config, output } = options;
+        if (!config || !output) {
+            console.log(Cli.description.error("Please provide all required options: --config, --output"));
+            process.exit(1);
+        }
+        console.log(Cli.description.info(`Extracting sample payloads...`));
+        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");
+        const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
+        await compiler.initialize(buildYaml);
+        await compiler.extractPayloadsFromBuild(output);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(Cli.description.error(`Error: ${message}`));
+        process.exit(1);
+    }
+});
 program.parse();
 function getSupportedLanguage(lang) {
     switch (lang.toLowerCase()) {

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

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

package/dist/generator/config-compiler.js

@@ -1,5 +1,5 @@
 import { loadAndDereferenceYaml } from "../utils/config-utils/yaml.js";
-import { SchemaExtactionService as SchemaExtractionService } from "../services/schema-service.js";
+import { ExtractionService as SchemaExtractionService } from "../services/schema-service.js";
 import { SupportedLanguages } from "../types/compiler-types.js";
 import { TypescriptGenerator } from "./generators/typescript/ts-generator.js";
 import { ConfigValidator } from "./validators/config-validator.js";
@@ -141,6 +141,11 @@ export class ConfigCompiler {
                 throw new Error("No validation config found in build data");
             await this.generateCode(valConfig, codeName, false, outputPath, absolutePath);
         };
+        this.extractPayloadsFromBuild = async (outputPath) => {
+            if (!this.buildData)
+                throw new Error("Build data not initialized");
+            const payloads = this.SchemaExtractionService.extractPayloadExamples(this.buildData);
+        };
         this.language = language;
         this.SchemaExtractionService = new SchemaExtractionService();
     }

package/dist/generator/generators/classes/abstract-generator.d.ts

@@ -11,4 +11,5 @@ export declare abstract class CodeGenerator {
     abstract generateSessionDataCode(): Promise<void>;
     abstract generateValidationCode(): Promise<void>;
     abstract generateCode(codeConfig: CodeGeneratorProps): Promise<void>;
+    abstract generateUnitTestingCode(): Promise<void>;
 }

package/dist/generator/generators/documentation/md-generator.d.ts

@@ -2,6 +2,7 @@ import { TestObject } from "../../../types/config-types.js";
 import { CodeGenerator } from "../classes/abstract-generator.js";
 export declare class MarkdownDocGenerator extends CodeGenerator {
     generateSessionDataCode(): Promise<void>;
+    generateUnitTestingCode(): Promise<void>;
     generateValidationCode: () => Promise<void>;
     generateCode: () => Promise<void>;
     generateMarkdownForTest: (testObject: TestObject) => string;

package/dist/generator/generators/documentation/md-generator.js

@@ -54,4 +54,7 @@ export class MarkdownDocGenerator extends CodeGenerator {
     generateSessionDataCode() {
         throw new Error("Method not implemented.");
     }
+    generateUnitTestingCode() {
+        throw new Error("Method not implemented.");
+    }
 }

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

@@ -10,4 +10,5 @@ export declare class GoGenerator extends CodeGenerator {
     private createVariablesCode;
     private createValidationLogicCode;
     private CreateErrorMarkdown;
+    generateUnitTestingCode(): Promise<void>;
 }

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

@@ -8,7 +8,7 @@ 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 { ConvertArrayToStringGoStyle, removeAllSpecialCharacters, } 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);
@@ -34,6 +34,7 @@ export class GoGenerator extends CodeGenerator {
             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();
+            await this.generateUnitTestingCode();
         };
         this.generateTestFunction = async (testObject) => {
             const template = readFileSync(path.resolve(__dirname, "./templates/test-object.mustache"), "utf-8");
@@ -255,11 +256,38 @@ ${importList.map((imp) => `\t${imp}`).join("\n")}
     createVariablesCode(testObject) {
         const variables = [];
         const varNames = getVariablesFromTest(testObject);
+        const returnStatement = testObject[TestObjectSyntax.Return];
+        const continueStatement = testObject[TestObjectSyntax.Continue];
+        let elementsList = [];
+        // REPLACE ALL special WITH empty AND SPLIT
+        if (typeof returnStatement === "string") {
+            elementsList = removeAllSpecialCharacters(returnStatement).split(" ");
+        }
+        if (continueStatement) {
+            const contElements = removeAllSpecialCharacters(continueStatement).split(" ");
+            for (const elem of contElements) {
+                if (!elementsList.includes(elem)) {
+                    elementsList.push(elem);
+                }
+            }
+        }
         for (const name of varNames) {
             const value = testObject[name];
-            const final = typeof value === "string"
-                ? `validationutils.GetJsonPath(testObjMap, "${value}",true)`
-                : ConvertArrayToStringGoStyle(value);
+            if (!elementsList.includes(name)) {
+                console.log(`Variable ${name} not used in return or continue statements, skipping generation.: \n ${returnStatement} \n ${continueStatement}`);
+                console.log(elementsList);
+                continue;
+            }
+            let final = "";
+            if (value.includes("_EXTERNAL")) {
+                final = `validationutils.GetJsonPath(input, "${value}",true)`;
+            }
+            else {
+                final =
+                    typeof value === "string"
+                        ? `validationutils.GetJsonPath(testObjMap, "${value}",true)`
+                        : ConvertArrayToStringGoStyle(value);
+            }
             variables.push({
                 name: name,
                 value: final,
@@ -316,6 +344,13 @@ ${importList.map((imp) => `\t${imp}`).join("\n")}
     CreateErrorMarkdown(testObject, skipList) {
         return markdownMessageGenerator(testObject[TestObjectSyntax.Return], testObject, testObject[TestObjectSyntax.Name], skipList);
     }
+    async generateUnitTestingCode() {
+        const testTemplate = readFileSync(path.resolve(__dirname, "./templates/test-templates/validator-test.mustache"), "utf-8");
+        const finalTestCode = Mustache.render(testTemplate, {
+            functionName: this.codeConfig?.codeName ?? "L1Validations",
+        });
+        await writeAndFormatCode(this.rootPath, `./${packageName}/main-validator_test.go`, finalTestCode, "go");
+    }
 }
 function stringToCaps(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);

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

@@ -4,7 +4,6 @@ package jsonvalidations
 
 import (
     "validationpkg/validationutils"
-	"fmt"
 )
 
 func {{apiName}}_Tests(input validationutils.ValidationInput) ([]validationutils.ValidationOutput, error) {

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

@@ -1,5 +1,5 @@
 // Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
-package main
+package validationpkg
 
 {{{importCode}}}
 

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

@@ -2,9 +2,6 @@
 
 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
@@ -143,7 +140,7 @@ func fillFromTemplate(propName string, obj map[string]interface{}, templates map
 
 // DeepCloneJSON creates a deep clone of a JSON-serializable structure using sonic
 func DeepCloneJSON(v interface{}) interface{} {
-	b, err := sonic.Marshal(v)
+	/* b, err := sonic.Marshal(v)
 	if err != nil {
 		panic(err) // or handle error
 	}
@@ -151,5 +148,6 @@ func DeepCloneJSON(v interface{}) interface{} {
 	if err := sonic.Unmarshal(b, &out); err != nil {
 		panic(err)
 	}
-	return out
+	return out */
+	return v
 }

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

@@ -49,9 +49,9 @@ type ExternalData struct {
 
 // ValidationInput represents the input data for validation functions
 type ValidationInput struct {
-	Payload      interface{}
-	ExternalData ExternalData
-	Config       ValidationConfig
+	Payload      interface{} `json:"payload"`
+	ExternalData ExternalData `json:"_EXTERNAL,omitempty"`
+	Config       ValidationConfig `json:"_CONFIG,omitempty"`
 }
 
 // TestFunction is a function type that takes ValidationInput and returns a slice of ValidationOutput

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

@@ -4,13 +4,9 @@ var {{name}} = func (input validationutils.ValidationInput) ([]validationutils.V
     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)
+    for _, testObjMap := range scope {
+        validationutils.UnusedFunction(testObjMap)
+        // testObjMap["_EXTERNAL"] = validationutils.DeepCloneJSON(input.ExternalData)
         
         {{#variables}}
         {{name}} := {{{value}}}
@@ -26,7 +22,7 @@ var {{name}} = func (input validationutils.ValidationInput) ([]validationutils.V
 
         {{{validationCode}}}
 
-        delete(testObjMap, "_EXTERNAL")
+        // delete(testObjMap, "_EXTERNAL")
     }
     
     result := validationutils.ValidationOutput{

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

@@ -0,0 +1,167 @@
+// Code generated by github.com/ONDC-Official/automation-validation-compiler, DO NOT EDIT.
+
+package validationpkg
+
+
+// How to run:
+//
+// 1) Create example payload files under ./examples (relative to this package):
+//      validationpkg/examples/search.json
+//      validationpkg/examples/on_search.json
+//    Each file must contain a JSON array of payload objects.
+//
+// 2) From the validationpkg module directory, run:
+//      go test -run TestPerformL1validations_Examples -v
+//    Or from the repo root:
+//      go test ./ondcValidator/validationpkg -run TestPerformL1validations_Examples -v
+//
+// Outputs are written under ./examples_output/<action>/case-XXX/output.json.
+
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"validationpkg/validationutils"
+)
+
+type noopStorage struct{}
+
+func (n *noopStorage) SaveKey(uniquePrefix string, key string, value string) error { return nil }
+func (n *noopStorage) GetKey(uniquePrefix string, key string) (string, error) {
+	return "", fmt.Errorf("noop storage: key not found")
+}
+func (n *noopStorage) DeleteKey(uniquePrefix string, key string) error { return nil }
+func (n *noopStorage) ListKeys(uniquePrefix string) ([]string, error) {
+	return nil, fmt.Errorf("noop storage: list not supported")
+}
+func (n *noopStorage) ClearStorage() error { return nil }
+func (n *noopStorage) KeyExists(uniquePrefix string, key string) (bool, error) { return false, nil }
+
+type validationRunOutput struct {
+	Action    string                            `json:"action"`
+	Case      int                               `json:"case"`
+	UniqueKey string                            `json:"uniqueKey"`
+	Error     string                            `json:"error,omitempty"`
+	Results   []validationutils.ValidationOutput `json:"results,omitempty"`
+}
+
+func TestPerformL1validations_Examples(t *testing.T) {
+	examplesDir := "examples"
+	if _, err := os.Stat(examplesDir); err != nil {
+		if os.IsNotExist(err) {
+			t.Skipf("%s directory not found; skipping example-based validations", examplesDir)
+		}
+		t.Fatalf("failed to stat %s: %v", examplesDir, err)
+	}
+
+	files, err := filepath.Glob(filepath.Join(examplesDir, "*.json"))
+	if err != nil {
+		t.Fatalf("failed to glob examples: %v", err)
+	}
+	if len(files) == 0 {
+		t.Skipf("no example files found in %s", examplesDir)
+	}
+
+	outputRoot := "examples_output"
+	if err := os.MkdirAll(outputRoot, 0o755); err != nil {
+		t.Fatalf("failed to create output dir %s: %v", outputRoot, err)
+	}
+
+	store := &noopStorage{}
+
+	for _, filePath := range files {
+		action := strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath))
+
+		t.Run(action, func(t *testing.T) {
+			data, err := os.ReadFile(filePath)
+			if err != nil {
+				t.Fatalf("failed to read %s: %v", filePath, err)
+			}
+
+			var payloads []json.RawMessage
+			if err := json.Unmarshal(data, &payloads); err != nil {
+				t.Fatalf("%s must contain a JSON array of payloads: %v", filePath, err)
+			}
+			if len(payloads) == 0 {
+				t.Skipf("no payloads in %s", filePath)
+			}
+
+			for i, raw := range payloads {
+				caseNum := i + 1
+
+				var payload interface{}
+				if err := json.Unmarshal(raw, &payload); err != nil {
+					t.Errorf("case %d: payload is not valid JSON: %v", caseNum, err)
+					continue
+				}
+
+				uniqueKey := extractTransactionID(payload)
+				if uniqueKey == "" {
+					uniqueKey = fmt.Sprintf("%s-case-%03d", action, caseNum)
+				}
+
+				cfg := &validationutils.ValidationConfig{
+					StateFullValidations: false,
+					Debug:                false,
+					OnlyInvalid:           true,
+					HideParentErrors:      true,
+					UniqueKey:             &uniqueKey,
+					Store:                 store,
+				}
+
+				results, runErr := Perform{{functionName}}(action, payload, cfg, validationutils.ExternalData{})
+				out := validationRunOutput{
+					Action:    action,
+					Case:      caseNum,
+					UniqueKey: uniqueKey,
+					Results:   results,
+				}
+				if runErr != nil {
+					out.Error = runErr.Error()
+				}
+
+				caseDir := filepath.Join(outputRoot, action, fmt.Sprintf("case-%03d", caseNum))
+				if err := os.MkdirAll(caseDir, 0o755); err != nil {
+					t.Errorf("case %d: failed to create output dir %s: %v", caseNum, caseDir, err)
+					continue
+				}
+
+				encoded, err := json.MarshalIndent(out, "", "  ")
+				if err != nil {
+					t.Errorf("case %d: failed to marshal output: %v", caseNum, err)
+					continue
+				}
+
+				if err := os.WriteFile(filepath.Join(caseDir, "output.json"), encoded, 0o644); err != nil {
+					t.Errorf("case %d: failed to write output.json: %v", caseNum, err)
+				}
+
+				if runErr != nil {
+					t.Errorf("case %d: PerformL1validations returned error: %v", caseNum, runErr)
+				}
+			}
+		})
+	}
+}
+
+func extractTransactionID(payload interface{}) string {
+	root, ok := payload.(map[string]interface{})
+	if !ok {
+		return ""
+	}
+	ctx, ok := root["context"].(map[string]interface{})
+	if !ok {
+		return ""
+	}
+	if v, ok := ctx["transaction_id"]; ok {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}

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

@@ -59,7 +59,7 @@ if(!validate){
             FedConfig: configureDebugInfo,
         },
     }
-    delete(testObjMap, "_EXTERNAL")
+    // delete(testObjMap, "_EXTERNAL")
     return []validationutils.ValidationOutput{result},nil
 }
 

package/dist/generator/generators/javascript/js-generator.d.ts

@@ -1,6 +1,7 @@
 import { CodeGenerator, CodeGeneratorProps } from "../classes/abstract-generator.js";
 export declare class JavascriptGenerator extends CodeGenerator {
     private tempTsPath;
+    generateUnitTestingCode(): Promise<void>;
     constructor(validationConfig: any, errorCodes: any[], rootPath?: string);
     generateSessionDataCode: () => Promise<never>;
     generateValidationCode: () => Promise<void>;

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

@@ -12,6 +12,9 @@ const execAsync = promisify(exec);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class JavascriptGenerator extends CodeGenerator {
+    generateUnitTestingCode() {
+        throw new Error("Method not implemented.");
+    }
     constructor(validationConfig, errorCodes, rootPath = "./") {
         super(validationConfig, errorCodes, rootPath);
         this.generateSessionDataCode = async () => {

package/dist/generator/generators/python/py-generator.d.ts

@@ -2,6 +2,7 @@ import { TestObject } from "../../../types/config-types.js";
 import { CodeGenerator, CodeGeneratorProps } from "../classes/abstract-generator.js";
 export declare class PythonGenerator extends CodeGenerator {
     codeConfig: CodeGeneratorProps | undefined;
+    generateUnitTestingCode(): Promise<void>;
     generateSessionDataCode: () => Promise<void>;
     generateValidationCode: () => Promise<void>;
     generateCode: (codeConfig: CodeGeneratorProps) => Promise<void>;

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

@@ -185,6 +185,9 @@ export class PythonGenerator extends CodeGenerator {
             }
         };
     }
+    generateUnitTestingCode() {
+        throw new Error("Method not implemented.");
+    }
     CreateErrorMarkdown(testObject, skipList) {
         return markdownMessageGenerator(testObject[TestObjectSyntax.Return], testObject, testObject[TestObjectSyntax.Name], skipList);
     }

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

@@ -15,4 +15,5 @@ export declare class TypescriptGenerator extends CodeGenerator {
     private generateErrorFile;
     private getExternalKeys;
     private generateIndexFile;
+    generateUnitTestingCode(): Promise<void>;
 }

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

@@ -286,4 +286,7 @@ export class TypescriptGenerator extends CodeGenerator {
             masterFunction: masterFunction,
         });
     }
+    generateUnitTestingCode() {
+        throw new Error("Method not implemented.");
+    }
 }

package/dist/services/schema-service.d.ts

@@ -1,6 +1,7 @@
 import { JSONSchema7 } from "json-schema";
 import { BUILD_TYPE } from "../types/build.js";
-export declare class SchemaExtactionService {
+export declare class ExtractionService {
     extractSchemas: (data: BUILD_TYPE, removeRequired: boolean, removeEnums: boolean) => Promise<Record<string, JSONSchema7>>;
     extractPossiblePaths: (schemas: Record<string, JSONSchema7>) => Record<string, string[]>;
+    extractPayloadExamples: (data: BUILD_TYPE) => void;
 }

package/dist/services/schema-service.js

@@ -1,6 +1,6 @@
 import { removeRequiredAndEnum } from "../utils/config-utils/json-schema-utils.js";
 import { getAllJsonPaths } from "../utils/json-path-utils/extract-string-paths.js";
-export class SchemaExtactionService {
+export class ExtractionService {
     constructor() {
         this.extractSchemas = async (data, removeRequired, removeEnums) => {
             const paths = data.paths;
@@ -25,5 +25,6 @@ export class SchemaExtactionService {
             }
             return paths;
         };
+        this.extractPayloadExamples = (data) => { };
     }
 }

package/dist/types/build.d.ts

@@ -47,4 +47,5 @@ export interface BUILD_TYPE {
         code: ErrorDefinition[];
     };
     "x-validations"?: ValidationConfig;
+    "x-examples"?: any;
 }

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

@@ -27,3 +27,4 @@ export declare function ConvertArrayToStringsInTestObject(testObject: TestObject
 export declare function ConvertArrayToString(arr: any[]): string;
 export declare function ConvertArrayToStringGoStyle(arr: any[]): string;
 export declare function addTabToMarkdown(markdown: string): string;
+export declare function removeAllSpecialCharacters(input: string): string;

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

@@ -79,3 +79,6 @@ export function addTabToMarkdown(markdown) {
         .map((line) => `\t${line}`) // Add a tab character at the beginning of each line
         .join("\n"); // Rejoin the lines into a single string
 }
+export function removeAllSpecialCharacters(input) {
+    return input.replace(/[()!]/g, "").trim();
+}

package/package.json

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