@ondc/automation-mock-runner 1.1.0 → 1.1.9

package/dist/lib/MockRunner.js

@@ -80,7 +80,21 @@ class MockRunner {
             const context = this.generateContext(step.action_id, step.api);
             defaultPayload.context = context;
             const schema = (0, function_registry_1.getFunctionSchema)("generate");
-            const result = await this.getRunnerInstance().execute(MockRunner.decodeBase64(step.mock.generate), schema, [defaultPayload, sessionData]);
+            const code = MockRunner.decodeBase64(step.mock.generate);
+            let helperLib = "";
+            try {
+                helperLib = MockRunner.decodeBase64(this.config.helperLib || "");
+            }
+            catch (e) {
+                this.logger.error("Failed to decode helper library", { actionId }, e);
+                helperLib = "";
+            }
+            // Combine helper library and main code
+            const fullCode = helperLib + "\n" + code;
+            const result = await this.getRunnerInstance().execute(fullCode, schema, [
+                defaultPayload,
+                sessionData,
+            ]);
             const executionTime = Date.now() - startTime;
             this.logger.logExecution(executionId, "Payload generation completed", {
                 actionId,

package/dist/lib/configHelper.js

@@ -25,9 +25,47 @@ function createInitialMockConfig(domain, version, flowId) {
         steps: [],
         transaction_history: [],
         validationLib: "",
-        helperLib: "",
+        helperLib: MockRunner_1.MockRunner.encodeBase64(defaultHelpers),
     };
 }
+const defaultHelpers = `/*
+	Custom helper functions available in all mock generation functions.
+	these are appended below the generate function for each step.
+*/
+
+// Generates a UUID v4
+function uuidv4() {
+	return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+	  const r = Math.random() * 16 | 0;
+	  const v = c === 'x' ? r : (r & 0x3 | 0x8);
+	  return v.toString(16);
+	});
+}
+
+// Generate a 6 digit string ID
+function generate6DigitId() {
+	return Math.floor(100000 + Math.random() * 900000).toString();
+}
+
+// Returns the current ISO timestamp
+function currentTimestamp() {
+	return new Date().toISOString();
+}
+
+// Converts ISO 8601 duration string to total seconds
+const isoDurToSec = (duration) => {
+  const durRE = /P((\d+)Y)?((\d+)M)?((\d+)W)?((\d+)D)?T?((\d+)H)?((\d+)M)?((\d+)S)?/;
+  const s = durRE.exec(duration);
+  if (!s) return 0;
+  
+  return (Number(s?.[2]) || 0) * 31536000 +
+	(Number(s?.[4]) || 0) * 2628288 +
+	(Number(s?.[6]) || 0) * 604800 +
+	(Number(s?.[8]) || 0) * 86400 +
+	(Number(s?.[10]) || 0) * 3600 +
+	(Number(s?.[12]) || 0) * 60 +
+	(Number(s?.[14]) || 0);
+};`;
 function convertToFlowConfig(config) {
     const flowConfig = {};
     flowConfig.id = config.meta.flowId;

package/dist/lib/constants/function-registry.js

@@ -25,7 +25,7 @@ exports.FUNCTION_REGISTRY = {
             description: "The generated payload object to be sent in the API request",
         },
         description: "Generates the mock payload for an API call",
-        timeout: 60 * 1000,
+        timeout: 35 * 1000,
         defaultBody: `  return defaultPayload;`,
         template: (body) => `/**
  * Generates the mock payload for an API call in the transaction flow.

package/dist/test/MockRunner.test.js

@@ -188,4 +188,430 @@ describe("MockRunner", () => {
             }
         }, 10000); // Set Jest timeout to 10 seconds to allow for the timeout to occur
     });
+    describe("Helper Library Functionality", () => {
+        it("should successfully use helper library functions in generate code", async () => {
+            // Create a helper library with utility functions
+            const helperLib = MockRunner_1.MockRunner.encodeBase64(`
+				function formatCurrency(amount) {
+					return "₹" + amount.toFixed(2);
+				}
+				
+				function calculateDiscount(price, discountPercent) {
+					return price - (price * discountPercent / 100);
+				}
+			`);
+            // Create generate code that uses helper library functions
+            const generateCode = MockRunner_1.MockRunner.encodeBase64(`
+				async function generate(payload, sessionData) {
+					const originalPrice = 1000;
+					const discountedPrice = calculateDiscount(originalPrice, 10);
+					
+					payload.message = {
+						price: formatCurrency(originalPrice),
+						discountedPrice: formatCurrency(discountedPrice),
+						savings: formatCurrency(originalPrice - discountedPrice)
+					};
+					
+					return payload;
+				}
+			`);
+            // Create config with helper library
+            const configWithHelper = {
+                meta: {
+                    domain: "ONDC:RET10",
+                    version: "2.0.0",
+                    flowId: "helper-test",
+                },
+                transaction_data: {
+                    transaction_id: "test-txn-123",
+                    latest_timestamp: "2024-01-01T00:00:00.000Z",
+                    bap_id: "test-bap",
+                    bap_uri: "https://test-bap.com",
+                },
+                steps: [
+                    {
+                        api: "select",
+                        action_id: "select_0",
+                        owner: "BAP",
+                        responseFor: null,
+                        unsolicited: false,
+                        description: "Test helper library",
+                        mock: {
+                            generate: generateCode,
+                            validate: MockRunner_1.MockRunner.encodeBase64("async function validate(payload, sessionData) { return { isValid: true, errors: [], warnings: [] }; }"),
+                            requirements: MockRunner_1.MockRunner.encodeBase64("async function meetsRequirements(sessionData) { return { meets: true, reasons: [] }; }"),
+                            defaultPayload: {
+                                context: {},
+                                message: {},
+                            },
+                            saveData: {},
+                            inputs: {},
+                        },
+                    },
+                ],
+                transaction_history: [],
+                validationLib: "",
+                helperLib: helperLib,
+            };
+            const runner = new MockRunner_1.MockRunner(configWithHelper, true);
+            const result = await runner.runGeneratePayload("select_0", {});
+            expect(result.success).toBe(true);
+            expect(result.result).toBeDefined();
+            expect(result.result.message).toBeDefined();
+            expect(result.result.message.price).toBe("₹1000.00");
+            expect(result.result.message.discountedPrice).toBe("₹900.00");
+            expect(result.result.message.savings).toBe("₹100.00");
+        });
+        it("should work correctly when helper library is empty string", async () => {
+            const generateCode = MockRunner_1.MockRunner.encodeBase64(`
+				async function generate(payload, sessionData) {
+					payload.message = { test: "works without helper" };
+					return payload;
+				}
+			`);
+            const configNoHelper = {
+                meta: {
+                    domain: "ONDC:RET10",
+                    version: "2.0.0",
+                    flowId: "no-helper-test",
+                },
+                transaction_data: {
+                    transaction_id: "test-txn-456",
+                    latest_timestamp: "2024-01-01T00:00:00.000Z",
+                },
+                steps: [
+                    {
+                        api: "search",
+                        action_id: "search_0",
+                        owner: "BAP",
+                        responseFor: null,
+                        unsolicited: false,
+                        description: "Test without helper library",
+                        mock: {
+                            generate: generateCode,
+                            validate: MockRunner_1.MockRunner.encodeBase64("async function validate(payload, sessionData) { return { isValid: true, errors: [], warnings: [] }; }"),
+                            requirements: MockRunner_1.MockRunner.encodeBase64("async function meetsRequirements(sessionData) { return { meets: true, reasons: [] }; }"),
+                            defaultPayload: {
+                                context: {},
+                                message: {},
+                            },
+                            saveData: {},
+                            inputs: {},
+                        },
+                    },
+                ],
+                transaction_history: [],
+                validationLib: "",
+                helperLib: "",
+            };
+            const runner = new MockRunner_1.MockRunner(configNoHelper, true);
+            const result = await runner.runGeneratePayload("search_0", {});
+            expect(result.success).toBe(true);
+            expect(result.result).toBeDefined();
+            expect(result.result.message.test).toBe("works without helper");
+        });
+        it("should work correctly when helper library is null or undefined in config", async () => {
+            const generateCode = MockRunner_1.MockRunner.encodeBase64(`
+				async function generate(payload, sessionData) {
+					payload.message = { test: "works with null helper" };
+					return payload;
+				}
+			`);
+            // Test with empty string (same as undefined behavior)
+            const configNullHelper = {
+                meta: {
+                    domain: "ONDC:RET10",
+                    version: "2.0.0",
+                    flowId: "null-helper-test",
+                },
+                transaction_data: {
+                    transaction_id: "test-txn-789",
+                    latest_timestamp: "2024-01-01T00:00:00.000Z",
+                },
+                steps: [
+                    {
+                        api: "search",
+                        action_id: "search_0",
+                        owner: "BAP",
+                        responseFor: null,
+                        unsolicited: false,
+                        description: "Test with null/undefined helper library",
+                        mock: {
+                            generate: generateCode,
+                            validate: MockRunner_1.MockRunner.encodeBase64("async function validate(payload, sessionData) { return { isValid: true, errors: [], warnings: [] }; }"),
+                            requirements: MockRunner_1.MockRunner.encodeBase64("async function meetsRequirements(sessionData) { return { meets: true, reasons: [] }; }"),
+                            defaultPayload: {
+                                context: {},
+                                message: {},
+                            },
+                            saveData: {},
+                            inputs: {},
+                        },
+                    },
+                ],
+                transaction_history: [],
+                validationLib: "",
+                helperLib: "",
+            };
+            const runner = new MockRunner_1.MockRunner(configNullHelper, true);
+            const result = await runner.runGeneratePayload("search_0", {});
+            expect(result.success).toBe(true);
+            expect(result.result).toBeDefined();
+            expect(result.result.message.test).toBe("works with null helper");
+        });
+        it("should handle invalid base64 in helper library gracefully", async () => {
+            const generateCode = MockRunner_1.MockRunner.encodeBase64(`
+				async function generate(payload, sessionData) {
+					payload.message = { test: "should still work" };
+					return payload;
+				}
+			`);
+            const configInvalidHelper = {
+                meta: {
+                    domain: "ONDC:RET10",
+                    version: "2.0.0",
+                    flowId: "invalid-helper-test",
+                },
+                transaction_data: {
+                    transaction_id: "test-txn-invalid",
+                    latest_timestamp: "2024-01-01T00:00:00.000Z",
+                },
+                steps: [
+                    {
+                        api: "search",
+                        action_id: "search_0",
+                        owner: "BAP",
+                        responseFor: null,
+                        unsolicited: false,
+                        description: "Test with invalid helper library",
+                        mock: {
+                            generate: generateCode,
+                            validate: MockRunner_1.MockRunner.encodeBase64("async function validate(payload, sessionData) { return { isValid: true, errors: [], warnings: [] }; }"),
+                            requirements: MockRunner_1.MockRunner.encodeBase64("async function meetsRequirements(sessionData) { return { meets: true, reasons: [] }; }"),
+                            defaultPayload: {
+                                context: {},
+                                message: {},
+                            },
+                            saveData: {},
+                            inputs: {},
+                        },
+                    },
+                ],
+                transaction_history: [],
+                validationLib: "",
+                helperLib: "invalid-base64-@#$%",
+            };
+            const runner = new MockRunner_1.MockRunner(configInvalidHelper, true);
+            const result = await runner.runGeneratePayload("search_0", {});
+            // Should still execute successfully with empty helper lib
+            expect(result.success).toBe(true);
+            expect(result.result).toBeDefined();
+            expect(result.result.message.test).toBe("should still work");
+        });
+        it("should combine helper library with multiple utility functions", async () => {
+            // Helper library with multiple utilities
+            const helperLib = MockRunner_1.MockRunner.encodeBase64(`
+				const CONSTANTS = {
+					TAX_RATE: 0.18,
+					SHIPPING_COST: 50
+				};
+				
+				function calculateTax(amount) {
+					return amount * CONSTANTS.TAX_RATE;
+				}
+				
+				function calculateTotal(subtotal) {
+					const tax = calculateTax(subtotal);
+					return subtotal + tax + CONSTANTS.SHIPPING_COST;
+				}
+				
+				function formatDate(dateStr) {
+					return new Date(dateStr).toLocaleDateString('en-IN');
+				}
+			`);
+            const generateCode = MockRunner_1.MockRunner.encodeBase64(`
+				async function generate(payload, sessionData) {
+					const subtotal = 1000;
+					const tax = calculateTax(subtotal);
+					const total = calculateTotal(subtotal);
+					
+					payload.message = {
+						subtotal: subtotal,
+						tax: tax,
+						shipping: 50,
+						total: total,
+						orderDate: formatDate(payload.context.timestamp)
+					};
+					
+					return payload;
+				}
+			`);
+            const config = {
+                meta: {
+                    domain: "ONDC:RET10",
+                    version: "2.0.0",
+                    flowId: "multi-helper-test",
+                },
+                transaction_data: {
+                    transaction_id: "test-txn-multi",
+                    latest_timestamp: "2024-01-15T00:00:00.000Z",
+                },
+                steps: [
+                    {
+                        api: "init",
+                        action_id: "init_0",
+                        owner: "BAP",
+                        responseFor: null,
+                        unsolicited: false,
+                        description: "Test multiple helper functions",
+                        mock: {
+                            generate: generateCode,
+                            validate: MockRunner_1.MockRunner.encodeBase64("async function validate(payload, sessionData) { return { isValid: true, errors: [], warnings: [] }; }"),
+                            requirements: MockRunner_1.MockRunner.encodeBase64("async function meetsRequirements(sessionData) { return { meets: true, reasons: [] }; }"),
+                            defaultPayload: {
+                                context: {},
+                                message: {},
+                            },
+                            saveData: {},
+                            inputs: {},
+                        },
+                    },
+                ],
+                transaction_history: [],
+                validationLib: "",
+                helperLib: helperLib,
+            };
+            const runner = new MockRunner_1.MockRunner(config, true);
+            const result = await runner.runGeneratePayload("init_0", {});
+            expect(result.success).toBe(true);
+            expect(result.result.message).toBeDefined();
+            expect(result.result.message.subtotal).toBe(1000);
+            expect(result.result.message.tax).toBe(180); // 18% of 1000
+            expect(result.result.message.shipping).toBe(50);
+            expect(result.result.message.total).toBe(1230); // 1000 + 180 + 50
+            expect(result.result.message.orderDate).toBeDefined();
+        });
+        it("should handle syntax errors in helper library", async () => {
+            // Helper library with syntax error
+            const helperLibWithError = MockRunner_1.MockRunner.encodeBase64(`
+				function brokenFunction( {
+					// Missing closing parenthesis
+					return "broken";
+				}
+			`);
+            const generateCode = MockRunner_1.MockRunner.encodeBase64(`
+				async function generate(payload, sessionData) {
+					payload.message = { test: "value" };
+					return payload;
+				}
+			`);
+            const config = {
+                meta: {
+                    domain: "ONDC:RET10",
+                    version: "2.0.0",
+                    flowId: "error-helper-test",
+                },
+                transaction_data: {
+                    transaction_id: "test-txn-error",
+                    latest_timestamp: "2024-01-01T00:00:00.000Z",
+                },
+                steps: [
+                    {
+                        api: "search",
+                        action_id: "search_0",
+                        owner: "BAP",
+                        responseFor: null,
+                        unsolicited: false,
+                        description: "Test helper library with syntax error",
+                        mock: {
+                            generate: generateCode,
+                            validate: MockRunner_1.MockRunner.encodeBase64("async function validate(payload, sessionData) { return { isValid: true, errors: [], warnings: [] }; }"),
+                            requirements: MockRunner_1.MockRunner.encodeBase64("async function meetsRequirements(sessionData) { return { meets: true, reasons: [] }; }"),
+                            defaultPayload: {
+                                context: {},
+                                message: {},
+                            },
+                            saveData: {},
+                            inputs: {},
+                        },
+                    },
+                ],
+                transaction_history: [],
+                validationLib: "",
+                helperLib: helperLibWithError,
+            };
+            const runner = new MockRunner_1.MockRunner(config, true);
+            const result = await runner.runGeneratePayload("search_0", {});
+            // Should fail due to syntax error in combined code
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it("should allow helper library to access sessionData through generate function", async () => {
+            const helperLib = MockRunner_1.MockRunner.encodeBase64(`
+				function getUserDiscount(userType) {
+					const discounts = {
+						'premium': 20,
+						'regular': 10,
+						'new': 5
+					};
+					return discounts[userType] || 0;
+				}
+			`);
+            const generateCode = MockRunner_1.MockRunner.encodeBase64(`
+				async function generate(payload, sessionData) {
+					const userType = sessionData.user_inputs?.userType || 'new';
+					const discount = getUserDiscount(userType);
+					
+					payload.message = {
+						userType: userType,
+						discountPercent: discount
+					};
+					
+					return payload;
+				}
+			`);
+            const config = {
+                meta: {
+                    domain: "ONDC:RET10",
+                    version: "2.0.0",
+                    flowId: "session-helper-test",
+                },
+                transaction_data: {
+                    transaction_id: "test-txn-session",
+                    latest_timestamp: "2024-01-01T00:00:00.000Z",
+                },
+                steps: [
+                    {
+                        api: "select",
+                        action_id: "select_0",
+                        owner: "BAP",
+                        responseFor: null,
+                        unsolicited: false,
+                        description: "Test helper with session data",
+                        mock: {
+                            generate: generateCode,
+                            validate: MockRunner_1.MockRunner.encodeBase64("async function validate(payload, sessionData) { return { isValid: true, errors: [], warnings: [] }; }"),
+                            requirements: MockRunner_1.MockRunner.encodeBase64("async function meetsRequirements(sessionData) { return { meets: true, reasons: [] }; }"),
+                            defaultPayload: {
+                                context: {},
+                                message: {},
+                            },
+                            saveData: {},
+                            inputs: {},
+                        },
+                    },
+                ],
+                transaction_history: [],
+                validationLib: "",
+                helperLib: helperLib,
+            };
+            const runner = new MockRunner_1.MockRunner(config, true);
+            const result = await runner.runGeneratePayload("select_0", {
+                userType: "premium",
+            });
+            expect(result.success).toBe(true);
+            expect(result.result.message.userType).toBe("premium");
+            expect(result.result.message.discountPercent).toBe(20);
+        });
+    });
 });

package/dist/test/helper-config.test.js

@@ -460,7 +460,6 @@ describe("configHelper", () => {
             expect(result.steps).toEqual([]);
             expect(result.transaction_history).toEqual([]);
             expect(result.validationLib).toBe("");
-            expect(result.helperLib).toBe("");
         });
         it("should handle different domain formats", () => {
             const result1 = (0, configHelper_1.createInitialMockConfig)("ONDC:RET10", "1.0.0", "test");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ondc/automation-mock-runner",
-	"version": "1.1.0",
+	"version": "1.1.9",
 	"description": "A TypeScript library for ONDC automation mock runner",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/public/node-worker.js

@@ -108,8 +108,8 @@ function createSandbox() {
 		decodeURIComponent,
 		// Utility functions for ONDC operations
 		setTimeout: (fn, delay) => {
-			if (delay < 1 || delay > 1000) {
-				throw new Error("Timeout must be between 1-1000ms");
+			if (delay < 1 || delay > 35 * 1000) {
+				throw new Error("Timeout must be between 1-35000ms");
 			}
 			return setTimeout(fn, delay);
 		},
@@ -151,7 +151,7 @@ parentPort?.on("message", async (message) => {
 
 		// Execute the script
 		script.runInContext(context, {
-			timeout: timeout || 5000,
+			timeout: timeout || 35000,
 			breakOnSigint: true,
 		});
 
@@ -168,8 +168,8 @@ parentPort?.on("message", async (message) => {
 			new Promise((_, reject) =>
 				setTimeout(
 					() => reject(new Error("Function execution timeout")),
-					timeout || 5000
-				)
+					timeout || 5000,
+				),
 			),
 		]);