@ondc/automation-mock-runner 1.0.6 → 1.1.0

package/dist/lib/MockRunner.d.ts

@@ -8,6 +8,48 @@ export declare class MockRunner {
     logger: Logger;
     constructor(config: MockPlaygroundConfigType, skipValidation?: boolean);
     getRunnerInstance(): BaseCodeRunner;
+    getConfig(): {
+        meta: {
+            domain: string;
+            version: string;
+            flowId: string;
+        };
+        transaction_data: {
+            transaction_id: string;
+            latest_timestamp: string;
+            bap_id?: string | undefined;
+            bap_uri?: string | undefined;
+            bpp_id?: string | undefined;
+            bpp_uri?: string | undefined;
+        };
+        steps: {
+            api: string;
+            action_id: string;
+            owner: "BAP" | "BPP";
+            responseFor: string | null;
+            unsolicited: boolean;
+            description: string;
+            mock: {
+                generate: string;
+                validate: string;
+                requirements: string;
+                defaultPayload: any;
+                saveData: Record<string, string>;
+                inputs: {
+                    id?: string | undefined;
+                    jsonSchema?: any;
+                };
+            };
+            repeatCount?: number | null | undefined;
+        }[];
+        transaction_history: {
+            action_id: string;
+            payload: any;
+            saved_info: Record<string, any>;
+        }[];
+        validationLib: string;
+        helperLib: string;
+    };
     validateConfig(): {
         success: boolean;
         errors?: import("zod/v4/core").$ZodIssue[];

package/dist/lib/MockRunner.js

@@ -44,6 +44,9 @@ class MockRunner {
         this.logger.debug("Code runner instance obtained successfully: " + this.runner.toString());
         return this.runner;
     }
+    getConfig() {
+        return this.config;
+    }
     validateConfig() {
         const res = (0, validateConfig_1.validateConfigWithErrors)(this.config);
         return res;
@@ -319,50 +322,84 @@ class MockRunner {
         };
     }
     generateContext(actionId, action, sessionData) {
-        let step = this.config.steps.find((s) => s.action_id === actionId);
-        if (!step) {
-            step = undefined;
-        }
-        const responseFor = step?.responseFor;
+        // Find the step configuration for this action
+        const step = this.config.steps.find((s) => s.action_id === actionId);
+        // Determine the message_id based on responseFor logic
         let messageId = (0, uuid_1.v4)();
-        if (responseFor) {
+        if (step?.responseFor) {
+            // Priority 1: Get from sessionData if available
             if (sessionData?.latestMessage_id &&
+                Array.isArray(sessionData.latestMessage_id) &&
                 sessionData.latestMessage_id.length > 0) {
                 messageId = sessionData.latestMessage_id[0];
             }
+            // Priority 2: Fall back to transaction history
             else {
-                const responsePayload = this.config.transaction_history.find((item) => item.action_id === responseFor)?.payload;
-                if (responsePayload.context?.message_id) {
-                    messageId = responsePayload.context.message_id;
+                const historyItem = this.config.transaction_history?.find((item) => item.action_id === step.responseFor);
+                if (historyItem?.payload?.context?.message_id) {
+                    messageId = historyItem.payload.context.message_id;
                 }
             }
         }
+        // Safely extract transaction_id
+        const transactionId = (() => {
+            // Priority 1: Get from sessionData
+            if (sessionData?.transaction_id) {
+                const sessionTxnId = Array.isArray(sessionData.transaction_id)
+                    ? sessionData.transaction_id[0]
+                    : sessionData.transaction_id;
+                // Only return if we got a valid non-empty value
+                if (sessionTxnId && sessionTxnId.trim().length > 0) {
+                    return sessionTxnId;
+                }
+            }
+            // Priority 2: Get from transaction history (most recent)
+            if (this.config.transaction_history?.length > 0) {
+                const mostRecentHistory = this.config.transaction_history[this.config.transaction_history.length - 1];
+                const historyTxnId = mostRecentHistory?.payload?.context?.transaction_id;
+                if (historyTxnId && historyTxnId.trim().length > 0) {
+                    return historyTxnId;
+                }
+            }
+            // Priority 3: Get from transaction_data
+            const configTxnId = this.config.transaction_data?.transaction_id;
+            if (configTxnId && configTxnId.trim().length > 0) {
+                return configTxnId;
+            }
+            // Priority 4: Generate new UUID as last resort
+            return (0, uuid_1.v4)();
+        })();
+        // Build base context
         const baseContext = {
-            domain: this.config.meta.domain,
+            domain: this.config.meta?.domain || "",
             action: action,
             timestamp: new Date().toISOString(),
-            transaction_id: sessionData?.transaction_id[0] ||
-                this.config.transaction_data.transaction_id,
+            transaction_id: transactionId,
             message_id: messageId,
-            bap_id: this.config.transaction_data.bap_id || "",
-            bap_uri: this.config.transaction_data.bap_uri || "",
+            bap_id: this.config.transaction_data?.bap_id || "",
+            bap_uri: this.config.transaction_data?.bap_uri || "",
             ttl: "PT30S",
         };
-        if (action != "search") {
-            baseContext.bpp_id = this.config.transaction_data.bpp_id || "";
-            baseContext.bpp_uri = this.config.transaction_data.bpp_uri || "";
+        // Add BPP details for non-search actions
+        if (action !== "search") {
+            baseContext.bpp_id = this.config.transaction_data?.bpp_id || "";
+            baseContext.bpp_uri = this.config.transaction_data?.bpp_uri || "";
         }
-        if (this.config.meta.version.split(".")[0] === "1") {
+        // Version-specific context structure
+        const version = this.config.meta?.version || "2.0.0";
+        const majorVersion = parseInt(version.split(".")[0], 10);
+        if (majorVersion === 1) {
             return {
                 ...baseContext,
                 country: "IND",
                 city: "*",
-                core_version: this.config.meta.version,
+                core_version: version,
             };
         }
+        // Version 2+ format
         return {
             ...baseContext,
-            version: this.config.meta.version,
+            version: version,
             location: {
                 country: {
                     code: "IND",

package/dist/lib/configHelper.d.ts

@@ -1,3 +1,5 @@
 import { MockPlaygroundConfigType } from "./types/mock-config";
 export declare function createInitialMockConfig(domain: string, version: string, flowId: string): MockPlaygroundConfigType;
 export declare function convertToFlowConfig(config: MockPlaygroundConfigType): any;
+export declare function createOptimizedMockConfig(config: MockPlaygroundConfigType): Promise<MockPlaygroundConfigType>;
+export declare function getMinifiedCode(base64Code: string): Promise<string>;

package/dist/lib/configHelper.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInitialMockConfig = createInitialMockConfig;
 exports.convertToFlowConfig = convertToFlowConfig;
+exports.createOptimizedMockConfig = createOptimizedMockConfig;
+exports.getMinifiedCode = getMinifiedCode;
+const MockRunner_1 = require("./MockRunner");
 const uuid_1 = require("uuid");
+const terser_1 = require("terser");
 function createInitialMockConfig(domain, version, flowId) {
     return {
         meta: {
@@ -58,3 +62,31 @@ function convertToFlowConfig(config) {
     }
     return flowConfig;
 }
+async function createOptimizedMockConfig(config) {
+    const optimizedSteps = await Promise.all(config.steps.map(async (step) => {
+        return {
+            ...step,
+            mock: {
+                ...step.mock,
+                generate: await getMinifiedCode(step.mock.generate),
+                validate: await getMinifiedCode(step.mock.validate),
+                requirements: await getMinifiedCode(step.mock.requirements),
+            },
+        };
+    }));
+    const optimizedConfig = {
+        meta: config.meta,
+        transaction_history: [],
+        helperLib: config.helperLib,
+        validationLib: config.validationLib,
+        transaction_data: config.transaction_data,
+        steps: optimizedSteps,
+    };
+    return optimizedConfig;
+}
+async function getMinifiedCode(base64Code) {
+    const decodedCode = MockRunner_1.MockRunner.decodeBase64(base64Code);
+    const result = await (0, terser_1.minify)(decodedCode);
+    // If `minify` returns an object like { code: '...' }, return the string
+    return MockRunner_1.MockRunner.encodeBase64(result.code || decodedCode);
+}

package/dist/test/MockRunner.test.js

@@ -3,11 +3,12 @@
  * Tests for MockRunner class - ONDC Automation Mock Runner
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const configHelper_1 = require("../lib/configHelper");
 const MockRunner_1 = require("../lib/MockRunner");
 describe("MockRunner", () => {
     let mockRunner;
     let mockConfig;
-    beforeEach(() => {
+    beforeEach(async () => {
         mockConfig = {
             meta: {
                 domain: "ONDC:TRV14",
@@ -25,7 +26,10 @@ describe("MockRunner", () => {
         };
         try {
             mockRunner = new MockRunner_1.MockRunner(mockConfig);
-            mockConfig.steps.push(mockRunner.getDefaultStep("search", "search_0"));
+            mockRunner
+                .getConfig()
+                .steps.push(mockRunner.getDefaultStep("search", "search_0"));
+            mockRunner = new MockRunner_1.MockRunner(await (0, configHelper_1.createOptimizedMockConfig)(mockRunner.getConfig()));
         }
         catch (error) {
             throw error;
@@ -157,9 +161,31 @@ describe("MockRunner", () => {
                 b: 2,
             };
             const res = await MockRunner_1.MockRunner.runGetSave(ob, fun);
-            console.log(JSON.stringify(res, null, 2));
-            console.log(Object.keys(ob).length);
             expect(res.result).toBe(ob.a + ob.b);
         });
+        it("should timeout for long-running getSave functions", async () => {
+            const longRunningFunction = MockRunner_1.MockRunner.encodeBase64(`async function getSave(payload){
+				console.log('Starting long-running operation...');
+				// Simulate a long-running operation that takes more than 3 seconds
+				await new Promise(resolve => setTimeout(resolve, 4000));
+				console.log('Long-running operation completed');
+				return payload.result;
+			}`);
+            const payload = {
+                result: "This should timeout",
+            };
+            // This should timeout and return an error result
+            const res = await MockRunner_1.MockRunner.runGetSave(payload, longRunningFunction);
+            console.log("Timeout test result:", JSON.stringify(res, null, 2));
+            // Expect the operation to fail due to timeout
+            expect(res.success).toBe(false);
+            expect(res.error).toBeDefined();
+            if (res.error) {
+                expect(res.error.message.toLowerCase().includes("timeout") ||
+                    res.error.message.includes("Timeout") ||
+                    res.error.message.includes("TIMEOUT") ||
+                    res.error.name.toLowerCase().includes("timeout")).toBe(true);
+            }
+        }, 10000); // Set Jest timeout to 10 seconds to allow for the timeout to occur
     });
 });

package/dist/test/generateContext.test.d.ts

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

package/dist/test/generateContext.test.js

@@ -0,0 +1,472 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MockRunner_1 = require("../lib/MockRunner");
+const uuid_1 = require("uuid");
+// Mock UUID to get predictable test results
+jest.mock("uuid", () => ({
+    v4: jest.fn(() => "test-uuid-1234"),
+}));
+describe("MockRunner - generateContext", () => {
+    let mockRunner;
+    let mockConfig;
+    beforeEach(() => {
+        // Reset UUID mock
+        uuid_1.v4.mockReturnValue("test-uuid-1234");
+        mockConfig = {
+            meta: {
+                domain: "ONDC:TRV14",
+                version: "2.0.0",
+                flowId: "test-flow",
+            },
+            transaction_data: {
+                transaction_id: "txn-123",
+                latest_timestamp: "2025-11-11T10:00:00.000Z",
+                bap_id: "test-bap-id",
+                bap_uri: "https://test-bap.com",
+                bpp_id: "test-bpp-id",
+                bpp_uri: "https://test-bpp.com",
+            },
+            steps: [
+                {
+                    api: "search",
+                    action_id: "search_1",
+                    owner: "BAP",
+                    responseFor: null,
+                    unsolicited: false,
+                    description: "Search step",
+                    mock: {
+                        generate: "base64-encoded-generate",
+                        validate: "base64-encoded-validate",
+                        requirements: "base64-encoded-requirements",
+                        defaultPayload: { context: {}, message: {} },
+                        saveData: {},
+                        inputs: {},
+                    },
+                },
+                {
+                    api: "on_search",
+                    action_id: "on_search_1",
+                    owner: "BPP",
+                    responseFor: "search_1",
+                    unsolicited: false,
+                    description: "On search response",
+                    mock: {
+                        generate: "base64-encoded-generate",
+                        validate: "base64-encoded-validate",
+                        requirements: "base64-encoded-requirements",
+                        defaultPayload: { context: {}, message: {} },
+                        saveData: {},
+                        inputs: {},
+                    },
+                },
+                {
+                    api: "select",
+                    action_id: "select_1",
+                    owner: "BAP",
+                    responseFor: null,
+                    unsolicited: false,
+                    description: "Select step",
+                    mock: {
+                        generate: "base64-encoded-generate",
+                        validate: "base64-encoded-validate",
+                        requirements: "base64-encoded-requirements",
+                        defaultPayload: { context: {}, message: {} },
+                        saveData: {},
+                        inputs: {},
+                    },
+                },
+            ],
+            transaction_history: [
+                {
+                    action_id: "search_1",
+                    payload: {
+                        context: {
+                            message_id: "search-msg-123",
+                            timestamp: "2025-11-11T10:00:00.000Z",
+                        },
+                        message: {},
+                    },
+                    saved_info: {},
+                },
+            ],
+            validationLib: "",
+            helperLib: "",
+        };
+        mockRunner = new MockRunner_1.MockRunner(mockConfig, true); // Skip validation for tests
+    });
+    describe("Basic Context Generation", () => {
+        it("should generate context with basic required fields", () => {
+            const context = mockRunner.generateContext("search_1", "search");
+            expect(context).toHaveProperty("domain", "ONDC:TRV14");
+            expect(context).toHaveProperty("action", "search");
+            expect(context).toHaveProperty("timestamp");
+            expect(context).toHaveProperty("transaction_id", "txn-123");
+            expect(context).toHaveProperty("message_id");
+            expect(context).toHaveProperty("bap_id", "test-bap-id");
+            expect(context).toHaveProperty("bap_uri", "https://test-bap.com");
+            expect(context).toHaveProperty("ttl", "PT30S");
+        });
+        it("should generate timestamp in ISO format", () => {
+            const context = mockRunner.generateContext("search_1", "search");
+            expect(context.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+            expect(new Date(context.timestamp).toISOString()).toBe(context.timestamp);
+        });
+        it("should use transaction_id from config", () => {
+            const context = mockRunner.generateContext("search_1", "search");
+            expect(context.transaction_id).toBe("txn-123");
+        });
+        it("should generate new UUID for message_id when no responseFor", () => {
+            const context = mockRunner.generateContext("search_1", "search");
+            expect(context.message_id).toBe("test-uuid-1234");
+        });
+    });
+    describe("Version-based Context Structure", () => {
+        it("should generate v2.0.0 context structure", () => {
+            const context = mockRunner.generateContext("search_1", "search");
+            expect(context).toHaveProperty("version", "2.0.0");
+            expect(context).toHaveProperty("location");
+            expect(context.location).toEqual({
+                country: { code: "IND" },
+                city: { code: "*" },
+            });
+            expect(context).not.toHaveProperty("country");
+            expect(context).not.toHaveProperty("city");
+            expect(context).not.toHaveProperty("core_version");
+        });
+        it("should generate v1.x.x context structure", () => {
+            const v1Config = {
+                ...mockConfig,
+                meta: { ...mockConfig.meta, version: "1.2.0" },
+            };
+            const v1Runner = new MockRunner_1.MockRunner(v1Config, true);
+            const context = v1Runner.generateContext("search_1", "search");
+            expect(context).toHaveProperty("core_version", "1.2.0");
+            expect(context).toHaveProperty("country", "IND");
+            expect(context).toHaveProperty("city", "*");
+            expect(context).not.toHaveProperty("version");
+            expect(context).not.toHaveProperty("location");
+        });
+        it("should handle version 1.0.0", () => {
+            const v1Config = {
+                ...mockConfig,
+                meta: { ...mockConfig.meta, version: "1.0.0" },
+            };
+            const v1Runner = new MockRunner_1.MockRunner(v1Config, true);
+            const context = v1Runner.generateContext("search_1", "search");
+            expect(context.core_version).toBe("1.0.0");
+            expect(context.country).toBe("IND");
+            expect(context.city).toBe("*");
+        });
+        it("should handle version 1.10.5", () => {
+            const v1Config = {
+                ...mockConfig,
+                meta: { ...mockConfig.meta, version: "1.10.5" },
+            };
+            const v1Runner = new MockRunner_1.MockRunner(v1Config, true);
+            const context = v1Runner.generateContext("search_1", "search");
+            expect(context.core_version).toBe("1.10.5");
+        });
+    });
+    describe("BPP Fields Handling", () => {
+        it("should not include bpp fields for search action", () => {
+            const context = mockRunner.generateContext("search_1", "search");
+            expect(context).not.toHaveProperty("bpp_id");
+            expect(context).not.toHaveProperty("bpp_uri");
+        });
+        it("should include bpp fields for non-search actions", () => {
+            const context = mockRunner.generateContext("select_1", "select");
+            expect(context).toHaveProperty("bpp_id", "test-bpp-id");
+            expect(context).toHaveProperty("bpp_uri", "https://test-bpp.com");
+        });
+        it("should include bpp fields for on_search action", () => {
+            const context = mockRunner.generateContext("on_search_1", "on_search");
+            expect(context).toHaveProperty("bpp_id", "test-bpp-id");
+            expect(context).toHaveProperty("bpp_uri", "https://test-bpp.com");
+        });
+        it("should handle empty bpp_id and bpp_uri gracefully", () => {
+            const configWithEmptyBpp = {
+                ...mockConfig,
+                transaction_data: {
+                    ...mockConfig.transaction_data,
+                    bpp_id: "",
+                    bpp_uri: "",
+                },
+            };
+            const runnerWithEmptyBpp = new MockRunner_1.MockRunner(configWithEmptyBpp, true);
+            const context = runnerWithEmptyBpp.generateContext("select_1", "select");
+            expect(context.bpp_id).toBe("");
+            expect(context.bpp_uri).toBe("");
+        });
+    });
+    describe("Response Message ID Handling", () => {
+        it("should use message_id from responseFor step in transaction history", () => {
+            const context = mockRunner.generateContext("on_search_1", "on_search");
+            expect(context.message_id).toBe("search-msg-123");
+        });
+        it("should generate new UUID when responseFor not found in transaction history", () => {
+            const configWithMissingHistory = {
+                ...mockConfig,
+                transaction_history: [], // Empty history
+            };
+            const runnerWithMissingHistory = new MockRunner_1.MockRunner(configWithMissingHistory, true);
+            // This will throw because the function tries to access responsePayload.context on undefined
+            expect(() => {
+                runnerWithMissingHistory.generateContext("on_search_1", "on_search");
+            }).not.toThrow("Cannot read properties of undefined (reading 'context')");
+        });
+        it("should generate new UUID when responseFor payload has no message_id", () => {
+            const configWithIncompleteHistory = {
+                ...mockConfig,
+                transaction_history: [
+                    {
+                        action_id: "search_1",
+                        payload: {
+                            context: {}, // No message_id
+                            message: {},
+                        },
+                        saved_info: {},
+                    },
+                ],
+            };
+            const runnerWithIncompleteHistory = new MockRunner_1.MockRunner(configWithIncompleteHistory, true);
+            const context = runnerWithIncompleteHistory.generateContext("on_search_1", "on_search");
+            expect(context.message_id).toBe("test-uuid-1234");
+        });
+    });
+    describe("Session Data Integration", () => {
+        it("should use transaction_id from sessionData when provided", () => {
+            const sessionData = {
+                transaction_id: ["session-txn-456"],
+            };
+            const context = mockRunner.generateContext("search_1", "search", sessionData);
+            expect(context.transaction_id).toBe("session-txn-456");
+        });
+        it("should use latestMessage_id from sessionData for response steps", () => {
+            const sessionData = {
+                transaction_id: ["session-txn-456"], // Need to provide transaction_id array
+                latestMessage_id: ["session-msg-789"],
+            };
+            const context = mockRunner.generateContext("on_search_1", "on_search", sessionData);
+            expect(context.message_id).toBe("session-msg-789");
+        });
+        it("should fallback to config transaction_id when sessionData has empty transaction_id", () => {
+            const sessionData = {
+                transaction_id: [],
+            };
+            const context = mockRunner.generateContext("search_1", "search", sessionData);
+            expect(context.transaction_id).toBe("txn-123");
+        });
+        it("should fallback to transaction history when sessionData has empty latestMessage_id", () => {
+            const sessionData = {
+                transaction_id: ["session-txn"], // Provide transaction_id array
+                latestMessage_id: [],
+            };
+            const context = mockRunner.generateContext("on_search_1", "on_search", sessionData);
+            expect(context.transaction_id).toBe("session-txn");
+            expect(context.message_id).toBe("search-msg-123");
+        });
+        it("should handle sessionData with null values", () => {
+            const sessionData = {
+                transaction_id: null,
+                latestMessage_id: null,
+            };
+            // This will throw because the function tries to access transaction_id[0] on null
+            expect(() => {
+                mockRunner.generateContext("on_search_1", "on_search", sessionData);
+            }).not.toThrow("Cannot read properties of null (reading '0')");
+        });
+    });
+    describe("Step Resolution", () => {
+        it("should handle non-existent actionId gracefully", () => {
+            const context = mockRunner.generateContext("non_existent", "unknown");
+            expect(context.message_id).toBe("test-uuid-1234"); // Should generate new UUID
+            expect(context.domain).toBe("ONDC:TRV14");
+            expect(context.action).toBe("unknown");
+        });
+        it("should handle step without responseFor", () => {
+            const context = mockRunner.generateContext("search_1", "search");
+            expect(context.message_id).toBe("test-uuid-1234");
+        });
+    });
+    describe("Empty and Default Values", () => {
+        it("should handle empty bap_id and bap_uri", () => {
+            const configWithEmptyBap = {
+                ...mockConfig,
+                transaction_data: {
+                    ...mockConfig.transaction_data,
+                    bap_id: "",
+                    bap_uri: "",
+                },
+            };
+            const runnerWithEmptyBap = new MockRunner_1.MockRunner(configWithEmptyBap, true);
+            const context = runnerWithEmptyBap.generateContext("search_1", "search");
+            expect(context.bap_id).toBe("");
+            expect(context.bap_uri).toBe("");
+        });
+        it("should handle undefined bap_id and bap_uri", () => {
+            const configWithUndefinedBap = {
+                ...mockConfig,
+                transaction_data: {
+                    ...mockConfig.transaction_data,
+                    bap_id: undefined,
+                    bap_uri: undefined,
+                },
+            };
+            const runnerWithUndefinedBap = new MockRunner_1.MockRunner(configWithUndefinedBap, true);
+            const context = runnerWithUndefinedBap.generateContext("search_1", "search");
+            expect(context.bap_id).toBe("");
+            expect(context.bap_uri).toBe("");
+        });
+    });
+    describe("Complex Scenarios", () => {
+        it("should handle multi-step flow with proper message_id chaining", () => {
+            const complexConfig = {
+                ...mockConfig,
+                steps: [
+                    ...mockConfig.steps,
+                    {
+                        api: "on_select",
+                        action_id: "on_select_1",
+                        owner: "BPP",
+                        responseFor: "select_1",
+                        unsolicited: false,
+                        description: "On select response",
+                        mock: {
+                            generate: "base64",
+                            validate: "base64",
+                            requirements: "base64",
+                            defaultPayload: { context: {}, message: {} },
+                            saveData: {},
+                            inputs: {},
+                        },
+                    },
+                ],
+                transaction_history: [
+                    ...mockConfig.transaction_history,
+                    {
+                        action_id: "select_1",
+                        payload: {
+                            context: {
+                                message_id: "select-msg-456",
+                                timestamp: "2025-11-11T11:00:00.000Z",
+                            },
+                            message: {},
+                        },
+                        saved_info: {},
+                    },
+                ],
+            };
+            const complexRunner = new MockRunner_1.MockRunner(complexConfig, true);
+            const context = complexRunner.generateContext("on_select_1", "on_select");
+            expect(context.message_id).toBe("select-msg-456");
+        });
+        it("should generate unique timestamps for multiple calls", (done) => {
+            const context1 = mockRunner.generateContext("search_1", "search");
+            setTimeout(() => {
+                const context2 = mockRunner.generateContext("search_1", "search");
+                expect(context1.timestamp).not.toBe(context2.timestamp);
+                expect(new Date(context2.timestamp).getTime()).toBeGreaterThan(new Date(context1.timestamp).getTime());
+                done();
+            }, 1);
+        });
+        it("should handle mixed version formats", () => {
+            const configs = [
+                { version: "2.0.0", expected: "version" },
+                { version: "1.0.0", expected: "core_version" },
+                { version: "1.5.2", expected: "core_version" },
+                { version: "2.1.0", expected: "version" },
+                { version: "0.9.0", expected: "version" },
+            ];
+            configs.forEach(({ version, expected }) => {
+                const testConfig = {
+                    ...mockConfig,
+                    meta: { ...mockConfig.meta, version },
+                };
+                const testRunner = new MockRunner_1.MockRunner(testConfig, true);
+                const context = testRunner.generateContext("search_1", "search");
+                if (expected === "core_version") {
+                    expect(context).toHaveProperty("core_version", version);
+                    expect(context).toHaveProperty("country", "IND");
+                    expect(context).not.toHaveProperty("version");
+                    expect(context).not.toHaveProperty("location");
+                }
+                else {
+                    expect(context).toHaveProperty("version", version);
+                    expect(context).toHaveProperty("location");
+                    expect(context).not.toHaveProperty("core_version");
+                    expect(context).not.toHaveProperty("country");
+                }
+            });
+        });
+    });
+    describe("Error Handling and Edge Cases", () => {
+        it("should handle malformed transaction history", () => {
+            const configWithMalformedHistory = {
+                ...mockConfig,
+                transaction_history: [
+                    {
+                        action_id: "search_1",
+                        payload: null, // Malformed payload
+                        saved_info: {},
+                    },
+                ],
+            };
+            const runnerWithMalformedHistory = new MockRunner_1.MockRunner(configWithMalformedHistory, true);
+            // This will throw because the function tries to access payload.context on null
+            expect(() => {
+                runnerWithMalformedHistory.generateContext("on_search_1", "on_search");
+            }).not.toThrow("Cannot read properties of null (reading 'context')");
+        });
+        it("should handle very long action names", () => {
+            const longActionId = "a".repeat(1000);
+            const context = mockRunner.generateContext(longActionId, "search");
+            expect(context.action).toBe("search");
+            expect(context.domain).toBe("ONDC:TRV14");
+        });
+        it("should handle special characters in action names", () => {
+            const specialActionId = "test-action_with.special@chars#123";
+            const context = mockRunner.generateContext(specialActionId, "special/action");
+            expect(context.action).toBe("special/action");
+            expect(context.message_id).toBe("test-uuid-1234");
+        });
+        it("should handle sessionData with proper array format", () => {
+            const sessionData = {
+                transaction_id: ["custom-txn-id"],
+                latestMessage_id: ["custom-msg-id"],
+            };
+            const context = mockRunner.generateContext("on_search_1", "on_search", sessionData);
+            expect(context.transaction_id).toBe("custom-txn-id");
+            expect(context.message_id).toBe("custom-msg-id");
+        });
+        it("should handle sessionData with undefined arrays", () => {
+            const sessionData = {
+                transaction_id: undefined,
+                latestMessage_id: undefined,
+            };
+            const context = mockRunner.generateContext("on_search_1", "on_search", sessionData);
+            expect(context.transaction_id).toBe("txn-123"); // Falls back to config
+            expect(context.message_id).toBe("search-msg-123"); // Falls back to transaction history
+        });
+        it("should handle properly formatted transaction history with no message_id", () => {
+            const configWithValidHistoryNoMsgId = {
+                ...mockConfig,
+                transaction_history: [
+                    {
+                        action_id: "search_1",
+                        payload: {
+                            context: {
+                                // No message_id field
+                                timestamp: "2025-11-11T10:00:00.000Z",
+                            },
+                            message: {},
+                        },
+                        saved_info: {},
+                    },
+                ],
+            };
+            const runnerWithValidHistory = new MockRunner_1.MockRunner(configWithValidHistoryNoMsgId, true);
+            const context = runnerWithValidHistory.generateContext("on_search_1", "on_search");
+            expect(context.message_id).toBe("test-uuid-1234"); // Should generate new UUID
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ondc/automation-mock-runner",
-	"version": "1.0.6",
+	"version": "1.1.0",
 	"description": "A TypeScript library for ONDC automation mock runner",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -78,6 +78,7 @@
 		"acorn-walk": "^8.3.4",
 		"base-64": "^1.0.0",
 		"jsonpath": "^1.1.1",
+		"terser": "^5.44.1",
 		"uuid": "^10.0.0",
 		"zod": "^4.1.12"
 	},