@ondc/automation-mock-runner 0.0.1

package/dist/lib/runners/browser-runner.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserRunner = void 0;
+const code_validator_1 = require("../validators/code-validator");
+const worker_factory_1 = require("../worker/worker-factory");
+class BrowserRunner {
+    constructor() {
+        this.worker = null;
+        this.executionId = 0;
+        this.pendingExecutions = new Map();
+        this.initWorker();
+    }
+    initWorker() {
+        if (this.worker) {
+            this.worker.terminate();
+        }
+        this.worker = worker_factory_1.WorkerFactory.createCodeRunnerWorker();
+        this.worker.addEventListener("message", (event) => {
+            const { id, success, result, error, logs, executionTime } = event.data;
+            const pending = this.pendingExecutions.get(id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingExecutions.delete(id);
+                pending.resolve({
+                    timestamp: new Date().toISOString(),
+                    success,
+                    result,
+                    error,
+                    logs,
+                    executionTime,
+                    validation: { isValid: true, errors: [], warnings: [] },
+                });
+            }
+        });
+        this.worker.addEventListener("error", (error) => {
+            console.error("Worker error:", error);
+            this.initWorker();
+        });
+    }
+    async execute(functionBody, schema, args) {
+        const validation = code_validator_1.CodeValidator.validate(functionBody, schema);
+        if (!validation.isValid || !validation.wrappedCode) {
+            return {
+                success: false,
+                timestamp: new Date().toISOString(),
+                error: {
+                    message: validation.errors.join("\n"),
+                    name: "ValidationError",
+                },
+                logs: [],
+                validation,
+            };
+        }
+        // Execute wrapped code in worker
+        return new Promise((resolve) => {
+            const id = ++this.executionId;
+            const timeout = schema.timeout || 5000;
+            const timeoutId = setTimeout(() => {
+                this.pendingExecutions.delete(id);
+                resolve({
+                    success: false,
+                    timestamp: new Date().toISOString(),
+                    error: {
+                        message: `Execution timeout after ${timeout}ms`,
+                        name: "TimeoutError",
+                    },
+                    logs: [],
+                    validation,
+                });
+                this.initWorker();
+            }, timeout); // Type assertion for compatibility
+            this.pendingExecutions.set(id, {
+                resolve: (result) => {
+                    resolve({ ...result, validation });
+                },
+                timeout: timeoutId,
+            });
+            this.worker?.postMessage({
+                id,
+                code: validation.wrappedCode,
+                functionName: schema.name,
+                args,
+            });
+        });
+    }
+    terminate() {
+        this.worker?.terminate();
+        this.worker = null;
+    }
+}
+exports.BrowserRunner = BrowserRunner;

package/dist/lib/runners/node-runner.d.ts

@@ -0,0 +1,16 @@
+import { FunctionSchema } from "../constants/function-registry";
+import { ExecutionResult } from "../types/execution-results";
+import { BaseCodeRunner } from "./base-runner";
+export declare class NodeRunner implements BaseCodeRunner {
+    private worker;
+    private executionId;
+    private pendingExecutions;
+    private readonly workerPath;
+    private readonly maxMemoryMB;
+    constructor(options?: {
+        maxMemoryMB?: number;
+    });
+    private initWorker;
+    execute(functionBody: string, schema: FunctionSchema, args: any[]): Promise<ExecutionResult>;
+    terminate(): void;
+}

package/dist/lib/runners/node-runner.js

@@ -0,0 +1,189 @@
+"use strict";
+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.NodeRunner = void 0;
+const worker_threads_1 = require("worker_threads");
+const code_validator_1 = require("../validators/code-validator");
+const path = __importStar(require("path"));
+class NodeRunner {
+    constructor(options = {}) {
+        this.worker = null;
+        this.executionId = 0;
+        this.pendingExecutions = new Map();
+        this.workerPath = path.join(__dirname, "../../../public/node-worker.js");
+        this.maxMemoryMB = options.maxMemoryMB || 128;
+        this.initWorker();
+    }
+    initWorker() {
+        if (this.worker) {
+            this.worker.terminate();
+        }
+        // Create worker with resource limits
+        this.worker = new worker_threads_1.Worker(this.workerPath, {
+            resourceLimits: {
+                maxOldGenerationSizeMb: this.maxMemoryMB,
+                maxYoungGenerationSizeMb: this.maxMemoryMB / 2,
+                codeRangeSizeMb: 16,
+            },
+            // Prevent worker from accessing parent environment variables
+            env: {},
+        });
+        this.worker.on("message", (message) => {
+            const { id, success, result, error, logs, executionTime } = message;
+            const pending = this.pendingExecutions.get(id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingExecutions.delete(id);
+                pending.resolve({
+                    timestamp: new Date().toISOString(),
+                    success,
+                    result,
+                    error,
+                    logs,
+                    executionTime,
+                    validation: { isValid: true, errors: [], warnings: [] },
+                });
+            }
+        });
+        this.worker.on("error", (error) => {
+            console.error("Worker error:", error);
+            // Resolve all pending executions with error
+            this.pendingExecutions.forEach((pending, id) => {
+                clearTimeout(pending.timeout);
+                pending.resolve({
+                    success: false,
+                    timestamp: new Date().toISOString(),
+                    error: {
+                        message: error.message || "Worker crashed",
+                        name: "WorkerError",
+                    },
+                    logs: [],
+                    validation: { isValid: true, errors: [], warnings: [] },
+                });
+            });
+            this.pendingExecutions.clear();
+            this.initWorker();
+        });
+        this.worker.on("exit", (code) => {
+            if (code !== 0) {
+                console.error(`Worker stopped with exit code ${code}`);
+                // Handle any pending executions
+                this.pendingExecutions.forEach((pending, id) => {
+                    clearTimeout(pending.timeout);
+                    pending.resolve({
+                        success: false,
+                        timestamp: new Date().toISOString(),
+                        error: {
+                            message: `Worker exited with code ${code}`,
+                            name: "WorkerExitError",
+                        },
+                        logs: [],
+                        validation: { isValid: true, errors: [], warnings: [] },
+                    });
+                });
+                this.pendingExecutions.clear();
+            }
+        });
+    }
+    async execute(functionBody, schema, args) {
+        const validation = code_validator_1.CodeValidator.validate(functionBody, schema);
+        if (!validation.isValid || !validation.wrappedCode) {
+            return {
+                success: false,
+                timestamp: new Date().toISOString(),
+                error: {
+                    message: validation.errors.join("\n"),
+                    name: "ValidationError",
+                },
+                logs: [],
+                validation,
+            };
+        }
+        return new Promise((resolve) => {
+            const id = ++this.executionId;
+            const timeout = schema.timeout || 5000;
+            const timeoutId = setTimeout(() => {
+                this.pendingExecutions.delete(id);
+                resolve({
+                    success: false,
+                    timestamp: new Date().toISOString(),
+                    error: {
+                        message: `Execution timeout after ${timeout}ms`,
+                        name: "TimeoutError",
+                    },
+                    logs: [],
+                    validation,
+                });
+                // Restart worker to kill the hanging execution
+                this.initWorker();
+            }, timeout);
+            this.pendingExecutions.set(id, {
+                resolve: (result) => {
+                    resolve({ ...result, validation });
+                },
+                timeout: timeoutId,
+            });
+            // Send code to worker for execution
+            this.worker?.postMessage({
+                id,
+                code: validation.wrappedCode,
+                functionName: schema.name,
+                args,
+                timeout,
+            });
+        });
+    }
+    terminate() {
+        // Clear all pending executions
+        this.pendingExecutions.forEach((pending) => {
+            clearTimeout(pending.timeout);
+            pending.resolve({
+                success: false,
+                timestamp: new Date().toISOString(),
+                error: {
+                    message: "Runner terminated",
+                    name: "TerminationError",
+                },
+                logs: [],
+                validation: { isValid: true, errors: [], warnings: [] },
+            });
+        });
+        this.pendingExecutions.clear();
+        // Terminate worker
+        this.worker?.terminate();
+        this.worker = null;
+    }
+}
+exports.NodeRunner = NodeRunner;

package/dist/lib/runners/runner-factory.d.ts

@@ -0,0 +1,25 @@
+import { Worker } from "worker_threads";
+import { BrowserRunner } from "./browser-runner";
+import { NodeRunner } from "./node-runner";
+/**
+ * Factory for creating workers in both browser and Node.js environments
+ */
+export declare class RunnerFactory {
+    /**
+     * Creates a Web Worker for browser environment
+     */
+    static createCodeRunnerWorker(): Worker;
+    /**
+     * Creates a Worker Thread for Node.js environment
+     * Note: This is primarily for internal use by NodeRunner
+     */
+    static createNodeWorker(workerPath: string, options?: any): Worker;
+    /**
+     * Detects the current environment
+     */
+    static getEnvironment(): "browser" | "node" | "unknown";
+    /**
+     * Creates appropriate runner based on environment
+     */
+    static createRunner(options?: any): BrowserRunner | NodeRunner;
+}

package/dist/lib/runners/runner-factory.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerFactory = void 0;
+const worker_threads_1 = require("worker_threads");
+const browser_runner_1 = require("./browser-runner");
+const node_runner_1 = require("./node-runner");
+/**
+ * Factory for creating workers in both browser and Node.js environments
+ */
+class RunnerFactory {
+    /**
+     * Creates a Web Worker for browser environment
+     */
+    static createCodeRunnerWorker() {
+        // Browser environment - returns Web Worker
+        if (typeof window !== "undefined" && typeof worker_threads_1.Worker !== "undefined") {
+            // Inline worker code for browser
+            const workerCode = `
+				self.addEventListener('message', (event) => {
+					const { id, code, functionName, args } = event.data;
+					const startTime = performance.now();
+					const logs = [];
+
+					// Override console to capture logs
+					const originalConsole = { ...console };
+					console.log = (...args) => {
+						logs.push(args.join(' '));
+						originalConsole.log(...args);
+					};
+
+					try {
+						// Execute code
+						eval(code);
+						const fn = self[functionName];
+						
+						if (typeof fn !== 'function') {
+							throw new Error(\`\${functionName} is not a function\`);
+						}
+
+						const result = fn(...args);
+						const executionTime = performance.now() - startTime;
+
+						self.postMessage({
+							id,
+							success: true,
+							result,
+							logs,
+							executionTime
+						});
+					} catch (error) {
+						const executionTime = performance.now() - startTime;
+						self.postMessage({
+							id,
+							success: false,
+							error: {
+								message: error.message,
+								name: error.name,
+								stack: error.stack
+							},
+							logs,
+							executionTime
+						});
+					} finally {
+						// Restore console
+						console.log = originalConsole.log;
+					}
+				});
+			`;
+            const blob = new Blob([workerCode], { type: "application/javascript" });
+            const workerUrl = URL.createObjectURL(blob);
+            return new worker_threads_1.Worker(workerUrl);
+        }
+        // Node.js environment - returns Worker Thread
+        // This shouldn't be called for NodeRunner, but included for completeness
+        throw new Error("Use NodeRunner directly in Node.js environment instead of WorkerFactory");
+    }
+    /**
+     * Creates a Worker Thread for Node.js environment
+     * Note: This is primarily for internal use by NodeRunner
+     */
+    static createNodeWorker(workerPath, options) {
+        if (typeof worker_threads_1.Worker === "undefined") {
+            throw new Error("Worker threads not available in this environment");
+        }
+        return new worker_threads_1.Worker(workerPath, options);
+    }
+    /**
+     * Detects the current environment
+     */
+    static getEnvironment() {
+        if (typeof window !== "undefined" && typeof document !== "undefined") {
+            return "browser";
+        }
+        if (typeof process !== "undefined" && process.versions?.node) {
+            return "node";
+        }
+        return "unknown";
+    }
+    /**
+     * Creates appropriate runner based on environment
+     */
+    static createRunner(options) {
+        const env = RunnerFactory.getEnvironment();
+        if (env === "browser") {
+            return new browser_runner_1.BrowserRunner();
+        }
+        else if (env === "node") {
+            return new node_runner_1.NodeRunner(options);
+        }
+        throw new Error(`Unsupported environment: ${env}`);
+    }
+}
+exports.RunnerFactory = RunnerFactory;

package/dist/lib/types/execution-results.d.ts

@@ -0,0 +1,30 @@
+export interface ExecutionResult {
+    timestamp: string;
+    success: boolean;
+    result?: any;
+    error?: {
+        message: string;
+        stack?: string;
+        name: string;
+    };
+    logs: Array<{
+        type: "log" | "error" | "warn";
+        message: string;
+        timestamp: number;
+    }>;
+    executionTime?: number;
+    validation: ValidationResult;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    wrappedCode?: string;
+}
+export interface CodeStatistics {
+    lines: number;
+    functions: number;
+    complexity: number;
+    loops: number;
+    conditionals: number;
+}

package/dist/lib/types/execution-results.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/types/mock-config.d.ts

@@ -0,0 +1,107 @@
+import { z } from "zod";
+export declare const OwnerSchema: z.ZodEnum<{
+    BAP: "BAP";
+    BPP: "BPP";
+}>;
+export declare const MetaSchema: z.ZodObject<{
+    domain: z.ZodString;
+    version: z.ZodString;
+    flowId: z.ZodString;
+}, z.core.$strip>;
+export declare const TransactionDataSchema: z.ZodObject<{
+    transaction_id: z.ZodString;
+    latest_timestamp: z.ZodString;
+    bap_id: z.ZodOptional<z.ZodString>;
+    bap_uri: z.ZodOptional<z.ZodString>;
+    bpp_id: z.ZodOptional<z.ZodString>;
+    bpp_uri: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const MockConfigSchema: z.ZodObject<{
+    generate: z.ZodString;
+    validate: z.ZodString;
+    requirements: z.ZodString;
+    defaultPayload: z.ZodAny;
+    saveData: z.ZodRecord<z.ZodString, z.ZodString>;
+    inputs: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const PlaygroundActionStepSchema: z.ZodObject<{
+    api: z.ZodString;
+    action_id: z.ZodString;
+    owner: z.ZodEnum<{
+        BAP: "BAP";
+        BPP: "BPP";
+    }>;
+    responseFor: z.ZodNullable<z.ZodString>;
+    unsolicited: z.ZodBoolean;
+    description: z.ZodString;
+    mock: z.ZodObject<{
+        generate: z.ZodString;
+        validate: z.ZodString;
+        requirements: z.ZodString;
+        defaultPayload: z.ZodAny;
+        saveData: z.ZodRecord<z.ZodString, z.ZodString>;
+        inputs: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            jsonSchema: z.ZodOptional<z.ZodAny>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const TransactionHistoryItemSchema: z.ZodObject<{
+    action_id: z.ZodString;
+    payload: z.ZodAny;
+    saved_info: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+export declare const MockPlaygroundConfigSchema: z.ZodObject<{
+    meta: z.ZodObject<{
+        domain: z.ZodString;
+        version: z.ZodString;
+        flowId: z.ZodString;
+    }, z.core.$strip>;
+    transaction_data: z.ZodObject<{
+        transaction_id: z.ZodString;
+        latest_timestamp: z.ZodString;
+        bap_id: z.ZodOptional<z.ZodString>;
+        bap_uri: z.ZodOptional<z.ZodString>;
+        bpp_id: z.ZodOptional<z.ZodString>;
+        bpp_uri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    steps: z.ZodArray<z.ZodObject<{
+        api: z.ZodString;
+        action_id: z.ZodString;
+        owner: z.ZodEnum<{
+            BAP: "BAP";
+            BPP: "BPP";
+        }>;
+        responseFor: z.ZodNullable<z.ZodString>;
+        unsolicited: z.ZodBoolean;
+        description: z.ZodString;
+        mock: z.ZodObject<{
+            generate: z.ZodString;
+            validate: z.ZodString;
+            requirements: z.ZodString;
+            defaultPayload: z.ZodAny;
+            saveData: z.ZodRecord<z.ZodString, z.ZodString>;
+            inputs: z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                jsonSchema: z.ZodOptional<z.ZodAny>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    transaction_history: z.ZodArray<z.ZodObject<{
+        action_id: z.ZodString;
+        payload: z.ZodAny;
+        saved_info: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$strip>>;
+    validationLib: z.ZodString;
+    helperLib: z.ZodString;
+}, z.core.$strip>;
+export type Owner = z.infer<typeof OwnerSchema>;
+export type Meta = z.infer<typeof MetaSchema>;
+export type TransactionData = z.infer<typeof TransactionDataSchema>;
+export type MockConfig = z.infer<typeof MockConfigSchema>;
+export type PlaygroundActionStep = z.infer<typeof PlaygroundActionStepSchema>;
+export type TransactionHistoryItem = z.infer<typeof TransactionHistoryItemSchema>;
+export type MockPlaygroundConfigType = z.infer<typeof MockPlaygroundConfigSchema>;

package/dist/lib/types/mock-config.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPlaygroundConfigSchema = exports.TransactionHistoryItemSchema = exports.PlaygroundActionStepSchema = exports.MockConfigSchema = exports.TransactionDataSchema = exports.MetaSchema = exports.OwnerSchema = void 0;
+const zod_1 = require("zod");
+// Zod schemas
+exports.OwnerSchema = zod_1.z.enum(["BAP", "BPP"]);
+exports.MetaSchema = zod_1.z.object({
+    domain: zod_1.z.string().min(1, "Domain is required"),
+    version: zod_1.z.string().min(1, "Version is required"),
+    flowId: zod_1.z.string().min(1, "Flow ID is required"),
+});
+exports.TransactionDataSchema = zod_1.z.object({
+    transaction_id: zod_1.z.string().min(1, "Transaction ID is required"),
+    latest_timestamp: zod_1.z.string().min(1, "Latest timestamp is required"),
+    bap_id: zod_1.z.string().optional(),
+    bap_uri: zod_1.z.string().min(1, "BAP URI is required").optional(),
+    bpp_id: zod_1.z.string().min(1, "BPP ID is required").optional(),
+    bpp_uri: zod_1.z.string().min(1, "BPP URI is required").optional(),
+});
+exports.MockConfigSchema = zod_1.z.object({
+    generate: zod_1.z.string(),
+    validate: zod_1.z.string(),
+    requirements: zod_1.z.string(),
+    defaultPayload: zod_1.z.any(),
+    saveData: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
+    inputs: zod_1.z.object({
+        id: zod_1.z.string().min(1, "Input ID is required").optional(),
+        jsonSchema: zod_1.z.any().optional(),
+    }),
+});
+exports.PlaygroundActionStepSchema = zod_1.z.object({
+    api: zod_1.z.string().min(1, "API is required"),
+    action_id: zod_1.z.string().min(1, "Action ID is required"),
+    owner: exports.OwnerSchema,
+    responseFor: zod_1.z.string().nullable(),
+    unsolicited: zod_1.z.boolean(),
+    description: zod_1.z.string(),
+    mock: exports.MockConfigSchema,
+});
+exports.TransactionHistoryItemSchema = zod_1.z.object({
+    action_id: zod_1.z.string().min(1, "Action ID is required"),
+    payload: zod_1.z.any(),
+    saved_info: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+});
+exports.MockPlaygroundConfigSchema = zod_1.z.object({
+    meta: exports.MetaSchema,
+    transaction_data: exports.TransactionDataSchema,
+    steps: zod_1.z.array(exports.PlaygroundActionStepSchema),
+    transaction_history: zod_1.z.array(exports.TransactionHistoryItemSchema),
+    validationLib: zod_1.z.string(),
+    helperLib: zod_1.z.string(),
+});

package/dist/lib/utils/errors.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Custom error classes for better error handling and debugging
+ */
+export declare class MockRunnerError extends Error {
+    readonly code: string;
+    readonly context: Record<string, any>;
+    readonly timestamp: string;
+    constructor(message: string, code: string, context?: Record<string, any>);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        context: Record<string, any>;
+        timestamp: string;
+        stack: string | undefined;
+    };
+}
+export declare class ConfigurationError extends MockRunnerError {
+    constructor(message: string, context?: Record<string, any>);
+}
+export declare class ValidationError extends MockRunnerError {
+    readonly validationErrors: string[];
+    constructor(message: string, validationErrors?: string[], context?: Record<string, any>);
+}
+export declare class ExecutionError extends MockRunnerError {
+    readonly executionTime: number;
+    readonly actionId: string;
+    constructor(message: string, actionId: string, executionTime?: number, context?: Record<string, any>);
+}
+export declare class SecurityError extends MockRunnerError {
+    readonly securityViolation: string;
+    constructor(message: string, violation: string, context?: Record<string, any>);
+}
+export declare class TimeoutError extends MockRunnerError {
+    readonly timeoutMs: number;
+    constructor(message: string, timeoutMs: number, context?: Record<string, any>);
+}
+export declare class ActionNotFoundError extends MockRunnerError {
+    readonly actionId: string;
+    readonly availableActions: string[];
+    constructor(actionId: string, availableActions?: string[]);
+}
+export declare class SessionDataError extends MockRunnerError {
+    readonly stepIndex: number;
+    readonly jsonPath: string;
+    constructor(message: string, stepIndex: number, jsonPath?: string, context?: Record<string, any>);
+}