ondc-code-generator 0.5.51 → 0.6.0

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

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

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

@@ -1,7 +1,7 @@
 import { readFileSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { ConfigSyntax, TestObjectSyntax } from "../../../constants/syntax.js";
+import { ConfigSyntax, TestObjectSyntax, ExternalDataSyntax, } 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";
@@ -9,13 +9,60 @@ 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";
+import { collectLoadData } from "../../../utils/config-utils/load-variables.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.");
+            if (!this.codeConfig) {
+                throw new Error("Code config not set. Please call generateCode first.");
+            }
+            const sessionData = this.validationConfig[ConfigSyntax.SessionData];
+            const tests = this.validationConfig[ConfigSyntax.Tests];
+            const relevantSessionData = {};
+            collectLoadData(tests, relevantSessionData);
+            console.log("Relevant Session Data for Loading:", relevantSessionData);
+            const sessionDataUtilsTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/save-utils.mustache"), "utf-8");
+            const storageInterfaceTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-interface.mustache"), "utf-8");
+            const storageTypesTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-types.mustache"), "utf-8");
+            const indexTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/index.mustache"), "utf-8");
+            const saveActionTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/api-save.mustache"), "utf-8");
+            const allActions = Object.keys(tests);
+            const indexCode = Mustache.render(indexTemplate, {
+                actions: Array.from(allActions).map((action) => {
+                    return { action: action };
+                }),
+                functionName: this.codeConfig.codeName.replace(/[^a-zA-Z0-9_]/g, ""),
+            });
+            // Generate individual action files
+            for (const action of allActions) {
+                const loadData = relevantSessionData[action] || {};
+                const saveData = sessionData[action] || {};
+                const saveCode = Mustache.render(saveActionTemplate, {
+                    storeActions: Object.keys(saveData).map((key) => {
+                        return {
+                            key: key,
+                            value: saveData[key],
+                        };
+                    }),
+                    loadActions: Object.keys(loadData).map((key) => {
+                        console.log(loadData[key]);
+                        return {
+                            key: loadData[key],
+                        };
+                    }),
+                    action: action,
+                });
+                await writeAndFormatCode(this.rootPath, `./storage_actions/${action}.py`, saveCode, "python");
+            }
+            // Generate utility and interface files
+            await writeAndFormatCode(this.rootPath, "./utils/save_utils.py", sessionDataUtilsTemplate, "python");
+            await writeAndFormatCode(this.rootPath, "./types/storage_types.py", storageTypesTemplate, "python");
+            await writeAndFormatCode(this.rootPath, "./interfaces/storage_interface.py", storageInterfaceTemplate, "python");
+            await writeAndFormatCode(this.rootPath, "./storage_actions/__init__.py", indexCode, "python");
+            await writeAndFormatCode(this.rootPath, "./interfaces/__init__.py", "# Interfaces package", "python");
         };
         this.generateValidationCode = async () => {
             const testConfig = this.validationConfig[ConfigSyntax.Tests];
@@ -35,6 +82,7 @@ export class PythonGenerator extends CodeGenerator {
             }
         };
         this.generateCode = async (codeConfig) => {
+            this.codeConfig = codeConfig;
             const jsonPathUtilsCode = readFileSync(path.resolve(__dirname, "./templates/json-path-utils.mustache"), "utf-8");
             const validationUtils = readFileSync(path.resolve(__dirname, "./templates/validation-utils.mustache"), "utf-8");
             const typesTemplate = readFileSync(path.resolve(__dirname, "./templates/test-config.mustache"), "utf-8");
@@ -61,6 +109,7 @@ export class PythonGenerator extends CodeGenerator {
             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();
+            await this.generateSessionDataCode();
         };
         this.generateTestFunction = async (testObject) => {
             const template = readFileSync(path.resolve(__dirname, "./templates/test-object.mustache"), "utf-8");
@@ -89,8 +138,21 @@ export class PythonGenerator extends CodeGenerator {
             const skipList = skip ? [skip] : undefined;
             if (typeof testObject[TestObjectSyntax.Return] === "string") {
                 const returnStatement = compileInputToPy(testObject[TestObjectSyntax.Return]);
+                // Check if this is a stateful validation
+                let isStateFull = false;
+                for (const k in testObject) {
+                    const value = testObject[k];
+                    if (typeof value === "string") {
+                        if (value.includes(`${ExternalDataSyntax}.`) &&
+                            !value.includes("_SELF")) {
+                            isStateFull = true;
+                            break;
+                        }
+                    }
+                }
                 return Mustache.render(template, {
                     isNested: false,
+                    isStateFull: isStateFull,
                     returnStatement: returnStatement,
                     errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
                     errorDescription: this.CreateErrorMarkdown(testObject, skipList),
@@ -117,6 +179,7 @@ export class PythonGenerator extends CodeGenerator {
                     nestedFunctions: indentedNestedFunctions,
                     names: names,
                     errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
+                    testName: testObject[TestObjectSyntax.Name],
                     TEST_OBJECT: `${JSON.stringify(testObject)}`,
                 });
             }
@@ -203,9 +266,10 @@ ${errorsList}
             .map((api) => `from .api_tests import ${api}`)
             .join("\n");
         importsCode += `\nfrom .types.test_config import ValidationConfig\n`;
+        importsCode += `\nfrom .storage_actions import perform_${functionName.toLowerCase()}_save, perform_${functionName.toLowerCase()}_load\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):
+def perform_${functionName.toLowerCase()}(action, payload, config: ValidationConfig = None, external_data=None):
     ${masterDoc}
 
     if external_data is None:
@@ -219,6 +283,7 @@ def perform_${functionName.toLowerCase()}(action, payload,config: ValidationConf
         "standard_logs": False,
         "_debug": False,
         "hide_parent_errors": True,
+        "state_full_validations": False,
     }
     # Merge user config with default config
     if config is None:
@@ -226,6 +291,21 @@ def perform_${functionName.toLowerCase()}(action, payload,config: ValidationConf
     else:
         config = {**default_config, **config}
 
+    if config.get("state_full_validations") and not config.get("store"):
+        raise Exception(
+            "State Full validations require a storage interface to be provided in the config."
+        )
+    
+    if config.get("state_full_validations") and not config.get("unique_key"):
+        raise Exception(
+            "State Full validations require a unique_key to be provided in the config."
+        )
+
+    if config.get("state_full_validations"):
+        import asyncio
+        load_data = asyncio.run(perform_${functionName.toLowerCase()}_load(action, config["unique_key"], config["store"]))
+        external_data = {**load_data, **external_data}
+
     input_data = {
         "payload": normalized_payload,
         "external_data": external_data,

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

@@ -1,2 +1,3 @@
 # requirements.txt
 jsonpath-ng>=1.6.0
+typing-extensions>=4.0.0

package/dist/generator/generators/python/templates/storage-templates/api-save.mustache

@@ -0,0 +1,41 @@
+from ..utils.json_path_utils import get_json_path
+from ..utils.save_utils import save_data, load_function
+from ..interfaces.storage_interface import StorageInterface
+from ..types.storage_types import StorageConfig
+import json
+from datetime import datetime
+
+async def store_{{action}}(unique_prefix: str, payload: dict, store: StorageInterface, config: StorageConfig):
+    {{#storeActions}}
+    await save_function(payload, unique_prefix, "{{{key}}}", "{{{value}}}", store, config)
+    {{/storeActions}}
+
+async def load_for_{{action}}(unique_prefix: str, store: StorageInterface):
+    return {
+        {{#loadActions}}
+        "{{{key}}}": await load_function(store, unique_prefix, "{{{key}}}"),
+        {{/loadActions}}
+    }
+
+async def save_function(payload: dict, unique_prefix: str, key: str, path: str, store: StorageInterface, config: StorageConfig):
+    if path == "" or key == "_SELF":
+        return
+    
+    value = get_json_path(payload, path)
+    data = {
+        "stored_from": "{{action}}_action",
+        "key_path": path,
+        "value": value,
+        "timestamp": datetime.now().isoformat()
+    }
+    data_string = json.dumps(data)
+    await save_data(unique_prefix, key, data_string, store, config)
+
+async def load_function(store: StorageInterface, unique_prefix: str, key: str):
+    try:
+        value = await store.get_key(unique_prefix, key)
+        if not value:
+            return []
+        return json.loads(value)["value"]
+    except Exception:
+        return []

package/dist/generator/generators/python/templates/storage-templates/index.mustache

@@ -0,0 +1,40 @@
+{{#actions}}
+from .{{{action}}} import store_{{{action}}}, load_for_{{{action}}}
+{{/actions}}
+from ..interfaces.storage_interface import StorageInterface
+from ..types.storage_types import StorageConfig
+from typing import Optional, Dict, Any
+
+async def perform_{{functionName}}_save(action: str, unique_prefix: str, payload: Dict[Any, Any], store: StorageInterface, config: Optional[StorageConfig] = None):
+    complete_config: StorageConfig = {
+        "retry_attempts": 3,
+        "retry_delay_ms": 1000,
+        **(config or {})
+    }
+    
+    {{#actions}}
+    {{#-first}}
+    if action == "{{{action}}}":
+        return await store_{{{action}}}(unique_prefix, payload, store, complete_config)
+    {{/-first}}
+    {{^-first}}
+    elif action == "{{{action}}}":
+        return await store_{{{action}}}(unique_prefix, payload, store, complete_config)
+    {{/-first}}
+    {{/actions}}
+    else:
+        raise Exception("Action not found")
+
+async def perform_{{functionName}}_load(action: str, unique_prefix: str, store: StorageInterface):
+    {{#actions}}
+    {{#-first}}
+    if action == "{{{action}}}":
+        return await load_for_{{{action}}}(unique_prefix, store)
+    {{/-first}}
+    {{^-first}}
+    elif action == "{{{action}}}":
+        return await load_for_{{{action}}}(unique_prefix, store)
+    {{/-first}}
+    {{/actions}}
+    else:
+        raise Exception("Action not found")

package/dist/generator/generators/python/templates/storage-templates/save-utils.mustache

@@ -0,0 +1,22 @@
+from ..interfaces.storage_interface import StorageInterface
+from ..types.storage_types import StorageConfig
+import asyncio
+
+async def save_data(unique_prefix: str, key: str, save_data: str, store: StorageInterface, config: StorageConfig):
+    final_key = f"{unique_prefix}:{key}"
+    retry_times = config["retry_attempts"]
+    delay_ms = config["retry_delay_ms"]
+    attempts = 0
+    
+    while attempts < retry_times:
+        try:
+            await store.save_key(unique_prefix, final_key, save_data)
+            return
+        except Exception as e:
+            attempts += 1
+            if attempts >= retry_times:
+                raise e
+            await asyncio.sleep(delay_ms / 1000.0)  # Convert ms to seconds
+
+def create_key(unique_prefix: str, key: str):
+    return f"{unique_prefix}:{key}"

package/dist/generator/generators/python/templates/storage-templates/storage-interface.mustache

@@ -0,0 +1,93 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+class StorageInterface(ABC):
+    """
+    Storage interface for persisting and retrieving key-value data.
+    
+    Purpose — Provides a standardized abstraction layer for storage operations
+    that can be implemented by different storage backends (Redis, Memory, File, etc.).
+    
+    Implementation Notes:
+    - All operations are asynchronous and return coroutines
+    - Keys should be strings and values are stored as strings
+    - Implementations should handle serialization/deserialization as needed
+    - Prefix-based operations allow for namespacing and bulk operations
+    """
+    
+    @abstractmethod
+    async def save_key(self, unique_prefix: str, key: str, value: str) -> None:
+        """
+        Save a key-value pair to storage with a unique prefix for namespacing.
+        
+        Args:
+            unique_prefix: A unique identifier/namespace prefix to prevent key collisions
+            key: The unique identifier for the stored value within the prefix namespace
+            value: The string value to store
+        """
+        pass
+    
+    @abstractmethod
+    async def get_key(self, unique_prefix: str, key: str) -> str:
+        """
+        Retrieve a value by its key from storage within a specific namespace.
+        
+        Args:
+            unique_prefix: The unique identifier/namespace prefix used when storing
+            key: The unique identifier for the value to retrieve within the prefix namespace
+            
+        Returns:
+            The stored value as a string
+            
+        Raises:
+            Exception if the key does not exist
+        """
+        pass
+    
+    @abstractmethod
+    async def delete_key(self, unique_prefix: str, key: str) -> None:
+        """
+        Remove a key-value pair from storage within a specific namespace.
+        
+        Args:
+            unique_prefix: The unique identifier/namespace prefix used when storing
+            key: The unique identifier for the value to delete within the prefix namespace
+        """
+        pass
+    
+    @abstractmethod
+    async def list_keys(self, unique_prefix: str) -> List[str]:
+        """
+        List all keys within a specific namespace/prefix.
+        
+        Args:
+            unique_prefix: The unique identifier/namespace prefix to list keys from
+            
+        Returns:
+            A list of keys within that namespace
+        """
+        pass
+    
+    @abstractmethod
+    async def clear_storage(self) -> None:
+        """
+        Clear all stored data from the storage backend.
+        
+        Warning: This operation is destructive and cannot be undone.
+        Use with caution, especially in production environments.
+        """
+        pass
+    
+    @abstractmethod
+    async def key_exists(self, unique_prefix: str, key: str) -> bool:
+        """
+        Check if a key exists in storage within a specific namespace.
+        
+        Args:
+            unique_prefix: The unique identifier/namespace prefix to check within
+            key: The unique identifier to check for existence within the prefix namespace
+            
+        Returns:
+            True if the key exists, False otherwise
+        """
+        pass

package/dist/generator/generators/python/templates/storage-templates/storage-types.mustache

@@ -0,0 +1,5 @@
+from typing import TypedDict
+
+class StorageConfig(TypedDict):
+    retry_attempts: int
+    retry_delay_ms: int

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

@@ -12,10 +12,16 @@ class ValidationConfig(TypedDict, total=False):
         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.
+        state_full_validations (Optional[bool]): If True, stateful validations will be enabled.
+        store (Optional[Any]): Storage interface for stateful validations.
+        unique_key (Optional[str]): Unique key for stateful validations.
     """
     only_invalid: Optional[bool]
     hide_parent_errors: Optional[bool]
     _debug: Optional[bool]
+    state_full_validations: Optional[bool]
+    store: Optional[Any]
+    unique_key: Optional[str]
 
 # Input structure for validation functions
 ValidationInput = Dict[str, Any]

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

@@ -17,10 +17,18 @@
         valid = all(r["valid"] for r in sub_results)
 {{/isNested}}
 {{^isNested}}
+        {{#isStateFull}}
+        validate = True
+        if input_data["config"].get("state_full_validations") == True:
+            validate = {{{returnStatement}}}
+        {{/isStateFull}}
+        
+        {{^isStateFull}}
         validate = {{{returnStatement}}}
+        {{/isStateFull}}
 
         if not validate:
-            del {{testName}}_obj["_EXTERNAL"]
+            # del {{testName}}_obj["_EXTERNAL"]
             return [{
                 "test_name": "{{testName}}",
                 "valid": False,

package/dist/generator/generators/typescript/templates/storage-templates/api-save.mustache

@@ -0,0 +1,58 @@
+import payloadUtils from "../utils/json-path-utils";
+import saveUtils from "../utils/save-utils";
+import StorageInterface from "../interfaces/storage-interface";
+import { StorageConfig } from "../types/storage-types";
+
+export async function store_{{action}}(
+    uniquePrefix: string,
+    payload: any,
+    store: StorageInterface,
+    config: StorageConfig
+){  
+    {{#storeActions}}
+    await saveFunction(payload,uniquePrefix,"{{{key}}}", "{{{value}}}", store, config);
+    {{/storeActions}}
+}
+
+export async function loadFor_{{action}}(
+    uniquePrefix: string,
+    store: StorageInterface
+) {
+    return {
+        {{#loadActions}}
+        {{{key}}}: await loadFunction(store, uniquePrefix, "{{{key}}}"),
+        {{/loadActions}}
+    };
+}
+
+async function saveFunction(payload: any,uniquePrefix: string, key: string, path: string, store: StorageInterface,
+config: StorageConfig): Promise<void> {
+    if(path === "" || key === "_SELF"){
+        return;
+    }
+    const value = payloadUtils.getJsonPath(payload, path);
+    const data = {
+        stored_from: "{{action}}_action",
+        key_path: path,
+        value: value,
+        timestamp: new Date().toISOString(),
+    };
+    const dataString = JSON.stringify(data);
+    await saveUtils.saveData(uniquePrefix, key, dataString, store, config);
+}
+
+async function loadFunction(
+    store: StorageInterface,
+    uniquePrefix: string,
+    key: string
+): Promise<any[] | []> {
+    try {
+        const value = await store.getKey(uniquePrefix, key);
+        if (!value) {
+            return [];
+        }
+        return JSON.parse(value).value;
+    } catch (err) {
+        return [];
+    }
+}

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

@@ -0,0 +1,37 @@
+{{#actions}}
+    import { store_{{{action}}}, loadFor_{{{action}}} } from './{{{action}}}'
+{{/actions}}
+import StorageInterface from "../interfaces/storage-interface";
+import { StorageConfig } from "../types/storage-types";
+
+export async function perform{{functionName}}Save(action: string,uniquePrefix: string, payload: any, store: StorageInterface,
+config?: Partial<StorageConfig>){
+    
+    const completeConfig : StorageConfig = {
+        ...{
+            retryAttempts: 3,
+            retryDelayMs: 1000,
+        },
+        ...config
+    }
+    switch(action){
+        {{#actions}}
+        case '{{{action}}}':
+            return await store_{{{action}}}(uniquePrefix,payload,store,completeConfig);
+        {{/actions}}
+        default:
+            throw new Error('Action not found');
+    }
+}
+
+
+export async function perform{{functionName}}Load(action: string,uniquePrefix: string, store: StorageInterface){
+    switch(action){
+        {{#actions}}
+        case '{{{action}}}':
+            return await loadFor_{{{action}}}(uniquePrefix,store);
+        {{/actions}}
+        default:
+            throw new Error('Action not found');
+    }
+}

package/dist/generator/generators/typescript/templates/storage-templates/save-utils.mustache

@@ -0,0 +1,39 @@
+import StorageInterface from "../interfaces/storage-interface";
+import { StorageConfig } from "../types/storage-types";
+async function saveData(
+    uniquePrefix: string,
+    key: string,
+    saveData: string,
+    store: StorageInterface,
+    config: StorageConfig
+){
+    const finalKey = `${uniquePrefix}:${key}`;
+    const retryTimes = config.retryAttempts;
+    const delayMs = config.retryDelayMs;
+    let attempts = 0;
+    while(attempts < retryTimes){
+        try{
+            await store.saveKey(uniquePrefix, finalKey, saveData);
+            return;
+        }catch(e){
+            attempts++;
+            if(attempts >= retryTimes){
+                throw e;
+            }
+            await new Promise(res => setTimeout(res,delayMs));
+        }
+    }
+
+}
+
+function createKey(
+    uniquePrefix: string,
+    key: string
+){
+    return `${uniquePrefix}:${key}`;
+}
+
+export default {
+    saveData,
+    createKey
+}

package/dist/generator/generators/typescript/templates/storage-templates/storage-interface.mustache

@@ -0,0 +1,121 @@
+/**
+ * Storage interface for persisting and retrieving key-value data.
+ *
+ * @remarks
+ * **Purpose** — Provides a standardized abstraction layer for storage operations
+ * that can be implemented by different storage backends (Redis, Memory, File, etc.).
+ *
+ * **Implementation Notes**:
+ * - All operations are asynchronous and return Promises
+ * - Keys should be strings and values are stored as strings
+ * - Implementations should handle serialization/deserialization as needed
+ * - Prefix-based operations allow for namespacing and bulk operations
+ *
+ * @example
+ * ```ts
+ * class RedisStorage implements StorageInterface {
+ *   async saveKey(uniquePrefix: string, key: string, value: string): Promise<void> {
+ *     const fullKey = `${uniquePrefix}:${key}`;
+ *     await this.redisClient.set(fullKey, value);
+ *   }
+ *   // ... other methods
+ * }
+ *
+ * const storage = new RedisStorage();
+ * await storage.saveKey("app1", "user:123", JSON.stringify(userData));
+ * const user = JSON.parse(await storage.getKey("app1", "user:123"));
+ * ```
+ */
+export default interface StorageInterface {
+	/**
+	 * Save a key-value pair to storage with a unique prefix for namespacing.
+	 *
+	 * @param uniquePrefix - A unique identifier/namespace prefix to prevent key collisions
+	 * @param key - The unique identifier for the stored value within the prefix namespace
+	 * @param value - The string value to store
+	 * @returns Promise that resolves when the operation completes
+	 *
+	 * @example
+	 * ```ts
+	 * await storage.saveKey("app1", "session:abc123", JSON.stringify(sessionData));
+	 * ```
+	 */
+	saveKey(uniquePrefix: string, key: string, value: string): Promise<void>;
+
+	/**
+	 * Retrieve a value by its key from storage within a specific namespace.
+	 *
+	 * @param uniquePrefix - The unique identifier/namespace prefix used when storing
+	 * @param key - The unique identifier for the value to retrieve within the prefix namespace
+	 * @returns Promise that resolves to the stored value
+	 * @throws Should throw an error if the key does not exist
+	 *
+	 * @example
+	 * ```ts
+	 * const sessionData = await storage.getKey("app1", "session:abc123");
+	 * ```
+	 */
+	getKey(uniquePrefix: string, key: string): Promise<string>;
+
+	/**
+	 * Remove a key-value pair from storage within a specific namespace.
+	 *
+	 * @param uniquePrefix - The unique identifier/namespace prefix used when storing
+	 * @param key - The unique identifier for the value to delete within the prefix namespace
+	 * @returns Promise that resolves when the deletion completes
+	 *
+	 * @example
+	 * ```ts
+	 * await storage.deleteKey("app1", "session:abc123");
+	 * ```
+	 */
+	deleteKey(uniquePrefix: string, key: string): Promise<void>;
+
+	/**
+	 * List all keys within a specific namespace/prefix.
+	 *
+	 * @param uniquePrefix - The unique identifier/namespace prefix to list keys from
+	 * @returns Promise that resolves to an array of keys within that namespace
+	 *
+	 * @example
+	 * ```ts
+	 * const app1Keys = await storage.listKeys("app1");
+	 * // Returns keys stored under the "app1" namespace
+	 * // e.g., ["session:abc123", "user:456", "config:settings"]
+	 * ```
+	 */
+	listKeys(uniquePrefix: string): Promise<string[]>;
+
+	/**
+	 * Clear all stored data from the storage backend.
+	 *
+	 * @remarks
+	 * **Warning** — This operation is destructive and cannot be undone.
+	 * Use with caution, especially in production environments.
+	 *
+	 * @returns Promise that resolves when all data has been cleared
+	 *
+	 * @example
+	 * ```ts
+	 * await storage.clearStorage(); // All data is now removed
+	 * ```
+	 */
+	clearStorage(): Promise<void>;
+
+	/**
+	 * Check if a key exists in storage within a specific namespace.
+	 *
+	 * @param uniquePrefix - The unique identifier/namespace prefix to check within
+	 * @param key - The unique identifier to check for existence within the prefix namespace
+	 * @returns Promise that resolves to true if the key exists, false otherwise
+	 *
+	 * @example
+	 * ```ts
+	 * const exists = await storage.keyExists("app1", "user:123");
+	 * if (exists) {
+	 *   const userData = await storage.getKey("app1", "user:123");
+	 * }
+	 * ```
+	 */
+	keyExists(uniquePrefix: string, key: string): Promise<boolean>;
+}

package/dist/generator/generators/typescript/templates/storage-templates/storage-types.mustache

@@ -0,0 +1,6 @@
+
+
+export type StorageConfig = {
+    retryAttempts: number;
+    retryDelayMs: number;
+} 

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

@@ -1,17 +1,25 @@
+import StorageInterface from "../interfaces/storage-interface";
+
+
 /**
  * Configuration options for running validation routines.
  *
  * @property onlyInvalid - If true, only invalid results will be returned.
+ * @property stateFullValidations - If true, enables stateful validations that may depend on previous data.
+ * @property uniqueKey - Optional. A unique key for the validation instance.
+ * @property store - Optional. An implementation of StorageInterface for persisting data across validations.
  * @property hideParentErrors - Optional. Hides nested error details if set to true.
  * @property _debug - Optional. Enables debug mode for additional diagnostic information.
  */
 export interface ValidationConfig {
-	onlyInvalid: boolean;
-  hideParentErrors: boolean;
-	_debug: boolean;
+    stateFullValidations: boolean;
+    uniqueKey?: string;
+    store?: StorageInterface;
+    onlyInvalid: boolean;
+    hideParentErrors: boolean;
+    _debug: boolean;
 }
 
-
 /**
  * Represents the output of a validation run.
  *
@@ -49,15 +57,14 @@ export type validationOutput = {
 }[];
 
 
-/*
-{% comment %} export type ExternalData = {
+
+export type ExternalData = {
     {{#externalData}}
     {{name}}?: string[];
     {{/externalData}}
-}; {% endcomment %}
-*/
+    _SELF?: any;
+}; 
 
-export type ExternalData = {}
 
 export type validationInput = {
 	payload: any;

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

@@ -14,7 +14,7 @@ function {{name}}(input: validationInput): validationOutput {
         {{/hasContinue}}
 
         {{{validationCode}}}
-        delete testObj._EXTERNAL;
+        // delete testObj._EXTERNAL;
     }
     return [{
         testName: "{{testName}}",

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

@@ -20,10 +20,20 @@ valid = subResults.every((r) => r.valid);
 {{/isNested}}
 
 {{^isNested}}
+
+{{#isStateFull}}
+    let validate = true;
+    if(input.config.stateFullValidations === true){
+        validate = {{{returnStatement}}}
+    }
+{{/isStateFull}}
+
+{{^isStateFull}}
 const validate = {{{returnStatement}}}
+{{/isStateFull}}
 
 if(!validate){
-    delete testObj._EXTERNAL;
+    // delete testObj._EXTERNAL;
     return [{
         testName: "{{testName}}",
         valid: false,

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

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

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

@@ -1,7 +1,7 @@
 import { readFileSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { ConfigSyntax, TestObjectSyntax } from "../../../constants/syntax.js";
+import { ConfigSyntax, ExternalDataSyntax, 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";
@@ -10,13 +10,64 @@ import { compileInputToTs } from "./ts-ast.js";
 import { CodeGenerator, } from "../classes/abstract-generator.js";
 import { writeAndFormatCode } from "../../../utils/fs-utils.js";
 import { MarkdownDocGenerator } from "../documentation/md-generator.js";
+import { collectLoadData } from "../../../utils/config-utils/load-variables.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export class TypescriptGenerator extends CodeGenerator {
     constructor() {
         super(...arguments);
         this.generateSessionDataCode = async () => {
-            throw new Error("Method not implemented.");
+            if (!this.codeConfig) {
+                throw new Error("Code config not set. Please call generateCode first.");
+            }
+            const sessionData = this.validationConfig[ConfigSyntax.SessionData];
+            const tests = this.validationConfig[ConfigSyntax.Tests];
+            const relevantSessionData = {};
+            collectLoadData(tests, relevantSessionData);
+            console.log("Relevant Session Data for Loading:", relevantSessionData);
+            const actions = Object.keys(sessionData);
+            const sessionDataUtilsTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/save-utils.mustache"), "utf-8");
+            const storageInterfaceTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-interface.mustache"), "utf-8");
+            const storageTypesTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/storage-types.mustache"), "utf-8");
+            const indexTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/index.mustache"), "utf-8");
+            const saveActionTemplate = readFileSync(path.resolve(__dirname, "./templates/storage-templates/api-save.mustache"), "utf-8");
+            const allActions = Object.keys(tests);
+            const indexCode = Mustache.render(indexTemplate, {
+                actions: Array.from(allActions).map((action) => {
+                    return { action: action };
+                }),
+                functionName: this.codeConfig.codeName.replace(/[^a-zA-Z0-9_]/g, ""),
+            });
+            /*
+                storeActions: {
+                    key: string;
+                    value: string;
+                }[]
+            */
+            for (const action of allActions) {
+                const loadData = relevantSessionData[action] || {};
+                const saveData = sessionData[action] || {};
+                const saveCode = Mustache.render(saveActionTemplate, {
+                    storeActions: Object.keys(saveData).map((key) => {
+                        return {
+                            key: key,
+                            value: saveData[key],
+                        };
+                    }),
+                    loadActions: Object.keys(loadData).map((key) => {
+                        console.log(loadData[key]);
+                        return {
+                            key: loadData[key],
+                        };
+                    }),
+                    action: action,
+                });
+                await writeAndFormatCode(this.rootPath, `./storage-actions/${action}.ts`, saveCode, "typescript");
+            }
+            await writeAndFormatCode(this.rootPath, "./utils/save-utils.ts", sessionDataUtilsTemplate, "typescript");
+            await writeAndFormatCode(this.rootPath, "./types/storage-types.ts", storageTypesTemplate, "typescript");
+            await writeAndFormatCode(this.rootPath, "./interfaces/storage-interface.ts", storageInterfaceTemplate, "typescript");
+            await writeAndFormatCode(this.rootPath, "./storage-actions/index.ts", indexCode, "typescript");
         };
         this.generateValidationCode = async () => {
             const testConfig = this.validationConfig[ConfigSyntax.Tests];
@@ -36,6 +87,7 @@ export class TypescriptGenerator extends CodeGenerator {
             }
         };
         this.generateCode = async (codeConfig) => {
+            this.codeConfig = codeConfig;
             const jsonPathUtilsCode = readFileSync(path.resolve(__dirname, "./templates/json-path-utils.mustache"), "utf-8");
             const validtionUtils = readFileSync(path.resolve(__dirname, "./templates/validation-utils.mustache"), "utf-8");
             const typesTemplate = readFileSync(path.resolve(__dirname, "./templates/test-config.mustache"), "utf-8");
@@ -51,6 +103,7 @@ export class TypescriptGenerator extends CodeGenerator {
             await writeAndFormatCode(this.rootPath, "error.ts", this.generateErrorFile(this.errorCodes), "typescript");
             await writeAndFormatCode(this.rootPath, "index.ts", this.generateIndexFile(Object.keys(this.validationConfig[ConfigSyntax.Tests]), codeConfig.codeName), "typescript");
             await new MarkdownDocGenerator(this.validationConfig, this.errorCodes, this.rootPath).generateCode();
+            await this.generateSessionDataCode();
         };
         this.generateTestFunction = async (testObject) => {
             const template = readFileSync(path.resolve(__dirname, "./templates/test-object.mustache"), "utf-8");
@@ -79,8 +132,20 @@ export class TypescriptGenerator extends CodeGenerator {
             const skipList = skip ? [skip] : undefined;
             if (typeof testObject[TestObjectSyntax.Return] === "string") {
                 const returnStatement = compileInputToTs(testObject[TestObjectSyntax.Return]);
+                let isStateFull = false;
+                for (const k in testObject) {
+                    const value = testObject[k];
+                    if (typeof value === "string") {
+                        if (value.includes(`${ExternalDataSyntax}.`) &&
+                            !value.includes("_SELF")) {
+                            isStateFull = true;
+                            break;
+                        }
+                    }
+                }
                 return Mustache.render(template, {
                     isNested: false,
+                    isStateFull: isStateFull,
                     returnStatement: returnStatement,
                     errorCode: testObject[TestObjectSyntax.ErrorCode] ?? 30000,
                     errorDescription: this.CreateErrorMarkdown(testObject, skipList),
@@ -155,13 +220,14 @@ export class TypescriptGenerator extends CodeGenerator {
     }
     getExternalKeys() {
         const apis = Object.keys(this.validationConfig[ConfigSyntax.SessionData]);
-        const result = [];
+        let result = [];
         for (const api of apis) {
             const keys = Object.keys(this.validationConfig[ConfigSyntax.SessionData][api]);
             for (const key of keys) {
                 result.push({ name: key });
             }
         }
+        result = result.filter((v) => v.name !== "_SELF");
         return result;
     }
     generateIndexFile(apis, functionName = "L1Validations") {
@@ -171,15 +237,34 @@ export class TypescriptGenerator extends CodeGenerator {
             .join("\n");
         importsCode += `\nimport { ValidationConfig,validationOutput } from "./types/test-config";`;
         importsCode += `\nimport normalizeKeys from "./utils/json-normalizer";`;
+        importsCode += `\nimport { perform${functionName}Save, perform${functionName}Load}  from "./storage-actions";`;
+        importsCode += `\nimport StorageInterface from "./interfaces/storage-interface";`;
         const masterTemplate = readFileSync(path.resolve(__dirname, "./templates/index.mustache"), "utf-8");
         const masterFunction = `
 				export function perform${functionName}(action: string, payload: any, config?: Partial<ValidationConfig>, externalData: any = {}) {
 					const completeConfig: ValidationConfig = {
-						...{ onlyInvalid: true, standardLogs: false, hideParentErrors: true, _debug: false },
+						...{ onlyInvalid: true, standardLogs: false, hideParentErrors: true, stateFullValidations: false, _debug: false },
 						...config,
 					};
+
+					if (completeConfig.stateFullValidations  && !completeConfig.store) {
+						throw new Error(
+							"State Full validations require a storage interface to be provided in the config."
+						);
+					}
+					if( completeConfig.stateFullValidations && !completeConfig.uniqueKey) {
+       	 				throw new Error(
+            				"State Full validations require a uniqueKey to be provided in the config."
+        				);
+    				}
 					const normalizedPayload = normalizeKeys(JSON.parse(JSON.stringify(payload)));
 					externalData._SELF = normalizedPayload;
+					if (completeConfig.stateFullValidations) {
+						externalData = {
+							...performL1_validationsLoad(action, completeConfig.uniqueKey!, completeConfig.store!),
+							...externalData,
+						};
+					}
 					switch (action) {
 						${apis
             .map((api) => `case "${api}": return ${api}({
@@ -191,7 +276,11 @@ export class TypescriptGenerator extends CodeGenerator {
 						default:
 							throw new Error("Action not found");
 					}
-			}`;
+			}
+
+			export {perform${functionName}Save, perform${functionName}Load, StorageInterface};
+
+			`;
         return Mustache.render(masterTemplate, {
             importsCode: importsCode,
             masterFunction: masterFunction,

package/dist/generator/validators/config-validator.js

@@ -11,7 +11,17 @@ export class ConfigValidator {
                 throw new Error(`SessionData not found in config`);
             const sessionData = this.config[ConfigSyntax.SessionData];
             const tests = this.config[ConfigSyntax.Tests];
-            await new SessionDataValidator(`${this.validationPath}/${ConfigSyntax.SessionData}`, sessionData).validate();
+            const sessionDataValidator = new SessionDataValidator(`${this.validationPath}/${ConfigSyntax.SessionData}`, sessionData);
+            await sessionDataValidator.validate();
+            for (const api in sessionData) {
+                const paths = this.stringJsonPaths[api];
+                for (const key in sessionData[api]) {
+                    const value = sessionData[api][key];
+                    if (typeof value === "string") {
+                        sessionDataValidator.validateApiPath(paths, value, api, key);
+                    }
+                }
+            }
             const externalVariables = getExternalVariables(sessionData);
             for (const api in tests) {
                 const testList = tests[api];

package/dist/generator/validators/session-data-config/session-data-validator.d.ts

@@ -6,4 +6,5 @@ export declare class SessionDataValidator implements IValidator {
     constructor(validtionPath: string, sessionData: Record<string, SessionDataApi>);
     validate: () => Promise<void>;
     private validateSessionData;
+    validateApiPath(apiPaths: string[], path: string, api: string, key: string): void;
 }

package/dist/generator/validators/session-data-config/session-data-validator.js

@@ -1,4 +1,6 @@
+import { ConfigSyntax } from "../../../constants/syntax.js";
 import { isPrimitive } from "../../../utils/general-utils/validation-utils.js";
+import { isValidJsonPath } from "../../../utils/json-path-utils/paths.js";
 export class SessionDataValidator {
     constructor(validtionPath, sessionData) {
         this.validate = async () => {
@@ -32,4 +34,12 @@ export class SessionDataValidator {
             }
         });
     }
+    validateApiPath(apiPaths, path, api, key) {
+        if (!isValidJsonPath(path)) {
+            throw new Error(`Invalid ${ConfigSyntax.SessionData} path at ${path}: Path should be a valid JSONPath expression for ${api} and key: ${key}`);
+        }
+        if (!apiPaths.includes(path)) {
+            throw new Error(`Invalid ${ConfigSyntax.SessionData} path at ${path}: Path should be a valid path which returns a linear array for ${api} and key: ${key}`);
+        }
+    }
 }

package/dist/index.js

@@ -1,46 +1,2 @@
 import { ConfigCompiler } from "./generator/config-compiler.js";
 export { ConfigCompiler };
-// import { readFileSync } from "fs";
-// import path from "path";
-// import { fileURLToPath } from "url";
-// const __filename = fileURLToPath(import.meta.url);
-// const __dirname = path.dirname(__filename);
-// import { SupportedLanguages } from "./types/compiler-types.js";
-// const main = async () => {
-// 	const compiler = new ConfigCompiler(SupportedLanguages.Python);
-// 	const buildPath = path.resolve(__dirname, "../samples/build.yaml");
-// 	const valConfigPath = path.resolve(
-// 		__dirname,
-// 		"../samples/validation-config.json"
-// 	);
-// 	const buildYaml = readFileSync(buildPath, "utf-8");
-// 	const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
-// 	// await compiler.initialize(buildYaml);
-// 	// await compiler.generateCode(
-// 	// 	valConfig,
-// 	// 	"L1_validations",
-// 	// 	false,
-// 	// 	"./alpha/python/"
-// 	// );
-// 	// const compilerTy = new ConfigCompiler(SupportedLanguages.Typescript);
-// 	// await compilerTy.initialize(buildYaml);
-// 	// await compilerTy.generateCode(
-// 	// 	valConfig,
-// 	// 	"L1_validations",
-// 	// 	false,
-// 	// 	"./alpha/typescript/"
-// 	// );
-// 	// JavaScript generation example
-// 	const compilerJs = new ConfigCompiler(SupportedLanguages.Javascript);
-// 	await compilerJs.initialize(buildYaml);
-// 	await compilerJs.generateCode(
-// 		valConfig,
-// 		"L1_validations",
-// 		false,
-// 		"./alpha/javascriptNative/"
-// 	);
-// };
-// (async () => {
-// 	await main();
-// 	console.log("========== Code generation completed. ==========");
-// })();

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,32 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { ConfigCompiler } from "./generator/config-compiler.js";
+import { SupportedLanguages } from "./types/compiler-types.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const main = async () => {
+    const compiler = new ConfigCompiler(SupportedLanguages.Python);
+    const buildPath = path.resolve(__dirname, "../samples/build.yaml");
+    const valConfigPath = path.resolve(__dirname, "../samples/validation-config.json");
+    const buildYaml = readFileSync(buildPath, "utf-8");
+    const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
+    await compiler.initialize(buildYaml);
+    await compiler.generateCode(valConfig, "L1_validations", false, "./alpha/python/");
+    const compilerTy = new ConfigCompiler(SupportedLanguages.Typescript);
+    await compilerTy.initialize(buildYaml);
+    await compilerTy.generateCode(valConfig, "L1_validations", false, "./alpha/typescript/");
+    // JavaScript generation example
+    // const compilerJs = new ConfigCompiler(SupportedLanguages.Javascript);
+    // await compilerJs.initialize(buildYaml);
+    // await compilerJs.generateCode(
+    // 	valConfig,
+    // 	"L1_validations",
+    // 	false,
+    // 	"./alpha/javascriptNative/"
+    // );
+};
+(async () => {
+    await main();
+    console.log("========== Code generation completed. ==========");
+})();

package/dist/utils/config-utils/load-variables.d.ts

@@ -0,0 +1,3 @@
+import { ConfigSyntax } from "../../constants/syntax.js";
+import { ValidationConfig } from "../../types/config-types.js";
+export declare function collectLoadData(tests: ValidationConfig[ConfigSyntax.Tests], relevantSessionData: Record<string, Record<string, string>>): void;

package/dist/utils/config-utils/load-variables.js

@@ -0,0 +1,33 @@
+import { ExternalDataSyntax, TestObjectSyntax, } from "../../constants/syntax.js";
+import { getVariablesFromTest } from "../general-utils/test-object-utils.js";
+export function collectLoadData(tests, relevantSessionData) {
+    function processTestObjects(api, testObjects) {
+        for (const testObject of testObjects) {
+            // Extract variables from this testObject
+            const varNames = getVariablesFromTest(testObject);
+            for (const varName of varNames) {
+                if (typeof testObject[varName] === "string") {
+                    const path = testObject[varName];
+                    if (path.includes("_SELF"))
+                        continue;
+                    if (path.startsWith(`$.${ExternalDataSyntax}`)) {
+                        relevantSessionData[api] = relevantSessionData[api] || {};
+                        // avoid duplication
+                        const value = path.split(`$.${ExternalDataSyntax}.`)[1];
+                        if (relevantSessionData[api][varName] !== value) {
+                            relevantSessionData[api][varName] = value;
+                        }
+                    }
+                }
+            }
+            // Recursively process return objects (if array)
+            const returnObj = testObject[TestObjectSyntax.Return];
+            if (Array.isArray(returnObj)) {
+                processTestObjects(api, returnObj);
+            }
+        }
+    }
+    for (const api in tests) {
+        processTestObjects(api, tests[api]);
+    }
+}

package/package.json

@@ -1,12 +1,13 @@
 {
 	"name": "ondc-code-generator",
-	"version": "0.5.51",
+	"version": "0.6.0",
 	"description": "generate code from build.yaml ",
 	"main": "dist/index.js",
 	"type": "module",
 	"scripts": {
 		"build": "tsc && copyfiles -u 1 \"src/**/*.{yaml,html,css,mustache}\" dist/",
 		"start": "node ./dist/index.js",
+		"test": "npm run build && node ./dist/test.js",
 		"dev": "nodemon",
 		"clean": "rm -rf dist",
 		"prepare": "npm run clean && npm run build"

package/dist/example.js

@@ -1,22 +0,0 @@
-"use strict";
-// import { readFileSync } from "fs";
-// import path from "path";
-// import { fileURLToPath } from "url";
-// const __filename = fileURLToPath(import.meta.url);
-// const __dirname = path.dirname(__filename);
-// import { SupportedLanguages } from "./types/compiler-types.js";
-// const main = async () => {
-// 	const compiler = new ConfigCompiler(SupportedLanguages.Typescript);
-// 	const buildPath = path.resolve(__dirname, "../samples/build.yaml");
-// 	const valConfigPath = path.resolve(
-// 		__dirname,
-// 		"../samples/validation-config.json"
-// 	);
-// 	const buildYaml = readFileSync(buildPath, "utf-8");
-// 	const valConfig = JSON.parse(readFileSync(valConfigPath, "utf-8"));
-// 	await compiler.initialize(buildYaml);
-// 	await compiler.generateCode(valConfig);
-// };
-// (async () => {
-// 	await main();
-// })();