@ondc/automation-mock-runner 1.3.48 → 1.3.50

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,35 +200,60 @@ 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(", ")}`);
             return warnings;
         }
-        // Check the structure of returned objects
-        foundReturns.forEach((returnArg) => {
-            if (returnArg.type === "ObjectExpression") {
-                const returnedProps = new Set(returnArg.properties.map((p) => p.key.name));
-                const expectedProps = Object.keys(expectedProperties);
-                // Check for missing properties
-                expectedProps.forEach((prop) => {
-                    if (!returnedProps.has(prop)) {
-                        warnings.push(`Return object is missing property '${prop}' (expected: ${expectedProperties[prop].type})`);
-                    }
-                });
-                // Check for extra properties
-                returnedProps.forEach((prop) => {
-                    if (!expectedProps.includes(prop)) {
-                        warnings.push(`Return object has unexpected property '${prop}'`);
-                    }
-                });
-            }
-            else {
-                warnings.push(`Function should return an object literal with properties: ${Object.keys(expectedProperties).join(", ")}`);
+        // Flatten conditional/logical/sequence/parenthesized wrappers so that
+        // minifier output like `return cond ? {a:1} : {a:2}` or `return x && {...}`
+        // is treated as the set of object-literal branches it actually returns.
+        const objectBranches = [];
+        const stack = [...foundReturns];
+        let nonObjectFound = false;
+        while (stack.length) {
+            const node = stack.pop();
+            switch (node.type) {
+                case "ObjectExpression":
+                    objectBranches.push(node);
+                    break;
+                case "ConditionalExpression":
+                    stack.push(node.consequent, node.alternate);
+                    break;
+                case "LogicalExpression":
+                    stack.push(node.left, node.right);
+                    break;
+                case "SequenceExpression":
+                    stack.push(node.expressions[node.expressions.length - 1]);
+                    break;
+                case "ParenthesizedExpression":
+                    stack.push(node.expression);
+                    break;
+                default:
+                    nonObjectFound = true;
             }
+        }
+        if (objectBranches.length === 0 || nonObjectFound) {
+            warnings.push(`Function should return an object literal with properties: ${Object.keys(expectedProperties).join(", ")}`);
+        }
+        objectBranches.forEach((returnArg) => {
+            const returnedProps = new Set(returnArg.properties.map((p) => p.key.name));
+            const expectedProps = Object.keys(expectedProperties);
+            // Check for missing properties
+            expectedProps.forEach((prop) => {
+                if (!returnedProps.has(prop)) {
+                    warnings.push(`Return object is missing property '${prop}' (expected: ${expectedProperties[prop].type})`);
+                }
+            });
+            // Check for extra properties
+            returnedProps.forEach((prop) => {
+                if (!expectedProps.includes(prop)) {
+                    warnings.push(`Return object has unexpected property '${prop}'`);
+                }
+            });
         });
         return warnings;
     }

package/dist/test/CodeValidator.test.js

@@ -3,6 +3,7 @@ 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");
 describe("CodeValidator.validate — return structure", () => {
     it("accepts an outer return with the full expected shape", () => {
         const code = `
@@ -57,6 +58,40 @@ describe("CodeValidator.validate — return structure", () => {
         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 i ? {...} : {...}", () => {
+        const code = `function validate(i,d){return i?{valid:!0,code:200,description:"Valid request"}:{valid:!1,code:200,description:"oh no"}}`;
+        const result = code_validator_1.CodeValidator.validate(code, validateSchema);
+        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.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/dist/test/run-validate-scratch.test.d.ts

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

package/dist/test/run-validate-scratch.test.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MockRunner_1 = require("../lib/MockRunner");
+describe("scratch: user-supplied validate fn", () => {
+    afterEach(async () => {
+        const shared = MockRunner_1.MockRunner.sharedRunner;
+        if (shared?.terminate)
+            await shared.terminate();
+        MockRunner_1.MockRunner.sharedRunner = undefined;
+    });
+    it("runs the user's validate() against a payload and a null payload", async () => {
+        const validateSrc = `function validate(targetPayload, sessionData) {
+  if(!targetPayload){
+    return {valid: false, code: 200, description: "oh no"};
+  }
+  return { valid: true, code: 200, description: "Valid request" };
+}`;
+        const config = {
+            meta: { domain: "ONDC:TRV14", version: "2.0.0", flowId: "testing" },
+            transaction_data: {
+                transaction_id: "e9e0b5cb-3f15-48a1-9d86-d4d643f0909d",
+                latest_timestamp: "1970-01-01T00:00:00.000Z",
+            },
+            steps: [],
+            transaction_history: [],
+            validationLib: "",
+            helperLib: "",
+        };
+        const runner = new MockRunner_1.MockRunner(config);
+        const step = runner.getDefaultStep("search", "search_0");
+        step.mock.validate = MockRunner_1.MockRunner.encodeBase64(validateSrc);
+        runner.getConfig().steps.push(step);
+        const r1 = await runner.runValidatePayloadWithSession("search_0", { context: {} }, {});
+        console.log("WITH_PAYLOAD:", JSON.stringify(r1, null, 2));
+        const r2 = await runner.runValidatePayloadWithSession("search_0", null, {});
+        console.log("WITH_NULL:", JSON.stringify(r2, null, 2));
+        expect(r1.success).toBe(true);
+        expect(r2.success).toBe(true);
+    }, 30000);
+});

package/package.json

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