ondc-code-generator 0.4.6 → 0.5.0

package/dist/constants/syntax.d.ts

@@ -13,4 +13,4 @@ export declare enum ConfigSyntax {
     SessionData = "_SESSION_DATA_"
 }
 export declare const ConfigKeyWords: (TestObjectSyntax | ConfigSyntax)[];
-export declare const nodeReservedKeywords: Set<string>;
+export declare const ReservedKeywords: Set<string>;

package/dist/constants/syntax.js

@@ -24,8 +24,9 @@ export const ConfigKeyWords = [
     ConfigSyntax.Tests,
     ConfigSyntax.SessionData,
 ];
-// JavaScript/Node.js keywords
-export const nodeReservedKeywords = new Set([
+// List of reserved keywords in Supported Languages (JavaScript/TypeScript and Python)
+export const ReservedKeywords = new Set([
+    // JavaScript/TypeScript keywords
     "break",
     "case",
     "catch",
@@ -75,4 +76,99 @@ export const nodeReservedKeywords = new Set([
     "protected",
     "public",
     "static",
+    // Python keywords
+    "and",
+    "as",
+    "assert",
+    "def",
+    "del",
+    "elif",
+    "except",
+    "exec",
+    "from",
+    "global",
+    "is",
+    "lambda",
+    "not",
+    "or",
+    "pass",
+    "print",
+    "raise",
+    "with",
+    "yield",
+    // Python built-in functions and constants (commonly reserved)
+    "True",
+    "False",
+    "None",
+    "abs",
+    "all",
+    "any",
+    "bin",
+    "bool",
+    "bytearray",
+    "bytes",
+    "callable",
+    "chr",
+    "classmethod",
+    "compile",
+    "complex",
+    "delattr",
+    "dict",
+    "dir",
+    "divmod",
+    "enumerate",
+    "eval",
+    "filter",
+    "float",
+    "format",
+    "frozenset",
+    "getattr",
+    "globals",
+    "hasattr",
+    "hash",
+    "help",
+    "hex",
+    "id",
+    "input",
+    "int",
+    "isinstance",
+    "issubclass",
+    "iter",
+    "len",
+    "list",
+    "locals",
+    "map",
+    "max",
+    "memoryview",
+    "min",
+    "next",
+    "object",
+    "oct",
+    "open",
+    "ord",
+    "pow",
+    "property",
+    "range",
+    "repr",
+    "reversed",
+    "round",
+    "set",
+    "setattr",
+    "slice",
+    "sorted",
+    "staticmethod",
+    "str",
+    "sum",
+    "tuple",
+    "type",
+    "vars",
+    "zip",
+    // Python 3.x additional keywords
+    "nonlocal",
+    "async",
+    "await",
+    // Soft keywords in Python (context-dependent)
+    "match",
+    "case",
+    "_",
 ]);

package/dist/generator/config-compiler.js

@@ -9,6 +9,7 @@ import Mustache from "mustache";
 import { fileURLToPath } from "url";
 import path from "path";
 import { duplicateVariablesInChildren } from "../utils/config-utils/duplicateVariables.js";
+import { PythonGenerator } from "./generators/python/py-generator.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const defaultConfig = {
@@ -70,9 +71,12 @@ export class ConfigCompiler {
             const targetPath = `${outputPath}generated/${codeName}`;
             switch (this.language) {
                 case SupportedLanguages.Typescript:
-                    await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], 
-                    // `./generated/${codeName}`
-                    targetPath).generateCode({
+                    await new TypescriptGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
+                        codeName: codeName,
+                    });
+                    break;
+                case SupportedLanguages.Python:
+                    await new PythonGenerator(valConfig, this.errorDefinitions ?? [], targetPath).generateCode({
                         codeName: codeName,
                     });
                     break;

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

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

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

@@ -0,0 +1,72 @@
+import { buildAstFromInput } from "../../../services/return-complier/combined.js";
+import { AllIn, AnyIn, ArePresent, AreUnique, EqualTo, FollowRegex, GreaterThan, LessThan, NoneIn, } from "../../../services/return-complier/tokens.js";
+function getPyOperator(op) {
+    switch (op) {
+        case "&&":
+            return "and";
+        case "||":
+            return "or";
+        case "==":
+            return "==";
+        case "!=":
+            return "!=";
+        case ">":
+            return ">";
+        case "<":
+            return "<";
+        case ">=":
+            return ">=";
+        case "<=":
+            return "<=";
+        default:
+            throw new Error(`Unsupported operator: ${op}`);
+    }
+}
+const uniaryFunction = {
+    [AreUnique.LABEL ?? "are unique"]: "are_unique",
+    [ArePresent.LABEL ?? "are present"]: "are_present",
+};
+const binaryFunction = {
+    [AllIn.LABEL ?? "all in"]: "all_in",
+    [AnyIn.LABEL ?? "any in"]: "any_in",
+    [FollowRegex.LABEL ?? "follow regex"]: "follow_regex",
+    [NoneIn.LABEL ?? "none in"]: "none_in",
+    [EqualTo.LABEL ?? "equal to"]: "equal_to",
+    [GreaterThan.LABEL ?? "greater than"]: "greater_than",
+    [LessThan.LABEL ?? "less than"]: "less_than",
+};
+function compileToPy(node) {
+    if (node.type === "returnStatement") {
+        const returnNode = node;
+        return compileToPy(returnNode.expression);
+    }
+    if (node.type === "binaryOperator") {
+        const binaryNode = node;
+        const lhs = compileToPy(binaryNode.lhs);
+        const rhs = compileToPy(binaryNode.rhs);
+        return `(${lhs}) ${getPyOperator(binaryNode.operator)} (${rhs})`;
+    }
+    if (node.type === "notOperator") {
+        const notNode = node;
+        const expression = compileToPy(notNode.expression);
+        return `not (${expression})`;
+    }
+    if (node.type === "customUniaryFunction") {
+        const unary = node;
+        const func = uniaryFunction[unary.customFunction];
+        const varName = unary.expression.name;
+        return `validation_utils["${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 `validation_utils["${func}"](${lhs}, ${rhs})`;
+    }
+    throw new Error("Unknown node type");
+}
+export const compileInputToPy = (input) => {
+    const ast = buildAstFromInput(input);
+    return compileToPy(ast);
+};

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

@@ -0,0 +1,19 @@
+import { TestObject } from "../../../types/config-types.js";
+import { CodeGenerator, CodeGeneratorProps } from "../classes/abstract-generator.js";
+export declare class PythonGenerator extends CodeGenerator {
+    generateSessionDataCode: () => Promise<never>;
+    generateValidationCode: () => Promise<void>;
+    generateCode: (codeConfig: CodeGeneratorProps) => Promise<void>;
+    generateTestFunction: (testObject: TestObject) => Promise<{
+        funcName: string;
+        code: string;
+    }>;
+    private CreateErrorMarkdown;
+    private createVariablesCode;
+    private convertArrayToStringPython;
+    private indentCode;
+    private createValidationLogicCode;
+    private generateErrorFile;
+    private getExternalKeys;
+    private generateIndexFile;
+}

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

@@ -1 +1,247 @@
-"use strict";
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { ConfigSyntax, TestObjectSyntax } from "../../../constants/syntax.js";
+import Mustache from "mustache";
+import { markdownMessageGenerator } from "../documentation/markdown-message-generator.js";
+import { getVariablesFromTest as extractVariablesFromText } from "../../../utils/general-utils/test-object-utils.js";
+import { compileInputToPy } from "./py-ast.js";
+import { CodeGenerator, } from "../classes/abstract-generator.js";
+import { writeAndFormatCode } from "../../../utils/fs-utils.js";
+import { MarkdownDocGenerator } from "../documentation/md-generator.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class PythonGenerator extends CodeGenerator {
+    constructor() {
+        super(...arguments);
+        this.generateSessionDataCode = async () => {
+            throw new Error("Method not implemented.");
+        };
+        this.generateValidationCode = async () => {
+            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-test.mustache"), "utf-8");
+                const finalCode = Mustache.render(apiTestTemplate, {
+                    functionCode: testFunction.code,
+                    apiName: key,
+                });
+                await writeAndFormatCode(this.rootPath, `./api_tests/${key}.py`, finalCode, "python");
+            }
+        };
+        this.generateCode = async (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 apiTestsInitTemplate = readFileSync(path.resolve(__dirname, "./templates/api-tests-init.mustache"), "utf-8");
+            const requirementsTemplate = readFileSync(path.resolve(__dirname, "./templates/requirements.mustache"), "utf-8");
+            const typesCode = Mustache.render(typesTemplate, {
+                externalData: this.getExternalKeys(),
+            });
+            const requirements = Mustache.render(requirementsTemplate, {});
+            const apiNames = Object.keys(this.validationConfig[ConfigSyntax.Tests]);
+            const apiTestsInitCode = Mustache.render(apiTestsInitTemplate, {
+                apis: apiNames.map((name) => ({ name })),
+            });
+            await writeAndFormatCode(this.rootPath, "./utils/json_path_utils.py", jsonPathUtilsCode, "python");
+            await writeAndFormatCode(this.rootPath, "./utils/json_normalizer.py", normalizerTemplate, "python");
+            await writeAndFormatCode(this.rootPath, "./utils/validation_utils.py", validationUtils, "python");
+            await writeAndFormatCode(this.rootPath, "./utils/__init__.py", "# Utils package", "python");
+            await writeAndFormatCode(this.rootPath, "./types/test_config.py", typesCode, "python");
+            await writeAndFormatCode(this.rootPath, "./types/__init__.py", "# Types package", "python");
+            await writeAndFormatCode(this.rootPath, "./api_tests/__init__.py", apiTestsInitCode, "python");
+            await this.generateValidationCode();
+            await writeAndFormatCode(this.rootPath, "requirements.txt", requirements, "text");
+            await writeAndFormatCode(this.rootPath, "error.py", this.generateErrorFile(this.errorCodes), "python");
+            await writeAndFormatCode(this.rootPath, "__init__.py", this.generateIndexFile(apiNames, codeConfig.codeName), "python");
+            await new MarkdownDocGenerator(this.validationConfig, this.errorCodes, this.rootPath).generateCode();
+        };
+        this.generateTestFunction = async (testObject) => {
+            const template = readFileSync(path.resolve(__dirname, "./templates/test-object.mustache"), "utf-8");
+            const view = {
+                name: testObject[TestObjectSyntax.Name],
+                scopePath: testObject[TestObjectSyntax.Scope] ?? "$",
+                variables: this.createVariablesCode(testObject),
+                hasContinue: testObject[TestObjectSyntax.Continue] ? true : false,
+                skipCheckStatement: testObject[TestObjectSyntax.Continue]
+                    ? compileInputToPy(testObject[TestObjectSyntax.Continue])
+                    : undefined,
+                validationCode: await this.createValidationLogicCode(testObject),
+                successCode: testObject[TestObjectSyntax.SuccessCode] ?? 200,
+                testName: testObject[TestObjectSyntax.Name],
+                errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
+                TEST_OBJECT: `${JSON.stringify(testObject)}`,
+            };
+            return {
+                funcName: testObject[TestObjectSyntax.Name],
+                code: Mustache.render(template, view),
+            };
+        };
+        this.createValidationLogicCode = async (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 = compileInputToPy(testObject[TestObjectSyntax.Return]);
+                return Mustache.render(template, {
+                    isNested: false,
+                    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 };
+                });
+                // Properly indent nested functions
+                const indentedNestedFunctions = functionCodes
+                    .map((f) => this.indentCode(f.code, 2))
+                    .join("\n\n");
+                return Mustache.render(template, {
+                    isNested: true,
+                    nestedFunctions: indentedNestedFunctions,
+                    names: names,
+                    errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
+                    TEST_OBJECT: `${JSON.stringify(testObject)}`,
+                });
+            }
+        };
+    }
+    CreateErrorMarkdown(testObject, skipList) {
+        return markdownMessageGenerator(testObject[TestObjectSyntax.Return], testObject, testObject[TestObjectSyntax.Name], skipList);
+    }
+    createVariablesCode(testObject) {
+        const variables = [];
+        const varNames = extractVariablesFromText(testObject);
+        for (const name of varNames) {
+            const value = testObject[name];
+            const final = typeof value === "string"
+                ? `payload_utils["get_json_path"](${testObject[TestObjectSyntax.Name]}_obj, "${value}")`
+                : this.convertArrayToStringPython(value);
+            variables.push({
+                name: name,
+                value: final,
+            });
+        }
+        return variables;
+    }
+    convertArrayToStringPython(value) {
+        // Convert TypeScript array notation to Python list notation
+        let stringified = JSON.stringify(value);
+        stringified = stringified.replace(/\\\\\\/g, "\\");
+        // Replace null with None, true with True, false with False
+        return stringified
+            .replace(/null/g, "None")
+            .replace(/true/g, "True")
+            .replace(/false/g, "False");
+    }
+    indentCode(code, indentLevel = 1) {
+        const indent = "    ".repeat(indentLevel);
+        return code
+            .split("\n")
+            .map((line) => (line.trim() ? indent + line : line))
+            .join("\n");
+    }
+    generateErrorFile(errors) {
+        const allCodes = errors.map((error) => error.code);
+        if (allCodes.length !== new Set(allCodes).size) {
+            throw new Error("Duplicate error codes found");
+        }
+        errors.push({
+            code: 20006,
+            Description: "Invalid response does not meet API contract specifications",
+        });
+        errors.push({
+            code: 30000,
+            Description: "Invalid request does not meet API contract specifications",
+        });
+        const errorsList = errors
+            .map((error) => `    {"code": ${error.code}, "message": "${error.Description}"}`)
+            .join(",\n");
+        const errorConstant = `
+errors = [
+${errorsList}
+]
+		`;
+        const errorFunction = `def get_error(code):
+    for error in errors:
+        if error["code"] == code:
+            return error
+    raise Exception(f"Error code {code} not found")`;
+        return `${errorConstant}\n${errorFunction}`;
+    }
+    getExternalKeys() {
+        const apis = Object.keys(this.validationConfig[ConfigSyntax.SessionData]);
+        const result = [];
+        for (const api of apis) {
+            const keys = Object.keys(this.validationConfig[ConfigSyntax.SessionData][api]);
+            for (const key of keys) {
+                result.push({ name: key });
+            }
+        }
+        return result;
+    }
+    generateIndexFile(apis, functionName = "L1Validations") {
+        // Clean function name for Python
+        functionName = functionName.replace(/[^a-zA-Z0-9_]/g, "");
+        let importsCode = apis
+            .map((api) => `from .api_tests import ${api}`)
+            .join("\n");
+        importsCode += `\nfrom .types.test_config import ValidationConfig\n`;
+        const masterDoc = readFileSync(path.resolve(__dirname, "./templates/master-doc.mustache"), "utf-8");
+        const masterFunction = `
+def perform_${functionName.toLowerCase()}(action, payload,config: ValidationConfig = None, external_data=None):
+    ${masterDoc}
+
+    if external_data is None:
+        external_data = {}
+    
+    from .utils.json_normalizer import normalize_keys
+    normalized_payload = normalize_keys(payload.copy())
+    external_data["_SELF"] = normalized_payload
+    default_config = {
+        "only_invalid": True,
+        "standard_logs": False,
+        "_debug": False,
+        "hide_parent_errors": True,
+    }
+    # Merge user config with default config
+    if config is None:
+        config = default_config
+    else:
+        config = {**default_config, **config}
+
+    input_data = {
+        "payload": normalized_payload,
+        "external_data": external_data,
+        "config": config,
+    }
+    
+    if action == "${apis[0]}":
+        return ${apis[0]}(input_data)
+${apis
+            .slice(1)
+            .map((api) => `    elif action == "${api}":
+        return ${api}(input_data)`)
+            .join("\n")}
+    else:
+        raise Exception("Action not found")
+		`;
+        return `${importsCode}\n${masterFunction}`;
+    }
+}

package/dist/generator/generators/python/templates/api-test.mustache

@@ -0,0 +1,29 @@
+from ..utils.json_path_utils import payload_utils
+from ..utils.validation_utils import validation_utils
+
+
+{{{functionCode}}}
+
+
+def {{apiName}}(input_data):
+    total_results = {{apiName}}_validations(input_data)
+
+    if input_data["config"].get("_debug") is False:
+        for r in total_results:
+            if "_debug_info" in r:
+                del r["_debug_info"]
+
+    if input_data["config"].get("hide_parent_errors") is True:
+        # delete results with valid false and no description
+        total_results = [r for r in total_results if not (r["valid"] is False and "description" not in r)]
+
+    if input_data["config"].get("only_invalid") is True:
+        res = [r for r in total_results if r["valid"] is False]
+        if len(res) == 0:
+            target_success = next((r for r in total_results if r["test_name"] == "{{apiName}}_validations"), None)
+            if not target_success:
+                raise Exception("Critical: Overall test result not found")
+            return [target_success]
+        return res
+
+    return total_results

package/dist/generator/generators/python/templates/api-tests-init.mustache

@@ -0,0 +1,12 @@
+# API Tests module
+# This file makes the api_tests directory a Python package
+
+{{#apis}}
+from .{{name}} import {{name}}
+{{/apis}}
+
+__all__ = [
+{{#apis}}
+    "{{name}}",
+{{/apis}}
+]

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

@@ -0,0 +1,86 @@
+from typing import Any, Dict, Set
+
+JSONObject = Dict[str, Any]
+
+def normalize_keys(input_data: Any) -> Any:
+    """
+    Normalize keys 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 None.
+    """
+    templates_by_prop_name: Dict[str, Set[str]] = {}
+
+    def collect_templates(node: Any) -> None:
+        if isinstance(node, list):
+            # Recurse into array items
+            for item in node:
+                collect_templates(item)
+            return
+
+        if isinstance(node, dict):
+            # For each property: if it's a dict (non-list), record its keys under that property name
+            for k, v in node.items():
+                if isinstance(v, dict):
+                    s = templates_by_prop_name.setdefault(k, set())
+                    for child_key in v.keys():
+                        s.add(child_key)
+                # Recurse
+                collect_templates(v)
+
+    def apply_templates(node: Any) -> Any:
+        if isinstance(node, list):
+            # Compute union of keys across all dict elements for this array level
+            array_union: Set[str] = set()
+            for item in node:
+                if isinstance(item, dict):
+                    array_union.update(item.keys())
+
+            normalized_list = []
+            for item in node:
+                if isinstance(item, dict):
+                    # Ensure array-level union keys
+                    next_obj: JSONObject = dict(item)
+                    for k in array_union:
+                        if k not in next_obj:
+                            next_obj[k] = None
+
+                    # Apply templates to nested dict properties
+                    for k, v in list(next_obj.items()):
+                        if isinstance(v, dict):
+                            next_obj[k] = fill_from_template(k, v)
+                        else:
+                            next_obj[k] = apply_templates(v)
+                    normalized_list.append(next_obj)
+                else:
+                    normalized_list.append(apply_templates(item))
+            return normalized_list
+
+        if isinstance(node, dict):
+            out: JSONObject = {}
+            for k, v in node.items():
+                if isinstance(v, dict):
+                    out[k] = fill_from_template(k, v)
+                else:
+                    out[k] = apply_templates(v)
+            return out
+
+        # primitives unchanged
+        return node
+
+    def fill_from_template(prop: str, obj: Any) -> Any:
+        # Recurse first so nested arrays/objects also normalize
+        base = apply_templates(obj)
+        templ = templates_by_prop_name.get(prop)
+        if not templ or not isinstance(base, dict):
+            return base
+
+        filled: JSONObject = dict(base)
+        for key in templ:
+            if key not in filled:
+                filled[key] = None
+        return filled
+
+    # Run passes
+    collect_templates(input_data)
+    return apply_templates(input_data)

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

@@ -0,0 +1,33 @@
+# pip install jsonpath-ng
+from typing import Any, List
+from jsonpath_ng.ext import parse  # ext supports more JSONPath features
+
+def is_list_of_strings_or_none(value: Any) -> bool:
+    return (
+        isinstance(value, list)
+        and all((v is None) or isinstance(v, str) for v in value)
+    )
+
+def get_json_path(payload: Any, path: str) -> List[Any]:
+    """
+    Evaluate a JSONPath against `payload`.
+
+    - If the result is a list that contains only strings and/or None,
+      convert None -> "null".
+    - Return [] when there are no matches.
+    """
+    expr = parse(path)
+    matches = [m.value for m in expr.find(payload)]  # extract raw values
+
+    if is_list_of_strings_or_none(matches):
+        matches = ["null" if v is None else v for v in matches]
+
+    # Explicitly mirror the TS return of [] for no matches
+    return matches if len(matches) > 0 else []
+
+# Optional: emulate your default export object
+payload_utils = {
+    "get_json_path": get_json_path,
+}
+
+__all__ = ["get_json_path", "payload_utils"]