ondc-code-generator 0.4.5 → 0.5.0

package/dist/generator/generators/python/templates/master-doc.mustache

@@ -0,0 +1,40 @@
+"""
+Perform Level-1 validations for a given `action`.
+
+Args:
+    action: string identifier of the action to validate against.
+    payload: Any JSON-like structure to validate (dict/list/nested).
+    config: Partial configuration. Can be:
+        - a plain dict (snake_case or camelCase keys),
+        - a dataclass/pydantic/object with fields,
+        - or a `ValidationConfig` TypedDict.
+        Missing fields are filled with defaults.
+    external_data: Optional dict of extra data available to rules.
+        `_SELF` is automatically set to the normalized payload.
+
+Config fields (merged with defaults):
+    - only_invalid (bool, default: True)
+    - hide_parent_errors (bool, default: True)
+    - _debug (bool, default: False)
+
+Returns:
+    ValidationOutput: a list of validation results, each shaped like:
+        {
+            "test_name": str,
+            "valid": bool,
+            "code": int,
+            "description"?: str,
+            "_debug_info"?: {
+            "fed_config"?: str,
+            "output_code"?: Any
+            }
+        }
+
+Raises:
+    ValueError: if the action is unknown.
+
+Example:
+    >>> out = perform_l1_validations("search", payload, {"only_invalid": False})
+    >>> out[0]["test_name"]
+    'REGEX_CONTEXT_LOCATION_CITY_CODE'
+"""

package/dist/generator/generators/python/templates/requirements.mustache

@@ -0,0 +1,2 @@
+# requirements.txt
+jsonpath-ng>=1.6.0

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

@@ -0,0 +1,62 @@
+from typing import Dict, Any, List
+from typing import TypedDict, Optional
+
+
+# External data type definitions
+ExternalData = Dict[str, Any]
+
+
+class ValidationConfig(TypedDict, total=False):
+    """Config options for validations.
+    Attributes:
+        only_invalid (bool): If True, only invalid results will be returned.
+        hide_parent_errors (Optional[bool]): If True, parent errors will be hidden.
+        _debug (Optional[bool]): If True, debug mode will be enabled.
+    """
+    only_invalid: Optional[bool]
+    hide_parent_errors: Optional[bool]
+    _debug: Optional[bool]
+
+# Input structure for validation functions
+ValidationInput = Dict[str, Any]
+
+class DebugInfo(TypedDict, total=False):
+    """
+    Diagnostic information useful for debugging.
+
+    Attributes:
+        fed_config: The configuration used to generate the validation.
+        output_code: The identifier/code of the validation rule that was executed.
+    """
+    fed_config: Any
+    output_code: Any
+
+
+class ValidationResult(TypedDict, total=False):
+    """
+    Represents the output of a single validation test.
+
+    Attributes:
+        test_name: The name of the validation test.
+        valid: Whether the test passed (True) or failed (False).
+        code: Numeric code representing the result or error type.
+        description: Optional. Additional details about the test result.
+        _debug_info: Optional. Diagnostic information useful for debugging.
+    """
+    test_name: str
+    valid: bool
+    code: int
+    description: Optional[str]
+    _debug_info: Optional[DebugInfo]
+
+
+# Represents the output of a validation run:
+# a list of individual validation results.
+ValidationOutput = List[ValidationResult]
+
+# Test function array type
+TestFunctionArray = List[callable]
+
+{{#externalData}}
+# {{name}}: Any
+{{/externalData}}

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

@@ -0,0 +1,29 @@
+def {{name}}(input_data):
+    scope = payload_utils["get_json_path"](input_data["payload"], "{{{scopePath}}}")
+    sub_results = []
+    valid = True
+
+    for {{testName}}_obj in scope:
+        {{testName}}_obj["_EXTERNAL"] = input_data["external_data"]
+{{#variables}}
+        {{name}} = {{{value}}}
+{{/variables}}
+        
+{{#hasContinue}}
+        skip_check = {{{skipCheckStatement}}}
+        if skip_check:
+            continue
+{{/hasContinue}}
+
+{{{validationCode}}}
+        # del {{testName}}_obj["_EXTERNAL"]
+
+    return [{
+        "test_name": "{{testName}}",
+        "valid": valid,
+        "code": {{successCode}} if valid else {{errorCode}}, 
+        "_debug_info": {
+            "fed_config": r"""
+{{{TEST_OBJECT}}}
+"""
+    }}] + sub_results

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

@@ -0,0 +1,35 @@
+{{#isNested}}
+{{{nestedFunctions}}}
+
+        test_functions = [
+    {{#names}}
+            {{name}},
+    {{/names}}
+        ]
+
+        all_results = []
+        for fn in test_functions:
+            sub_result = fn(input_data)
+            all_results.extend(sub_result)
+
+
+        sub_results = all_results
+        valid = all(r["valid"] for r in sub_results)
+{{/isNested}}
+{{^isNested}}
+        validate = {{{returnStatement}}}
+
+        if not validate:
+            del {{testName}}_obj["_EXTERNAL"]
+            return [{
+                "test_name": "{{testName}}",
+                "valid": False,
+                "code": {{errorCode}},
+                "description": r"""{{{errorDescription}}}""",
+                "_debug_info": {
+                    "fed_config": r"""
+{{{TEST_OBJECT}}}
+"""
+                }
+            }]
+{{/isNested}}

package/dist/generator/generators/python/templates/validation-utils.mustache

@@ -0,0 +1,93 @@
+import re
+from datetime import datetime
+from typing import List
+
+def are_unique(operand: List[str]) -> bool:
+    return len(set(operand)) == len(operand)
+
+def are_present(operand: List[str]) -> bool:
+    return none_in(operand, ["null", "undefined", None]) and len(operand) > 0
+
+def all_in(left: List[str], right: List[str]) -> bool:
+    if len(left) == 0 and len(right) != 0:
+        return False
+    return all(v in right for v in left)
+
+def any_in(left: List[str], right: List[str]) -> bool:
+    if len(left) == 0 and len(right) != 0:
+        return False
+    return any(v in right for v in left)
+
+def none_in(left: List[str], right: List[str]) -> bool:
+    return all(v not in right for v in left)
+
+def equal_to(left: List[str], right: List[str]) -> bool:
+    if len(left) != len(right):
+        return False
+    return all(v == right[i] for i, v in enumerate(left))
+
+def is_iso8601(s: str) -> bool:
+    iso8601_regex = r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$'
+    if not re.match(iso8601_regex, s):
+        return False
+    try:
+        datetime.fromisoformat(s.replace('Z', '+00:00'))
+        return True
+    except ValueError:
+        return False
+
+def greater_than(left: List[str], right: List[str]) -> bool:
+    def are_all_iso(arr): return all(is_iso8601(v) for v in arr)
+    def are_all_numbers(arr): return all(is_number(v) for v in arr)
+
+    if are_all_iso(left) and are_all_iso(right):
+        left_dates = [datetime.fromisoformat(d.replace('Z', '+00:00')).timestamp() for d in left]
+        right_dates = [datetime.fromisoformat(d.replace('Z', '+00:00')).timestamp() for d in right]
+        return all(ld > right_dates[i] if i < len(right_dates) else True for i, ld in enumerate(left_dates))
+    elif are_all_numbers(left) and are_all_numbers(right):
+        left_numbers = [float(n) for n in left]
+        right_numbers = [float(n) for n in right]
+        return all(ln > right_numbers[i] if i < len(right_numbers) else True for i, ln in enumerate(left_numbers))
+    return False
+
+def less_than(left: List[str], right: List[str]) -> bool:
+    def are_all_iso(arr): return all(is_iso8601(v) for v in arr)
+    def are_all_numbers(arr): return all(is_number(v) for v in arr)
+
+    if are_all_iso(left) and are_all_iso(right):
+        left_dates = [datetime.fromisoformat(d.replace('Z', '+00:00')).timestamp() for d in left]
+        right_dates = [datetime.fromisoformat(d.replace('Z', '+00:00')).timestamp() for d in right]
+        return all(ld < right_dates[i] if i < len(right_dates) else True for i, ld in enumerate(left_dates))
+    elif are_all_numbers(left) and are_all_numbers(right):
+        left_numbers = [float(n) for n in left]
+        right_numbers = [float(n) for n in right]
+        return all(ln < right_numbers[i] if i < len(right_numbers) else True for i, ln in enumerate(left_numbers))
+    return False
+
+def follow_regex(left: List[str], regex_array: List[str]) -> bool:
+    if len(left) == 0 and len(regex_array) != 0:
+        return False
+    for regex in regex_array:
+        re_obj = re.compile(regex)
+        if any(not re_obj.match(v) for v in left):
+            return False
+    return True
+
+def is_number(s: str) -> bool:
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+validation_utils = {
+    "are_unique": are_unique,
+    "are_present": are_present,
+    "all_in": all_in,
+    "any_in": any_in,
+    "none_in": none_in,
+    "equal_to": equal_to,
+    "follow_regex": follow_regex,
+    "greater_than": greater_than,
+    "less_than": less_than,
+}

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

@@ -4,4 +4,32 @@ import { testFunctionArray, validationInput, validationOutput } from "../types/t
 
 
 
-export default {{{functionCode}}}
+export default function {{apiName}}(input: validationInput): validationOutput{
+
+    let totalResults = {{apiName}}Validations(input);
+
+    if (input.config._debug === false) {
+		totalResults.forEach((r) => {
+			delete r._debugInfo;
+		});
+	}
+	if(input.config.hideParentErrors === true) {
+		// delete results with valid false and no description
+		totalResults = totalResults.filter((r) => !(r.valid === false && !r.description));
+	}
+	if (input.config.onlyInvalid === true) {
+		const res = totalResults.filter((r) => r.valid === false);
+		if(res.length === 0) {
+			const targetSuccess = totalResults.find((r) => r.testName === "{{apiName}}_validations");
+			if(!targetSuccess) {
+				throw new Error("Critical: Overall test result not found");
+			}
+			return [targetSuccess];
+		}
+		return res;
+	}
+
+    return totalResults;
+}
+
+{{{functionCode}}}

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

@@ -0,0 +1,33 @@
+{{{importsCode}}}
+
+/**
+ * Perform Level-1 validations against a payload for a given action.
+ *
+ * @remarks
+ * **Output shape** — {@link validationOutput} is an array of:
+ * - `testName: string`
+ * - `valid: boolean`
+ * - `code: number`
+ * - `description?: string`
+ * - `_debugInfo?: { fedConfig?: string; outputCode?: unknown }`
+ *
+ * **Config** — {@link ValidationConfig} (partial accepted here):
+ * - `onlyInvalid` (default `true`)
+ * - `hideParentErrors` (default `true`)
+ * - `_debug` (default `false`)
+ *
+ * @param action - One of {@link Action}.
+ * @param payload - The JSON payload to validate.
+ * @param config - Partial {@link ValidationConfig}. Merged with defaults.
+ * @param externalData - Extra data accessible to rules (we set `_SELF` to the normalized payload).
+ * @returns {@link validationOutput}
+ *
+ * @example
+ * ```ts
+ * import { performL1_validations } from "@your/pkg";
+ *
+ * const out = performL1_validations("search", payload, { onlyInvalid: false });
+ * // e.g. out[0] => { testName, valid, code, description?, _debugInfo? }
+ * ```
+ */
+ {{{masterFunction}}}

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

@@ -1,36 +1,101 @@
-export default function normalizeKeys(obj: any) {
-	if (Array.isArray(obj)) {
-		// Find all keys across all objects in the array
-		const allKeys = new Set();
-		obj.forEach((item) => {
-			if (typeof item === "object" && item !== null) {
-				Object.keys(item).forEach((key) => allKeys.add(key));
-			}
-		});
-
-		// Add missing keys with null
-		return obj.map((item) => {
-			if (typeof item === "object" && item !== null) {
-				const newItem = { ...item };
-				allKeys.forEach((key: any) => {
-					if (!(key in newItem)) {
-						newItem[key] = null;
-					}
-				});
-				// Recursively normalize nested objects/arrays
-				for (const k in newItem) {
-					newItem[k] = normalizeKeys(newItem[k]);
-				}
-				return newItem;
-			}
-			return item;
-		});
-	} else if (typeof obj === "object" && obj !== null) {
-		const newObj: any = {};
-		for (const key in obj) {
-			newObj[key] = normalizeKeys(obj[key]);
-		}
-		return newObj;
-	}
-	return obj; // primitive values
-}
+type JSONObject = Record<string, any>;
+
+/**
+ * Normalize keys so that:
+ *  - All objects with the same property name (e.g., "price") 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 `null`.
+ */
+export default function normalizeKeys(input: any): any {
+  // 1) Collect templates by property name: e.g., "price" -> Set<"currency" | "value" | ...>
+  const templatesByPropName: Record<string, Set<string>> = Object.create(null);
+
+  const collectTemplates = (node: any): void => {
+    if (Array.isArray(node)) {
+      // Recurse into array items
+      node.forEach(collectTemplates);
+
+      // Also collect a per-array union (used later when applying)
+      // We won't store this globally; we'll recompute per-array on apply.
+      return;
+    }
+    if (node && typeof node === "object") {
+      // For each property: if it's an object (non-array), record its keys under the property name
+      for (const [k, v] of Object.entries(node)) {
+        if (v && typeof v === "object" && !Array.isArray(v)) {
+          const set = (templatesByPropName[k] ||= new Set<string>());
+          Object.keys(v).forEach((childKey) => set.add(childKey));
+        }
+        collectTemplates(v);
+      }
+    }
+  };
+
+  // 2) Apply templates and within-array unions
+  const applyTemplates = (node: any): any => {
+    if (Array.isArray(node)) {
+      // Compute union of keys across all object elements for this array level
+      const arrayUnion = new Set<string>();
+      for (const item of node) {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          Object.keys(item).forEach((k) => arrayUnion.add(k));
+        }
+      }
+
+      return node.map((item) => {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          // Ensure array-level union keys
+          const next: JSONObject = { ...item };
+          arrayUnion.forEach((k) => {
+            if (!(k in next)) next[k] = null;
+          });
+
+          // Now apply templates per property name for nested objects
+          for (const [k, v] of Object.entries(next)) {
+            // If this property holds an object, align it to the template for that property name
+            if (v && typeof v === "object" && !Array.isArray(v)) {
+              next[k] = fillFromTemplate(k, v);
+            } else {
+              next[k] = applyTemplates(v);
+            }
+          }
+          return next;
+        }
+        return applyTemplates(item);
+      });
+    }
+
+    if (node && typeof node === "object") {
+      const out: JSONObject = {};
+      for (const [k, v] of Object.entries(node)) {
+        if (v && typeof v === "object" && !Array.isArray(v)) {
+          // Align object to the template for this property name (k)
+          out[k] = fillFromTemplate(k, v);
+        } else {
+          out[k] = applyTemplates(v);
+        }
+      }
+      return out;
+    }
+
+    return node; // primitives unchanged
+  };
+
+  // Helper: apply the template for a given property name `prop`
+  const fillFromTemplate = (prop: string, obj: any): any => {
+    const templ = templatesByPropName[prop];
+    // Recurse first on children so nested arrays/objects also normalize
+    const base: JSONObject = applyTemplates(obj);
+    if (!templ) return base; // no known template keys for this prop
+
+    const filled: JSONObject = { ...base };
+    templ.forEach((k) => {
+      if (!(k in filled)) filled[k] = null;
+    });
+    return filled;
+  };
+
+  // Run passes
+  collectTemplates(input);
+  return applyTemplates(input);
+}

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

@@ -1,14 +1,54 @@
-
+/**
+ * Configuration options for running validation routines.
+ *
+ * @property onlyInvalid - If true, only invalid results will be returned.
+ * @property hideParentErrors - Optional. Hides nested error details if set to true.
+ * @property _debug - Optional. Enables debug mode for additional diagnostic information.
+ */
 export interface ValidationConfig {
-    runAllValidations: boolean;
+	onlyInvalid: boolean;
+  hideParentErrors: boolean;
+	_debug: boolean;
 }
 
+
+/**
+ * Represents the output of a validation run.
+ *
+ * Each element in the array corresponds to a single validation test result.
+ *
+ * Object shape:
+ * ```ts
+ * {
+ *   testName: string;
+ *   valid: boolean;
+ *   code: number;
+ *   description?: string;
+ *   _debugInfo?: {
+ *     fedConfig: any;
+ *   };
+ * }
+ * ```
+ *
+ * ### Properties
+ * - **testName** — The name of the validation test.
+ * - **valid** — Whether the test passed (`true`) or failed (`false`).
+ * - **code** — Numeric code representing the result or error type.
+ * - **description** — *(Optional)* Additional details about the test result.
+ * - **_debugInfo** — *(Optional)* Diagnostic information useful for debugging.
+ *   - **fedConfig** — The configuration used to generate the validation.
+ */
 export type validationOutput = {
-	valid: boolean;
-	code: number;
-	description?: string;
+  testName: string;
+  valid: boolean;
+  code: number;
+  description?: string;
+  _debugInfo?: {
+    fedConfig: any;
+  };
 }[];
 
+
 /*
 {% comment %} export type ExternalData = {
     {{#externalData}}

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

@@ -16,5 +16,15 @@ function {{name}}(input: validationInput): validationOutput {
         {{{validationCode}}}
         delete testObj._EXTERNAL;
     }
-    return [{valid: valid,code: {{successCode}} },...subResults];
+    return [{
+        testName: "{{testName}}",
+        valid: valid,
+        code: valid ? {{successCode}} : {{errorCode}},
+        _debugInfo: {
+            fedConfig: 
+`
+{{{TEST_OBJECT}}}
+`,
+        }
+    },...subResults];
 }

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

@@ -9,20 +9,13 @@ const testFunctions: testFunctionArray = [
     {{/names}}
 ];
 
-let invalidResults: validationOutput = [];
+let allResults : validationOutput = [];
 for (const fn of testFunctions) {
     const subResult = fn(input);
-    // .filter(r => !r.valid);
-    invalidResults = [...invalidResults, ...subResult];
-    if(!input.config.runAllValidations && invalidResults.length > 0) {
-        return invalidResults;
-    }
-}
-if(invalidResults.length > 0) {
-    // return invalidResults;
-    subResults = invalidResults;
-    valid = subResults.every(r => r.valid);
+    allResults  = [...allResults , ...subResult];
 }
+subResults = allResults ;
+valid = subResults.every((r) => r.valid);
 
 {{/isNested}}
 
@@ -32,9 +25,16 @@ const validate = {{{returnStatement}}}
 if(!validate){
     delete testObj._EXTERNAL;
     return [{
+        testName: "{{testName}}",
         valid: false,
         code: {{errorCode}},
-        description: `{{{errorDescription}}}`
+        description: `{{{errorDescription}}}`,
+        _debugInfo: {
+            fedConfig: 
+`
+{{{TEST_OBJECT}}}
+`,
+        }
     }]
 }
 {{/isNested}}