@ondc/automation-mock-runner 1.3.49 → 1.3.51

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

@@ -15,9 +15,12 @@ export declare class CodeValidator {
      * Validate that return statements match expected structure
      */
     /**
-     * Collect ReturnStatement arguments belonging only to the outer (top-level)
-     * function. Nested function/arrow bodies are skipped — their returns are
-     * not the function's contract and would otherwise produce false positives.
+     * Collect ReturnStatement arguments belonging only to the target function.
+     * When `targetFnName` is given and a top-level `function <name>(...)` exists,
+     * we walk only that body — sibling helpers like `function x(){return "hi"}`
+     * declared next to `validate` are ignored. Returns inside nested
+     * functions/arrows are also skipped (they aren't the contract).
+     * Falls back to the whole AST when no named match is found.
      */
     private static collectTopLevelReturns;
     private static validateReturnStructure;

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

@@ -139,7 +139,7 @@ class CodeValidator {
             });
             // 5. Validate return type structure (for validate and meetsRequirements)
             if (schema.returnType.properties) {
-                const returnValidation = this.validateReturnStructure(ast, schema.returnType.properties);
+                const returnValidation = this.validateReturnStructure(ast, schema.returnType.properties, schema.name);
                 errors.push(...returnValidation);
             }
             // 6. Check for best practices
@@ -172,24 +172,27 @@ class CodeValidator {
      * Validate that return statements match expected structure
      */
     /**
-     * Collect ReturnStatement arguments belonging only to the outer (top-level)
-     * function. Nested function/arrow bodies are skipped — their returns are
-     * not the function's contract and would otherwise produce false positives.
+     * Collect ReturnStatement arguments belonging only to the target function.
+     * When `targetFnName` is given and a top-level `function <name>(...)` exists,
+     * we walk only that body — sibling helpers like `function x(){return "hi"}`
+     * declared next to `validate` are ignored. Returns inside nested
+     * functions/arrows are also skipped (they aren't the contract).
+     * Falls back to the whole AST when no named match is found.
      */
-    static collectTopLevelReturns(ast) {
+    static collectTopLevelReturns(ast, targetFnName) {
         const returns = [];
-        let depth = 0;
-        const enterFn = (node, _st, c) => {
-            if (depth === 0) {
-                depth++;
-                c(node.body, null);
-                depth--;
-            }
-        };
-        walk.recursive(ast, null, {
-            FunctionDeclaration: enterFn,
-            FunctionExpression: enterFn,
-            ArrowFunctionExpression: enterFn,
+        const programBody = Array.isArray(ast.body)
+            ? ast.body
+            : [];
+        const targetFn = targetFnName
+            ? programBody.find((n) => n.type === "FunctionDeclaration" && n.id?.name === targetFnName)
+            : undefined;
+        const walkRoot = targetFn ? targetFn.body : ast;
+        const skip = () => { };
+        walk.recursive(walkRoot, null, {
+            FunctionDeclaration: skip,
+            FunctionExpression: skip,
+            ArrowFunctionExpression: skip,
             ReturnStatement(node) {
                 if (node.argument)
                     returns.push(node.argument);
@@ -197,9 +200,9 @@ class CodeValidator {
         });
         return returns;
     }
-    static validateReturnStructure(ast, expectedProperties) {
+    static validateReturnStructure(ast, expectedProperties, targetFnName) {
         const warnings = [];
-        const foundReturns = this.collectTopLevelReturns(ast);
+        const foundReturns = this.collectTopLevelReturns(ast, targetFnName);
         // Check if we have return statements
         if (foundReturns.length === 0) {
             warnings.push(`Function should return an object with properties: ${Object.keys(expectedProperties).join(", ")}`);
@@ -339,7 +342,7 @@ class CodeValidator {
      */
     static checkBestPractices(ast, schema) {
         const warnings = [];
-        const hasReturn = this.collectTopLevelReturns(ast).length > 0;
+        const hasReturn = this.collectTopLevelReturns(ast, schema.name).length > 0;
         if (!hasReturn) {
             warnings.push(`Function should return a value (expected: ${schema.returnType.description})`);
         }

package/dist/test/CodeValidator.test.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const code_validator_1 = require("../lib/validators/code-validator");
 const function_registry_1 = require("../lib/constants/function-registry");
 const validateSchema = (0, function_registry_1.getFunctionSchema)("validate");
+const meetsRequirementsSchema = (0, function_registry_1.getFunctionSchema)("meetsRequirements");
+const generateSchema = (0, function_registry_1.getFunctionSchema)("generate");
 describe("CodeValidator.validate — return structure", () => {
     it("accepts an outer return with the full expected shape", () => {
         const code = `
@@ -63,6 +65,54 @@ describe("CodeValidator.validate — return structure", () => {
         expect(result.errors).toEqual([]);
         expect(result.isValid).toBe(true);
     });
+    it("ignores sibling top-level helper function returns (validate)", () => {
+        const code = `
+			function x() {
+				return "hello";
+			}
+			function validate(targetPayload, sessionData) {
+				let some = x();
+				return { valid: true, code: 200, description: "Valid request" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, validateSchema);
+        expect(result.errors).toEqual([]);
+        expect(result.warnings).toEqual([]);
+        expect(result.isValid).toBe(true);
+    });
+    it("does not warn 'should return a value' when target fn has a return (validate)", () => {
+        const code = `
+			function validate(targetPayload, sessionData) {
+				return { valid: true, code: 200, description: "Valid request" };
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, validateSchema);
+        expect(result.warnings.some((w) => w.includes("should return a value"))).toBe(false);
+    });
+    it("does not warn 'should return a value' for generate with a return", () => {
+        const code = `
+			async function generate(defaultPayload, sessionData) {
+				return defaultPayload;
+			}
+		`;
+        const result = code_validator_1.CodeValidator.validate(code, generateSchema);
+        expect(result.warnings.some((w) => w.includes("should return a value"))).toBe(false);
+        expect(result.isValid).toBe(true);
+    });
+    it("ignores sibling top-level helper function returns (meetsRequirements)", () => {
+        const code = `
+			function helper() {
+				return 123;
+			}
+			function meetsRequirements(sessionData) {
+				const n = helper();
+				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("warns when only a nested helper returns and the outer function has no return", () => {
         const code = `
 			function validate(targetPayload, sessionData) {

package/package.json

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