@ondc/automation-mock-runner 0.0.1

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

@@ -0,0 +1,327 @@
+"use strict";
+// lib/code-runner/code-validator.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeValidator = void 0;
+const acorn = __importStar(require("acorn"));
+const walk = __importStar(require("acorn-walk"));
+class CodeValidator {
+    /**
+     * Get code statistics
+     */
+    static getCodeStatistics(code) {
+        const stats = {
+            lines: code.split("\n").length,
+            functions: 0,
+            complexity: 1,
+            loops: 0,
+            conditionals: 0,
+        };
+        try {
+            const ast = acorn.parse(code, {
+                ecmaVersion: 2020,
+                sourceType: "script",
+            });
+            walk.simple(ast, {
+                FunctionDeclaration() {
+                    stats.functions++;
+                },
+                FunctionExpression() {
+                    stats.functions++;
+                },
+                ArrowFunctionExpression() {
+                    stats.functions++;
+                },
+                WhileStatement() {
+                    stats.loops++;
+                    stats.complexity++;
+                },
+                DoWhileStatement() {
+                    stats.loops++;
+                    stats.complexity++;
+                },
+                ForStatement() {
+                    stats.loops++;
+                    stats.complexity++;
+                },
+                ForInStatement() {
+                    stats.loops++;
+                    stats.complexity++;
+                },
+                ForOfStatement() {
+                    stats.loops++;
+                    stats.complexity++;
+                },
+                IfStatement() {
+                    stats.conditionals++;
+                    stats.complexity++;
+                },
+                ConditionalExpression() {
+                    stats.conditionals++;
+                    stats.complexity++;
+                },
+                SwitchCase(node) {
+                    if (node.test) {
+                        stats.conditionals++;
+                        stats.complexity++;
+                    }
+                },
+                LogicalExpression(node) {
+                    if (node.operator === "||" || node.operator === "&&") {
+                        stats.complexity++;
+                    }
+                },
+            });
+        }
+        catch (e) {
+            // Ignore parse errors, return partial stats
+            console.error("Error parsing code for statistics:", e);
+        }
+        return stats;
+    }
+    /**
+     * Main validation method - now handles function bodies
+     */
+    static validate(functionBody, schema) {
+        const errors = [];
+        const warnings = [];
+        // 1. Wrap the body with function declaration
+        const wrappedCode = functionBody;
+        // const wrappedCode = schema.template(functionBody);
+        try {
+            // 2. Parse complete code into AST
+            const ast = acorn.parse(wrappedCode, {
+                ecmaVersion: 2020,
+                sourceType: "script",
+                locations: true,
+            });
+            // 3. Security analysis on the complete code
+            const securityIssues = this.analyzeSecurityIssues(ast);
+            securityIssues.forEach((issue) => {
+                errors.push(`[Line ${issue.line}] ${issue.message}`);
+            });
+            // 4. Check for dangerous patterns
+            const dangerousPatterns = this.detectDangerousPatterns(ast);
+            dangerousPatterns.forEach((pattern) => {
+                errors.push(`[Line ${pattern.line}] ${pattern.message}`);
+            });
+            // 5. Validate return type structure (for validate and meetsRequirements)
+            if (schema.returnType.properties) {
+                const returnValidation = this.validateReturnStructure(ast, schema.returnType.properties);
+                errors.push(...returnValidation);
+            }
+            // 6. Check for best practices
+            const practiceWarnings = this.checkBestPractices(ast, schema);
+            warnings.push(...practiceWarnings);
+        }
+        catch (e) {
+            // Syntax error during parsing
+            let errorMessage = `Syntax Error: ${e.message}`;
+            // Try to extract line number and adjust for function body
+            const lineMatch = e.message.match(/\((\d+):(\d+)\)/);
+            if (lineMatch) {
+                const line = parseInt(lineMatch[1]);
+                const col = lineMatch[2];
+                // Subtract the number of lines in the template before the body
+                const templateLines = schema.template("").split("\n").length - 1;
+                const actualLine = Math.max(1, line - templateLines);
+                errorMessage = `Syntax Error at line ${actualLine}, column ${col}: ${e.message.split("(")[0]}`;
+            }
+            errors.push(errorMessage);
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+            wrappedCode: errors.length === 0 ? wrappedCode : undefined,
+        };
+    }
+    /**
+     * Validate that return statements match expected structure
+     */
+    static validateReturnStructure(ast, expectedProperties) {
+        const warnings = [];
+        const foundReturns = [];
+        walk.simple(ast, {
+            ReturnStatement(node) {
+                if (node.argument) {
+                    foundReturns.push(node.argument);
+                }
+            },
+        });
+        // 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(", ")}`);
+            }
+        });
+        return warnings;
+    }
+    /**
+     * Security analysis - checks for forbidden functions and properties
+     */
+    static analyzeSecurityIssues(ast) {
+        const issues = [];
+        walk.simple(ast, {
+            CallExpression(node) {
+                if (node.callee.type === "Identifier") {
+                    const name = node.callee.name;
+                    if (CodeValidator.FORBIDDEN_GLOBALS.includes(name)) {
+                        issues.push({
+                            type: "forbidden_function",
+                            message: `Forbidden function call: ${name}()`,
+                            line: node.loc?.start.line || 0,
+                            column: node.loc?.start.column || 0,
+                        });
+                    }
+                }
+            },
+            NewExpression(node) {
+                if (node.callee.type === "Identifier" &&
+                    node.callee.name === "Function") {
+                    issues.push({
+                        type: "function_constructor",
+                        message: "Using Function constructor is forbidden",
+                        line: node.loc?.start.line || 0,
+                        column: node.loc?.start.column || 0,
+                    });
+                }
+            },
+            MemberExpression(node) {
+                if (node.property.type === "Identifier") {
+                    const propName = node.property.name;
+                    if (CodeValidator.FORBIDDEN_PROPERTIES.includes(propName)) {
+                        issues.push({
+                            type: "forbidden_property",
+                            message: `Access to '${propName}' is forbidden`,
+                            line: node.loc?.start.line || 0,
+                            column: node.loc?.start.column || 0,
+                        });
+                    }
+                }
+            },
+        });
+        return issues;
+    }
+    /**
+     * Detect dangerous patterns like infinite loops
+     */
+    static detectDangerousPatterns(ast) {
+        const issues = [];
+        walk.simple(ast, {
+            WhileStatement(node) {
+                if (node.test.type === "Literal" && node.test.value === true) {
+                    issues.push({
+                        type: "infinite_loop",
+                        message: "Potential infinite loop: while(true)",
+                        line: node.loc?.start.line || 0,
+                    });
+                }
+            },
+            ForStatement(node) {
+                if (!node.test) {
+                    issues.push({
+                        type: "infinite_loop",
+                        message: "Potential infinite loop: for(;;)",
+                        line: node.loc?.start.line || 0,
+                    });
+                }
+            },
+            WithStatement(node) {
+                issues.push({
+                    type: "with_statement",
+                    message: "'with' statement is forbidden",
+                    line: node.loc?.start.line || 0,
+                });
+            },
+        });
+        return issues;
+    }
+    /**
+     * Check for best practices
+     */
+    static checkBestPractices(ast, schema) {
+        const warnings = [];
+        let hasReturn = false;
+        walk.simple(ast, {
+            ReturnStatement() {
+                hasReturn = true;
+            },
+        });
+        if (!hasReturn) {
+            warnings.push(`Function should return a value (expected: ${schema.returnType.description})`);
+        }
+        return warnings;
+    }
+}
+exports.CodeValidator = CodeValidator;
+CodeValidator.FORBIDDEN_GLOBALS = [
+    "eval",
+    "Function",
+    "importScripts",
+    "Worker",
+    "SharedWorker",
+    "WebSocket",
+    "XMLHttpRequest",
+    "fetch",
+];
+CodeValidator.FORBIDDEN_PROPERTIES = [
+    "localStorage",
+    "sessionStorage",
+    "indexedDB",
+    "webkitStorageInfo",
+    "__proto__",
+];

package/dist/lib/worker/worker-factory.d.ts

@@ -0,0 +1,3 @@
+export declare class WorkerFactory {
+    static createCodeRunnerWorker(): Worker;
+}

package/dist/lib/worker/worker-factory.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerFactory = void 0;
+// lib/src/workers/worker-factory.ts
+class WorkerFactory {
+    static createCodeRunnerWorker() {
+        const workerCode = `
+      // Complete worker implementation
+      self.addEventListener('message', (event) => {
+        const { id, code, functionName, args } = event.data;
+        
+        try {
+          const startTime = Date.now();
+          const logs = [];
+          
+          // Capture console outputs
+          const originalConsole = {
+            log: console.log,
+            error: console.error,
+            warn: console.warn
+          };
+          
+          console.log = (...args) => {
+            logs.push({
+              type: 'log',
+              message: args.join(' '),
+              timestamp: Date.now()
+            });
+          };
+          
+          console.error = (...args) => {
+            logs.push({
+              type: 'error', 
+              message: args.join(' '),
+              timestamp: Date.now()
+            });
+          };
+          
+          console.warn = (...args) => {
+            logs.push({
+              type: 'warn',
+              message: args.join(' '), 
+              timestamp: Date.now()
+            });
+          };
+          
+          // Execute the code
+          const func = new Function('args', code);
+          const result = func(args);
+          
+          // Restore console
+          Object.assign(console, originalConsole);
+          
+          self.postMessage({
+            id,
+            success: true,
+            result,
+            logs,
+            executionTime: Date.now() - startTime
+          });
+          
+        } catch (error) {
+          self.postMessage({
+            id,
+            success: false,
+            error: {
+              message: error.message,
+              name: error.name,
+              stack: error.stack
+            },
+            logs,
+            executionTime: Date.now() - startTime
+          });
+        }
+      });
+    `;
+        const blob = new Blob([workerCode], { type: "application/javascript" });
+        return new Worker(URL.createObjectURL(blob));
+    }
+}
+exports.WorkerFactory = WorkerFactory;

package/dist/test/MockRunner.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for MockRunner class - ONDC Automation Mock Runner
+ */
+export {};

package/dist/test/MockRunner.test.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Tests for MockRunner class - ONDC Automation Mock Runner
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const MockRunner_1 = require("../lib/MockRunner");
+describe("MockRunner", () => {
+    let mockRunner;
+    let mockConfig;
+    beforeEach(() => {
+        mockConfig = {
+            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: "",
+        };
+        try {
+            mockRunner = new MockRunner_1.MockRunner(mockConfig);
+            mockConfig.steps.push(mockRunner.getDefaultStep("search", "search_0"));
+        }
+        catch (error) {
+            throw error;
+        }
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe("Constructor", () => {
+        it("should create MockRunner with valid config", () => {
+            expect(mockRunner).toBeDefined();
+            expect(mockRunner).toBeInstanceOf(MockRunner_1.MockRunner);
+        });
+    });
+    describe("Config Validation", () => {
+        it("should validate correct config successfully", () => {
+            const validation = mockRunner.validateConfig();
+            expect(validation.success).toBe(true);
+            expect(validation.errors).toBeUndefined();
+        });
+        it("should detect validation errors in invalid config", () => {
+            expect(() => {
+                new MockRunner_1.MockRunner({
+                    meta: { domain: "", version: "", flowId: "" },
+                    transaction_data: {
+                        transaction_id: "",
+                        latest_timestamp: "",
+                        bap_id: "",
+                        bap_uri: "invalid-url",
+                        bpp_id: "",
+                        bpp_uri: "invalid-url",
+                    },
+                    steps: [],
+                    transaction_history: [],
+                    validationLib: "",
+                    helperLib: "",
+                });
+            }).toThrow();
+        });
+    });
+    describe("Generate Payload", () => {
+        it("should generate payload successfully", async () => {
+            const result = await mockRunner.runGeneratePayload("search_0", {
+                category: "Electronics",
+            });
+            expect(result).toBeDefined();
+            expect(result.success).toBe(true);
+            expect(result.result).toBeDefined();
+            expect(result.timestamp).toBeDefined();
+            expect(typeof result.executionTime).toBe("number");
+        });
+        it("should fail with non-existent action ID", async () => {
+            const result = await mockRunner.runGeneratePayload("non-existent", {});
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+            expect(result.error.message).toContain("not found");
+        });
+    });
+    describe("Validate Payload", () => {
+        it("should validate payload successfully", async () => {
+            const targetPayload = {
+                context: { domain: "retail", action: "search" },
+                message: {
+                    intent: { category: { descriptor: { name: "Electronics" } } },
+                },
+            };
+            const result = await mockRunner.runValidatePayload("search_0", targetPayload);
+            expect(result).toBeDefined();
+            expect(result.success).toBe(true);
+        });
+        it("should fail validation with invalid action ID", async () => {
+            const result = await mockRunner.runValidatePayload("invalid-id", {});
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+            expect(result.error.name).toBe("PayloadValidationError");
+        });
+    });
+    describe("Context Generation", () => {
+        it("should generate context for search action (v2.0)", () => {
+            const context = mockRunner.generateContext("search_0", "search");
+            expect(context).toBeDefined();
+            expect(context.domain).toBe("ONDC:TRV14");
+            expect(context.action).toBe("search");
+            expect(context.transaction_id).toBe("e9e0b5cb-3f15-48a1-9d86-d4d643f0909d");
+            expect(context.message_id).toBeDefined();
+            expect(context.timestamp).toBeDefined();
+            expect(context.bap_id).toBe("");
+            expect(context.bap_uri).toBe("");
+            // v2.0 specific fields
+            expect(context.version).toBe("2.0.0");
+            expect(context.location).toBeDefined();
+            expect(context.location.country.code).toBe("IND");
+            // Search action should not have BPP details
+            expect(context.bpp_id).toBeUndefined();
+            expect(context.bpp_uri).toBeUndefined();
+        });
+        it("should generate context for non-search action", () => {
+            // Add a select step first
+            mockConfig.steps.push(mockRunner.getDefaultStep("select", "select_0"));
+            const context = mockRunner.generateContext("select_0", "select");
+            expect(context.bpp_id).toBe("");
+            expect(context.bpp_uri).toBe("");
+            expect(context.action).toBe("select");
+        });
+    });
+    describe("Session Data Management", () => {
+        it("should extract session data correctly", () => {
+            const sessionData = mockRunner.getSessionDataUpToStep(0, mockConfig);
+            expect(sessionData).toEqual({});
+        });
+        it("should handle invalid step indices", () => {
+            const sessionData = mockRunner.getSessionDataUpToStep(-1, mockConfig);
+            expect(sessionData).toEqual({});
+        });
+    });
+});

package/dist/test/__mocks__/uuid.d.ts

@@ -0,0 +1,5 @@
+export declare const v4: jest.Mock<string, [], any>;
+declare const _default: {
+    v4: jest.Mock<string, [], any>;
+};
+export default _default;

package/dist/test/__mocks__/uuid.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v4 = void 0;
+// Mock implementation of uuid for Jest tests
+exports.v4 = jest.fn(() => "mocked-uuid-v4-12345678-1234-1234-1234-123456789012");
+exports.default = {
+    v4: exports.v4,
+};

package/dist/test/setup.d.ts

@@ -0,0 +1,3 @@
+/**
+ * Jest setup file for ONDC Mock Runner tests
+ */

package/dist/test/setup.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Jest setup file for ONDC Mock Runner tests
+ */
+// Global test configuration
+beforeAll(() => {
+    // Set up any global test configuration
+    process.env.NODE_ENV = "test";
+});
+afterAll(() => {
+    // Clean up after all tests
+});
+beforeEach(() => {
+    // Reset any mocks or state before each test
+    jest.clearAllMocks();
+});
+afterEach(() => {
+    // Clean up after each test
+});
+// Extend Jest matchers
+expect.extend({
+    toBeValidExecutionResult(received) {
+        const pass = received &&
+            typeof received === "object" &&
+            typeof received.success === "boolean" &&
+            typeof received.timestamp === "string" &&
+            Array.isArray(received.logs) &&
+            received.validation &&
+            typeof received.validation.isValid === "boolean";
+        if (pass) {
+            return {
+                message: () => `Expected ${received} not to be a valid ExecutionResult`,
+                pass: true,
+            };
+        }
+        else {
+            return {
+                message: () => `Expected ${received} to be a valid ExecutionResult`,
+                pass: false,
+            };
+        }
+    },
+});