@ondc/automation-mock-runner 1.3.17 → 1.3.19

package/dist/lib/MockRunner.d.ts

@@ -4,7 +4,7 @@ import { Logger } from "./utils/logger";
 import { ExecutionResult } from "./types/execution-results";
 export declare class MockRunner {
     private config;
-    private runner;
+    private static sharedRunner;
     logger: Logger;
     constructor(config: MockPlaygroundConfigType, skipValidation?: boolean);
     getRunnerInstance(): BaseCodeRunner;

package/dist/lib/MockRunner.js

@@ -38,11 +38,12 @@ class MockRunner {
     }
     getRunnerInstance() {
         this.logger.debug("Getting code runner instance");
-        if (!this.runner) {
-            this.runner = runner_factory_1.RunnerFactory.createRunner({}, this.logger);
+        if (!MockRunner.sharedRunner) {
+            MockRunner.sharedRunner = runner_factory_1.RunnerFactory.createRunner({}, this.logger);
         }
-        this.logger.debug("Code runner instance obtained successfully: " + this.runner.toString());
-        return this.runner;
+        this.logger.debug("Code runner instance obtained successfully: " +
+            MockRunner.sharedRunner.toString());
+        return MockRunner.sharedRunner;
     }
     getConfig() {
         return this.config;

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

@@ -2,15 +2,40 @@ 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 pool;
+    private waitQueue;
     private executionId;
-    private pendingExecutions;
+    private isTerminating;
     private readonly workerPath;
     private readonly maxMemoryMB;
+    private readonly poolSize;
+    private readonly maxExecutionsPerWorker;
+    private readonly maxWorkerAgeMs;
     constructor(options?: {
         maxMemoryMB?: number;
+        poolSize?: number;
+        maxExecutionsPerWorker?: number;
+        maxWorkerAgeMs?: number;
     });
-    private initWorker;
+    private createPooledWorker;
+    /**
+     * Terminate old worker (frees its V8 isolate) and replace with a fresh one.
+     */
+    private replaceWorker;
+    private shouldRecycle;
+    private acquire;
+    private release;
     execute(functionBody: string, schema: FunctionSchema, args: any[]): Promise<ExecutionResult>;
-    terminate(): void;
+    terminate(): Promise<void>;
+    getStats(): {
+        poolSize: number;
+        busy: number;
+        idle: number;
+        waitingInQueue: number;
+        workers: {
+            busy: boolean;
+            executionCount: number;
+            ageSeconds: string;
+        }[];
+    };
 }

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

@@ -37,86 +37,108 @@ exports.NodeRunner = void 0;
 const worker_threads_1 = require("worker_threads");
 const code_validator_1 = require("../validators/code-validator");
 const path = __importStar(require("path"));
+const DEFAULT_POOL_SIZE = 10;
+const MAX_EXECUTIONS_PER_WORKER = 100;
+const MAX_WORKER_AGE_MS = 10 * 60 * 1000; // 10 minutes
 class NodeRunner {
     constructor(options = {}) {
-        this.worker = null;
+        this.pool = [];
+        this.waitQueue = [];
         this.executionId = 0;
-        this.pendingExecutions = new Map();
+        this.isTerminating = false;
         this.workerPath = path.join(__dirname, "../../../public/node-worker.js");
         this.maxMemoryMB = options.maxMemoryMB || 128;
-        this.initWorker();
-    }
-    initWorker() {
-        if (this.worker) {
-            this.worker.terminate();
+        this.poolSize = options.poolSize || DEFAULT_POOL_SIZE;
+        this.maxExecutionsPerWorker =
+            options.maxExecutionsPerWorker || MAX_EXECUTIONS_PER_WORKER;
+        this.maxWorkerAgeMs = options.maxWorkerAgeMs || MAX_WORKER_AGE_MS;
+        // Pre-warm the pool
+        for (let i = 0; i < this.poolSize; i++) {
+            this.pool.push(this.createPooledWorker());
         }
-        // Create worker with resource limits
-        this.worker = new worker_threads_1.Worker(this.workerPath, {
+    }
+    // ── Worker lifecycle ───────────────────────────────────
+    createPooledWorker() {
+        const 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();
+        const pw = {
+            worker,
+            busy: false,
+            executionCount: 0,
+            createdAt: Date.now(),
+        };
+        worker.on("error", (error) => {
+            console.error("[NodeRunner] Worker error:", error.message);
+            this.replaceWorker(pw);
         });
-        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();
+        worker.on("exit", (code) => {
+            if (code !== 0 && !this.isTerminating) {
+                console.error(`[NodeRunner] Worker exited with code ${code}`);
+                this.replaceWorker(pw);
             }
         });
+        return pw;
+    }
+    /**
+     * Terminate old worker (frees its V8 isolate) and replace with a fresh one.
+     */
+    replaceWorker(pw) {
+        if (this.isTerminating)
+            return;
+        const idx = this.pool.indexOf(pw);
+        if (idx === -1)
+            return;
+        pw.worker.removeAllListeners();
+        pw.worker.terminate().catch(() => { });
+        const newPw = this.createPooledWorker();
+        this.pool[idx] = newPw;
+        // Hand to next waiting caller if any
+        if (this.waitQueue.length > 0) {
+            const next = this.waitQueue.shift();
+            newPw.busy = true;
+            next(newPw);
+        }
+    }
+    shouldRecycle(pw) {
+        return (pw.executionCount >= this.maxExecutionsPerWorker ||
+            Date.now() - pw.createdAt > this.maxWorkerAgeMs);
+    }
+    // ── Pool management ────────────────────────────────────
+    acquire() {
+        const idle = this.pool.find((pw) => !pw.busy);
+        if (idle) {
+            idle.busy = true;
+            return Promise.resolve(idle);
+        }
+        // All busy — wait in queue
+        return new Promise((resolve) => {
+            this.waitQueue.push(resolve);
+        });
+    }
+    release(pw) {
+        pw.busy = false;
+        pw.executionCount++;
+        // Recycle if stale — this is what prevents the slow memory creep
+        if (this.shouldRecycle(pw)) {
+            console.info(`[NodeRunner] Recycling worker (executions: ${pw.executionCount}, ` +
+                `age: ${((Date.now() - pw.createdAt) / 1000).toFixed(0)}s)`);
+            this.replaceWorker(pw);
+            return;
+        }
+        // Hand to next waiting caller
+        if (this.waitQueue.length > 0) {
+            const next = this.waitQueue.shift();
+            pw.busy = true;
+            next(pw);
+        }
     }
+    // ── Execution ──────────────────────────────────────────
     async execute(functionBody, schema, args) {
         const validation = code_validator_1.CodeValidator.validate(functionBody, schema);
         if (!validation.isValid || !validation.wrappedCode) {
@@ -131,11 +153,33 @@ class NodeRunner {
                 validation,
             };
         }
+        const pw = await this.acquire();
         return new Promise((resolve) => {
             const id = ++this.executionId;
             const timeout = schema.timeout || 5000;
+            const cleanup = () => {
+                pw.worker.removeListener("message", onMessage);
+                clearTimeout(timeoutId);
+            };
+            const onMessage = (message) => {
+                if (message.id !== id)
+                    return;
+                cleanup();
+                this.release(pw);
+                resolve({
+                    timestamp: new Date().toISOString(),
+                    success: message.success,
+                    result: message.result,
+                    error: message.error,
+                    logs: message.logs,
+                    executionTime: message.executionTime,
+                    validation,
+                });
+            };
             const timeoutId = setTimeout(() => {
-                this.pendingExecutions.delete(id);
+                cleanup();
+                // Timeout: kill THIS worker and replace it (bounded — pool stays fixed size)
+                this.replaceWorker(pw);
                 resolve({
                     success: false,
                     timestamp: new Date().toISOString(),
@@ -146,17 +190,9 @@ class NodeRunner {
                     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({
+            pw.worker.on("message", onMessage);
+            pw.worker.postMessage({
                 id,
                 code: validation.wrappedCode,
                 functionName: schema.name,
@@ -165,25 +201,29 @@ class NodeRunner {
             });
         });
     }
-    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;
+    // ── Cleanup ────────────────────────────────────────────
+    async terminate() {
+        this.isTerminating = true;
+        this.waitQueue = [];
+        await Promise.all(this.pool.map((pw) => {
+            pw.worker.removeAllListeners();
+            return pw.worker.terminate().catch(() => { });
+        }));
+        this.pool = [];
+    }
+    // ── Diagnostics (expose via /metrics) ──────────────────
+    getStats() {
+        return {
+            poolSize: this.pool.length,
+            busy: this.pool.filter((pw) => pw.busy).length,
+            idle: this.pool.filter((pw) => !pw.busy).length,
+            waitingInQueue: this.waitQueue.length,
+            workers: this.pool.map((pw) => ({
+                busy: pw.busy,
+                executionCount: pw.executionCount,
+                ageSeconds: ((Date.now() - pw.createdAt) / 1000).toFixed(0),
+            })),
+        };
     }
 }
 exports.NodeRunner = NodeRunner;

package/dist/test/MockRunner.test.js

@@ -43,6 +43,31 @@ describe("MockRunner", () => {
             expect(mockRunner).toBeDefined();
             expect(mockRunner).toBeInstanceOf(MockRunner_1.MockRunner);
         });
+        it("should reuse the same BaseCodeRunner across MockRunner instances", async () => {
+            const baseConfig = {
+                meta: {
+                    domain: "ONDC:TRV14",
+                    version: "2.0.0",
+                    flowId: "singleton-test",
+                },
+                transaction_data: {
+                    transaction_id: "11111111-1111-1111-1111-111111111111",
+                    latest_timestamp: "1970-01-01T00:00:00.000Z",
+                },
+                steps: [],
+                transaction_history: [],
+                validationLib: "",
+                helperLib: "",
+            };
+            const firstRunner = new MockRunner_1.MockRunner(baseConfig, true);
+            firstRunner
+                .getConfig()
+                .steps.push(firstRunner.getDefaultStep("search", "search_0"));
+            const optimizedConfig = await (0, configHelper_1.createOptimizedMockConfig)(firstRunner.getConfig());
+            const mockRunnerA = new MockRunner_1.MockRunner(optimizedConfig, true);
+            const mockRunnerB = new MockRunner_1.MockRunner(optimizedConfig, true);
+            expect(mockRunnerA.getRunnerInstance()).toBe(mockRunnerB.getRunnerInstance());
+        });
     });
     describe("Config Validation", () => {
         it("should validate correct config successfully", () => {

package/package.json

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