ondc-code-generator 0.7.3 → 0.7.5

package/dist/bin/cli.js

@@ -41,7 +41,7 @@ program
         console.log(Cli.description.info("Initializing compiler..."));
         await compiler.initialize(buildYaml);
         console.log(Cli.description.info("Generating validation code..."));
-        await compiler.generateValidationFromBuild(functionName, output);
+        await compiler.generateValidationFromBuild(functionName, output, true);
         console.log(Cli.description.success(`Validation code generated successfully in ${output} for language ${lang}`));
     }
     catch (error) {
@@ -57,8 +57,56 @@ program
     .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");
+    .action(async (options) => {
+    console.log(Cli.title("Ondc Schema Generator"));
+    try {
+        const { config, output, format } = options;
+        if (!config || !output || !format) {
+            console.log(Cli.description.error("Please provide all required options: --config, --output, --format"));
+            process.exit(1);
+        }
+        console.log(Cli.description.info(`Generating L0 schema...`));
+        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);
+        const formatType = getSchemaFormat(format);
+        await compiler.generateL0Schema(output, formatType, true);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(Cli.description.error(`Error: ${message}`));
+        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) {
@@ -75,6 +123,18 @@ function getSupportedLanguage(lang) {
             throw new Error(`Unsupported language: ${lang}. Supported languages are: ${getValidLanguageOptions()}`);
     }
 }
+function getSchemaFormat(format) {
+    switch (format.toLowerCase()) {
+        case "json":
+            return "json";
+        case "typescript":
+            return "typescript";
+        case "yaml":
+            throw new Error("YAML format is not yet supported");
+        default:
+            throw new Error(`Unsupported format: ${format}. Supported formats are: json, typescript`);
+    }
+}
 function getValidLanguageOptions() {
     return Object.values(SupportedLanguages).join(", ");
 }

package/dist/constants/syntax.js

@@ -168,4 +168,30 @@ export const ReservedKeywords = new Set([
     "match",
     "case",
     "_",
+    // golang keywords
+    "break",
+    "default",
+    "func",
+    "interface",
+    "select",
+    "case",
+    "defer",
+    "go",
+    "map",
+    "struct",
+    "chan",
+    "else",
+    "goto",
+    "package",
+    "switch",
+    "const",
+    "fallthrough",
+    "if",
+    "range",
+    "type",
+    "continue",
+    "for",
+    "import",
+    "return",
+    "var",
 ]);

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

@@ -20,9 +20,10 @@ export declare class ConfigCompiler {
     initialize: (buildYaml: string, generatorConfig?: Partial<CodeGeneratorConfig>) => Promise<void>;
     performValidations: (valConfig: ValidationConfig) => Promise<void>;
     withMinimalValidations: (valConfig: ValidationConfig) => Promise<void>;
-    generateCode: (valConfig: ValidationConfig, codeName?: string, minimal?: boolean, outputPath?: string) => Promise<void>;
-    generateL0Schema: (outputPath?: string, type?: "json" | "typescript") => Promise<void>;
+    generateCode: (valConfig: ValidationConfig, codeName?: string, minimal?: boolean, outputPath?: string, absolutePath?: boolean) => Promise<void>;
+    generateL0Schema: (outputPath?: string, type?: "json" | "typescript", absolutePath?: boolean) => Promise<void>;
     generateValidPaths: () => Promise<Record<string, string[]>>;
-    generateValidationFromBuild: (codeName: string, outputPath: string) => Promise<void>;
+    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";
@@ -57,7 +57,7 @@ export class ConfigCompiler {
             // throw new Error("validation failed");
         };
         // };
-        this.generateCode = async (valConfig, codeName = "L1-Validations", minimal = false, outputPath = "./") => {
+        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);
@@ -69,7 +69,9 @@ export class ConfigCompiler {
                 await this.performValidations(valConfig);
             }
             // Generate code based on the language
-            const targetPath = `${outputPath}generated/${codeName}`;
+            const targetPath = absolutePath
+                ? outputPath
+                : `${outputPath}generated/${codeName}`;
             switch (this.language) {
                 case SupportedLanguages.Typescript:
                     await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
@@ -95,11 +97,13 @@ export class ConfigCompiler {
                     throw new Error("Language not supported");
             }
         };
-        this.generateL0Schema = async (outputPath = "./", type = "typescript") => {
+        this.generateL0Schema = async (outputPath = "./", type = "typescript", absolutePath = false) => {
             if (!this.jsonSchemas) {
                 throw new Error("Schemas not initialized");
             }
-            const targetPath = `${outputPath}generated/L0-schemas/`;
+            const targetPath = absolutePath
+                ? outputPath
+                : `${outputPath}generated/L0-schemas/`;
             for (const schema in this.jsonSchemas) {
                 const json = this.jsonSchemas[schema];
                 if (type === "typescript") {
@@ -129,13 +133,18 @@ export class ConfigCompiler {
             // );
             return this.possibleJsonPaths;
         };
-        this.generateValidationFromBuild = async (codeName, outputPath) => {
+        this.generateValidationFromBuild = async (codeName, outputPath, absolutePath = false) => {
             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);
+            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,14 +2,11 @@
 
 package validationutils
 
-import (
-	"encoding/json"
-)
 
 // 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
+//   - 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{})
@@ -67,12 +64,12 @@ func applyTemplates(node interface{}, templates map[string]map[string]struct{})
 			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 {
@@ -141,15 +138,16 @@ func fillFromTemplate(propName string, obj map[string]interface{}, templates map
 	return filled
 }
 
-// DeepCloneJSON creates a deep clone of a JSON-serializable structure
+// DeepCloneJSON creates a deep clone of a JSON-serializable structure using sonic
 func DeepCloneJSON(v interface{}) interface{} {
-	b, err := json.Marshal(v)
+	/* b, err := sonic.Marshal(v)
 	if err != nil {
 		panic(err) // or handle error
 	}
 	var out interface{}
-	if err := json.Unmarshal(b, &out); err != nil {
+	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;
 }