@ondc/automation-mock-runner 1.3.52 → 1.3.54

package/dist/lib/MockRunner.js

@@ -617,11 +617,19 @@ class MockRunner {
     }
     static encodeBase64(input) {
         const bytes = new TextEncoder().encode(input);
-        return btoa(String.fromCharCode(...bytes));
+        const CHUNK = 0x8000;
+        let binary = "";
+        for (let i = 0; i < bytes.length; i += CHUNK) {
+            binary += String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK));
+        }
+        return btoa(binary);
     }
     static decodeBase64(encoded) {
         const binaryString = atob(encoded);
-        const bytes = new Uint8Array([...binaryString].map((char) => char.charCodeAt(0)));
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
         return new TextDecoder().decode(bytes);
     }
     static resolveBaseActionId(actionId) {

package/dist/lib/configHelper.js

@@ -40,117 +40,118 @@ function createInitialMockConfig(domain, version, flowId) {
         helperLib: MockRunner_1.MockRunner.encodeBase64(helpers_1.DEFAULT_HELPER_LIB),
     };
 }
-function convertToFlowConfig(config) {
-    const flowConfig = {};
-    flowConfig.id = config.meta.flowId;
-    flowConfig.description = "";
-    flowConfig.sequence = [];
-    let index = 0;
-    for (const step of config.steps) {
-        const pair = config.steps.find((s) => s.responseFor === step.action_id)?.action_id ||
-            null;
-        let flowStep = {};
-        const isFormStep = [
-            "HTML_FORM",
-            "DYNAMIC_FORM",
-            "HTML_FORM_MULTI",
-            "dynamic_form",
-            "html_form",
-        ];
-        // Check if previous step was a form step
-        const previousStep = index > 0 ? config.steps[index - 1] : null;
-        const isPreviousStepForm = previousStep !== null && isFormStep.includes(previousStep.api);
-        // Check if current step has no inputs
-        const hasNoInputs = step.mock.inputs === undefined ||
-            step.mock.inputs === null ||
-            Object.keys(step.mock.inputs).length === 0;
-        if (step.api === "dynamic_form") {
-            flowStep = {
-                key: step.action_id,
-                type: "DYNAMIC_FORM",
-                owner: step.owner,
-                description: step.description || "",
-                label: step.description || "FORM",
-                unsolicited: step.unsolicited,
-                pair: pair,
-                repeat: step.repeatCount || 1,
-                input: [
-                    {
-                        name: "form_submission_id",
-                        label: "Enter form submission ID",
-                        type: "DYNAMIC_FORM",
-                        payloadField: "form_submission_id",
-                        reference: `$.reference_data.${step.action_id}`,
-                    },
-                ],
-            };
-        }
-        else if (step.api === "HTML_FORM" || step.api === "html_form") {
-            flowStep = {
-                key: step.action_id,
-                type: "HTML_FORM",
-                owner: step.owner,
-                description: step.description || "",
-                label: step.description || "FORM",
-                unsolicited: step.unsolicited,
-                pair: pair,
-                repeat: step.repeatCount || 1,
-                input: [
-                    {
-                        name: "form_submission_id",
-                        label: "Enter form submission ID",
-                        type: "HTML_FORM",
-                        payloadField: "form_submission_id",
-                        reference: `$.reference_data.${step.action_id}`,
-                    },
-                ],
-            };
+function buildFlowStep(step, index, steps) {
+    const pair = steps.find((s) => s.responseFor === step.action_id)?.action_id || null;
+    let flowStep = {};
+    const isFormStep = [
+        "HTML_FORM",
+        "DYNAMIC_FORM",
+        "HTML_FORM_MULTI",
+        "dynamic_form",
+        "html_form",
+    ];
+    // Check if previous step was a form step
+    const previousStep = index > 0 ? steps[index - 1] : null;
+    const isPreviousStepForm = previousStep !== null && isFormStep.includes(previousStep.api);
+    // Check if current step has no inputs
+    const hasNoInputs = step.mock.inputs === undefined ||
+        step.mock.inputs === null ||
+        Object.keys(step.mock.inputs).length === 0;
+    if (step.api === "dynamic_form") {
+        flowStep = {
+            key: step.action_id,
+            type: "DYNAMIC_FORM",
+            owner: step.owner,
+            description: step.description || "",
+            label: step.description || "FORM",
+            unsolicited: step.unsolicited,
+            pair: pair,
+            repeat: step.repeatCount || 1,
+            input: [
+                {
+                    name: "form_submission_id",
+                    label: "Enter form submission ID",
+                    type: "DYNAMIC_FORM",
+                    payloadField: "form_submission_id",
+                    reference: `$.reference_data.${step.action_id}`,
+                },
+            ],
+        };
+    }
+    else if (step.api === "HTML_FORM" || step.api === "html_form") {
+        flowStep = {
+            key: step.action_id,
+            type: "HTML_FORM",
+            owner: step.owner,
+            description: step.description || "",
+            label: step.description || "FORM",
+            unsolicited: step.unsolicited,
+            pair: pair,
+            repeat: step.repeatCount || 1,
+            input: [
+                {
+                    name: "form_submission_id",
+                    label: "Enter form submission ID",
+                    type: "HTML_FORM",
+                    payloadField: "form_submission_id",
+                    reference: `$.reference_data.${step.action_id}`,
+                },
+            ],
+        };
+    }
+    else {
+        flowStep = {
+            key: step.action_id,
+            type: step.api,
+            owner: step.owner,
+            description: step.description || "",
+            expect: index === 0 ? true : false,
+            unsolicited: step.unsolicited,
+            pair: pair,
+            repeat: step.repeatCount || 1,
+        };
+    }
+    if (step.mock.inputs !== undefined &&
+        step.mock.inputs !== null &&
+        Object.keys(step.mock.inputs).length > 0) {
+        if (step.mock.inputs.id == "finvu_verification") {
+            flowStep.input = [
+                {
+                    name: "finvu_verification",
+                    label: "Complete Account Aggregator Verification",
+                    type: "FINVU_REDIRECT",
+                    payloadField: "$.context.aa_consent_verified",
+                },
+            ];
         }
         else {
-            flowStep = {
-                key: step.action_id,
-                type: step.api,
-                owner: step.owner,
-                description: step.description || "",
-                expect: index === 0 ? true : false,
-                unsolicited: step.unsolicited,
-                pair: pair,
-                repeat: step.repeatCount || 1,
-            };
-        }
-        if (step.mock.inputs !== undefined &&
-            step.mock.inputs !== null &&
-            Object.keys(step.mock.inputs).length > 0) {
-            if (step.mock.inputs.id == "finvu_verification") {
-                flowStep.input = [
-                    {
-                        name: "finvu_verification",
-                        label: "Complete Account Aggregator Verification",
-                        type: "FINVU_REDIRECT",
-                        payloadField: "$.context.aa_consent_verified",
-                    },
-                ];
-            }
-            else {
-                flowStep.input = [
-                    {
-                        name: step.mock.inputs.id,
-                        type: step.mock.inputs.id,
-                        schema: step.mock.inputs.jsonSchema,
-                    },
-                ];
-            }
-        }
-        if (step.mock.inputs?.oldInputs) {
-            flowStep.input = step.mock.inputs.oldInputs;
+            flowStep.input = [
+                {
+                    name: step.mock.inputs.id,
+                    type: step.mock.inputs.id,
+                    schema: step.mock.inputs.jsonSchema,
+                },
+            ];
         }
-        // Add force_proceed if previous step was a form and current step has no inputs
-        if (isPreviousStepForm && hasNoInputs) {
-            flowStep.force_proceed = true;
-        }
-        flowConfig.sequence.push(flowStep);
-        index++;
     }
+    if (step.mock.inputs?.oldInputs) {
+        flowStep.input = step.mock.inputs.oldInputs;
+    }
+    // Add force_proceed if previous step was a form and current step has no inputs
+    if (isPreviousStepForm && hasNoInputs) {
+        flowStep.force_proceed = true;
+    }
+    return flowStep;
+}
+function buildFlowSequence(steps) {
+    return steps.map((step, index) => buildFlowStep(step, index, steps));
+}
+function convertToFlowConfig(config) {
+    const flowConfig = {};
+    flowConfig.id = config.meta.flowId;
+    flowConfig.description = "";
+    flowConfig.sequence = buildFlowSequence(config.steps);
+    flowConfig.extraSequence = buildFlowSequence(config.extra_steps?.steps || []);
     return flowConfig;
 }
 async function createOptimizedMockConfig(config) {

package/dist/lib/validators/code-validator.d.ts

@@ -22,6 +22,12 @@ export declare class CodeValidator {
      * functions/arrows are also skipped (they aren't the contract).
      * Falls back to the whole AST when no named match is found.
      */
+    /**
+     * Returns the function name the schema's template wraps user code with
+     * (e.g. "generate", "validate", "meetsRequirements"). Returns undefined for
+     * raw-code schemas like `getSave` whose template is the identity function.
+     */
+    private static getExpectedDeclarationName;
     private static collectTopLevelReturns;
     private static validateReturnStructure;
     /**

package/dist/lib/validators/code-validator.js

@@ -137,14 +137,29 @@ class CodeValidator {
             dangerousPatterns.forEach((pattern) => {
                 errors.push(`[Line ${pattern.line}] ${pattern.message}`);
             });
-            // 5. Validate return type structure (for validate and meetsRequirements)
-            if (schema.returnType.properties) {
+            // 5. Require the top-level function declaration the schema wraps with
+            //    (skipped for raw-code schemas like `getSave` whose template doesn't
+            //    define a named function). Without this, a typo'd name silently
+            //    degrades to a misleading "Function should return an object..." warning.
+            const expectedName = this.getExpectedDeclarationName(schema);
+            const hasNamedDecl = expectedName
+                ? (ast.body || []).some((n) => n.type === "FunctionDeclaration" && n.id?.name === expectedName)
+                : true;
+            if (expectedName && !hasNamedDecl) {
+                errors.push(`Expected a top-level function declaration named '${expectedName}' (check for typos or a missing/wrapping function)`);
+            }
+            // 6. Validate return type structure (for validate and meetsRequirements).
+            //    Skipped when the named declaration is missing — the message would
+            //    duplicate the clearer error above.
+            if (schema.returnType.properties && hasNamedDecl) {
                 const returnValidation = this.validateReturnStructure(ast, schema.returnType.properties, schema.name);
                 errors.push(...returnValidation);
             }
-            // 6. Check for best practices
-            const practiceWarnings = this.checkBestPractices(ast, schema);
-            warnings.push(...practiceWarnings);
+            // 7. Check for best practices (skipped when declaration is missing)
+            if (hasNamedDecl) {
+                const practiceWarnings = this.checkBestPractices(ast, schema);
+                warnings.push(...practiceWarnings);
+            }
         }
         catch (e) {
             // Syntax error during parsing
@@ -179,6 +194,27 @@ class CodeValidator {
      * functions/arrows are also skipped (they aren't the contract).
      * Falls back to the whole AST when no named match is found.
      */
+    /**
+     * Returns the function name the schema's template wraps user code with
+     * (e.g. "generate", "validate", "meetsRequirements"). Returns undefined for
+     * raw-code schemas like `getSave` whose template is the identity function.
+     */
+    static getExpectedDeclarationName(schema) {
+        try {
+            const ast = acorn.parse(schema.template(""), {
+                ecmaVersion: 2020,
+                sourceType: "script",
+            });
+            const body = Array.isArray(ast.body)
+                ? ast.body
+                : [];
+            const fn = body.find((n) => n.type === "FunctionDeclaration" && n.id?.name === schema.name);
+            return fn ? schema.name : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     static collectTopLevelReturns(ast, targetFnName) {
         const returns = [];
         const programBody = Array.isArray(ast.body)

package/dist/test/BrowserRunner.test.js

@@ -117,7 +117,7 @@ describe("BrowserRunner", () => {
             const result = await browserRunner.execute(wrongFunctionCode, schema, args);
             expect(result.success).toBe(false);
             expect(result.error).toBeDefined();
-            expect(result.error.message).toContain("generate is not defined");
+            expect(result.error.message).toContain("Expected a top-level function declaration named 'generate'");
         });
         it("should handle runtime errors in functions", async () => {
             const errorCode = `

package/dist/test/CodeValidator.test.js

@@ -124,3 +124,325 @@ describe("CodeValidator.validate — return structure", () => {
         expect(result.warnings.some((w) => w.includes("should return a value"))).toBe(true);
     });
 });
+describe("CodeValidator.validate — meetsRequirements return structure", () => {
+    it("accepts an outer return with the full expected shape", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				return { valid: true, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toEqual([]);
+    });
+    it("ignores nested arrow helper returns inside meetsRequirements", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				const ok = (x) => { return x.length > 0; };
+				const ids = (sessionData.items || []).filter(i => { return i.id; });
+				return { valid: ok("hi"), code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toEqual([]);
+    });
+    it("ignores nested function declaration returns inside meetsRequirements", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				function buildMsg(x) { return "req: " + x; }
+				return { valid: false, code: 400, description: buildMsg("nope") };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toEqual([]);
+    });
+    it("flags missing 'description' on the outer return", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				return { valid: true, code: 200 };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("description"))).toBe(true);
+    });
+    it("flags missing 'valid' on the outer return", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				return { code: 200, description: "ok" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("valid"))).toBe(true);
+    });
+    it("flags missing 'code' on the outer return", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				return { valid: true, description: "ok" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("code"))).toBe(true);
+    });
+    it("flags an outer return that is not an object literal (boolean)", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				return true;
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("Function should return an object literal"))).toBe(true);
+    });
+    it("flags an outer return that is not an object literal (string)", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				return "ok";
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("Function should return an object literal"))).toBe(true);
+    });
+    it("accepts a minified conditional return: return c ? {...} : {...}", () => {
+        const code = `function meetsRequirements(s){return s.ok?{valid:!0,code:200,description:"Requirements met"}:{valid:!1,code:400,description:"not met"}}`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.errors).toEqual([]);
+        expect(result.isValid).toBe(true);
+    });
+    it("accepts multiple return paths inside if/else, both objects", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				if (!sessionData) {
+					return { valid: false, code: 400, description: "no session" };
+				}
+				if (sessionData.bad) {
+					return { valid: false, code: 401, description: "bad" };
+				}
+				return { valid: true, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.errors).toEqual([]);
+        expect(result.isValid).toBe(true);
+    });
+    it("flags when one of multiple return paths is missing a property", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				if (!sessionData) {
+					return { valid: false, code: 400 };
+				}
+				return { valid: true, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("description"))).toBe(true);
+    });
+    it("flags when one of multiple return paths is not an object", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				if (!sessionData) {
+					return false;
+				}
+				return { valid: true, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("Function should return an object literal"))).toBe(true);
+    });
+    it("flags unexpected/extra properties on the outer return", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				return { valid: true, code: 200, description: "ok", extra: "nope" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("unexpected property"))).toBe(true);
+    });
+    it("does not warn 'should return a value' when meetsRequirements has a return", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				return { valid: true, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.warnings.some((w) => w.includes("should return a value"))).toBe(false);
+    });
+    it("warns when only a nested helper returns and meetsRequirements has no return", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				function helper() { return 42; }
+				helper();
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.warnings.some((w) => w.includes("should return a value"))).toBe(true);
+    });
+    it("ignores sibling top-level helper returns even when they return non-objects", () => {
+        const code = `
+			function helper() { return 123; }
+			function anotherHelper() { return "string"; }
+			function meetsRequirements(sessionData) {
+				const a = helper();
+				const b = anotherHelper();
+				return { valid: a > 0 && !!b, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.errors).toEqual([]);
+        expect(result.warnings).toEqual([]);
+        expect(result.isValid).toBe(true);
+    });
+    it("ignores returns inside try/catch helpers nested in meetsRequirements", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				const safe = (fn) => {
+					try { return fn(); } catch (e) { return null; }
+				};
+				const v = safe(() => sessionData.x);
+				return { valid: !!v, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toEqual([]);
+    });
+    it("flags forbidden global usage inside meetsRequirements", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				eval("1+1");
+				return { valid: true, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("eval"))).toBe(true);
+    });
+    it("flags infinite loops inside meetsRequirements", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				while (true) { break; }
+				return { valid: true, code: 200, description: "Requirements met" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("infinite loop"))).toBe(true);
+    });
+    it("accepts return inside switch branches when all branches return objects", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				switch (sessionData.kind) {
+					case "a":
+						return { valid: true, code: 200, description: "Requirements met" };
+					case "b":
+						return { valid: false, code: 400, description: "bad b" };
+					default:
+						return { valid: false, code: 400, description: "unknown" };
+				}
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.errors).toEqual([]);
+        expect(result.isValid).toBe(true);
+    });
+    it("errors when the function name is misspelled (meetRequirements vs meetsRequirements)", () => {
+        const code = `
+			function meetRequirements(sessionData) {
+				if (!sessionData.selected_items) {
+					return { valid: false, code: "MISSING", description: "no items" };
+				}
+				return { valid: true, code: "200", description: "ok" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("Expected a top-level function declaration named 'meetsRequirements'"))).toBe(true);
+        // Suppresses the older misleading "should return an object with properties" message
+        expect(result.errors.some((e) => e.includes("Function should return an object with properties"))).toBe(false);
+        // Suppresses the "should return a value" warning too
+        expect(result.warnings.some((w) => w.includes("should return a value"))).toBe(false);
+    });
+    it("accepts return inside try/finally in meetsRequirements", () => {
+        const code = `
+			function meetsRequirements(sessionData) {
+				try {
+					return { valid: true, code: 200, description: "Requirements met" };
+				} catch (e) {
+					return { valid: false, code: 500, description: String(e) };
+				}
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.errors).toEqual([]);
+        expect(result.isValid).toBe(true);
+    });
+});
+describe("CodeValidator.validate — required top-level declaration name", () => {
+    const getSaveSchema = (0, function_registry_1.getFunctionSchema)("getSave");
+    it("errors when 'validate' is misspelled (validatee)", () => {
+        const code = `
+			function validatee(targetPayload, sessionData) {
+				return { valid: true, code: 200, description: "Valid request" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, validateSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("Expected a top-level function declaration named 'validate'"))).toBe(true);
+    });
+    it("errors when 'generate' is misspelled (genrate)", () => {
+        const code = `
+			async function genrate(defaultPayload, sessionData) {
+				return defaultPayload;
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, generateSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("Expected a top-level function declaration named 'generate'"))).toBe(true);
+    });
+    it("accepts async generate (async function declaration counts)", () => {
+        const code = `
+			async function generate(defaultPayload, sessionData) {
+				return defaultPayload;
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, generateSchema);
+        expect(result.errors).toEqual([]);
+        expect(result.isValid).toBe(true);
+    });
+    it("errors when function is defined as const arrow instead of declaration", () => {
+        const code = `
+			const validate = (targetPayload, sessionData) => {
+				return { valid: true, code: 200, description: "Valid request" };
+			};
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, validateSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("Expected a top-level function declaration named 'validate'"))).toBe(true);
+    });
+    it("errors when only helpers are defined and the target function is missing entirely", () => {
+        const code = `
+			function helper() { return 1; }
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, meetsRequirementsSchema);
+        expect(result.isValid).toBe(false);
+        expect(result.errors.some((e) => e.includes("Expected a top-level function declaration named 'meetsRequirements'"))).toBe(true);
+    });
+    it("does NOT require a function declaration for getSave (raw code allowed)", () => {
+        const code = `return payload.context.transaction_id;`;
+        const result = code_validator_1.CodeValidator.validate(code, getSaveSchema);
+        expect(result.errors.some((e) => e.includes("Expected a top-level function declaration"))).toBe(false);
+    });
+    it("accepts getSave wrapped in an IIFE (no named declaration needed)", () => {
+        const code = `const id = payload.context.transaction_id; return id;`;
+        const result = code_validator_1.CodeValidator.validate(code, getSaveSchema);
+        expect(result.errors.some((e) => e.includes("Expected a top-level function declaration"))).toBe(false);
+    });
+});

package/package.json

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