@centeredgesoft/runtime-mock-routes 2.10.3 → 2.11.1

package/build/server.js

@@ -1,4 +1,37 @@
 "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;
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -17,7 +50,7 @@ const fs_1 = __importDefault(require("fs"));
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
 const commander_1 = require("commander");
-const path_1 = require("path");
+const path_1 = __importStar(require("path"));
 const app_1 = require("./src/app");
 const appV2_1 = require("./src/appV2");
 var AppVersion;
@@ -32,20 +65,43 @@ const runServer = (sdk) => {
         .option("--tlsCert <tlsCertPath>", "Path to the TLS certificate file", process.env.HTTPS_CERT_FILE)
         .option("--tlsKey <tlsKeyPath>", "Path to the TLS key file", process.env.HTTPS_CERT_KEY_FILE)
         .option("-s, --seed <filePath>", "File path to seed the application", process.env.RUNTIME_MOCK_ROUTES_FILE_PATH)
-        .option("-a, --appVersion <appVersion>", "App Version to use", AppVersion.v2);
+        .option("-a, --appVersion <appVersion>", "App Version to use", AppVersion.v2)
+        .option("-w, --watch", "Watch the seed file for changes and reload routes without restarting", false)
+        .option("--watch-poll [interval]", "Use stat polling instead of fs.watch (useful for network drives / containers / bind mounts). Optionally specify poll interval in ms.", false);
     commander_1.program.parse(process.argv);
-    let initialRequests = {};
-    if (commander_1.program.seed) {
-        const filePath = (0, path_1.resolve)(commander_1.program.seed);
+    const seedFilePath = commander_1.program.seed ? (0, path_1.resolve)(commander_1.program.seed) : null;
+    // Tracks all files transitively required by the seed so we can bust & re-watch them
+    let trackedDeps = new Set();
+    function loadSeed(filePath) {
+        // Bust cache for all previously tracked deps so we get fresh modules on reload
+        for (const key of trackedDeps) {
+            delete require.cache[key];
+        }
+        // Snapshot before requiring — anything new afterwards is a transitive dep
+        const cacheBefore = new Set(Object.keys(require.cache));
         const funcOrJson = require(filePath);
-        initialRequests = typeof funcOrJson === 'function' ? funcOrJson() : funcOrJson;
+        trackedDeps = new Set();
+        for (const key of Object.keys(require.cache)) {
+            const normalizedKey = path_1.default.normalize(key);
+            const segments = normalizedKey.split(path_1.default.sep);
+            if (!cacheBefore.has(key) && !segments.includes('node_modules')) {
+                trackedDeps.add(key);
+            }
+        }
+        return typeof funcOrJson === 'function' ? funcOrJson() : funcOrJson;
+    }
+    let initialRequests = {};
+    if (seedFilePath) {
+        initialRequests = loadSeed(seedFilePath);
     }
     const appVersions = {
         v1: app_1.appFactory,
         v2: appV2_1.appFactory
     };
     const appFactory = appVersions[commander_1.program.appVersion] || appV2_1.appFactory;
-    const app = appFactory(initialRequests);
+    // Use a mutable handler so the servers don't need to rebind ports on reload
+    let currentApp = appFactory(initialRequests);
+    const handler = (req, res) => currentApp(req, res);
     // Setup HTTPS options
     const httpsOptions = commander_1.program.tlsCert && commander_1.program.tlsKey && fs_1.default.existsSync(commander_1.program.tlsCert) && fs_1.default.existsSync(commander_1.program.tlsKey)
         ? {
@@ -54,8 +110,8 @@ const runServer = (sdk) => {
             enabled: true
         }
         : { enabled: false };
-    const httpServer = http_1.default.createServer(app);
-    const httpsServer = httpsOptions.enabled ? https_1.default.createServer(httpsOptions, app) : null;
+    const httpServer = http_1.default.createServer(handler);
+    const httpsServer = httpsOptions.enabled ? https_1.default.createServer(httpsOptions, handler) : null;
     httpServer.listen(commander_1.program.port, () => {
         console.log(`⚡️[server]: Server is running at http://localhost:${commander_1.program.port}`);
     });
@@ -64,6 +120,76 @@ const runServer = (sdk) => {
             console.log(`⚡️[server]: Server is running at https://localhost:${commander_1.program.httpsPort}`);
         });
     }
+    // Watch seed and all transitive dependencies for changes
+    if (commander_1.program.watch && seedFilePath) {
+        let watchDebounce = null;
+        const usePolling = commander_1.program.watchPoll !== false;
+        const pollInterval = typeof commander_1.program.watchPoll === 'string' ? parseInt(commander_1.program.watchPoll, 10) || 300 : 300;
+        function doReload() {
+            watchDebounce = null;
+            try {
+                const newRequests = loadSeed(seedFilePath);
+                currentApp = appFactory(newRequests);
+                console.log(`🔥[watch]: Seed reloaded — watching ${trackedDeps.size} file(s)`);
+                rewatchDeps();
+            }
+            catch (err) {
+                console.error('🔥[watch]: Failed to reload seed:', err);
+            }
+        }
+        function scheduleReload() {
+            if (watchDebounce)
+                clearTimeout(watchDebounce);
+            watchDebounce = setTimeout(doReload, 100);
+        }
+        let watchedFiles = new Set();
+        let depWatchers = [];
+        function rewatchDeps() {
+            const deps = [...trackedDeps].filter(d => fs_1.default.existsSync(d));
+            if (usePolling) {
+                // Stop polling files no longer in the dep set
+                for (const f of watchedFiles) {
+                    if (!trackedDeps.has(f)) {
+                        fs_1.default.unwatchFile(f);
+                        watchedFiles.delete(f);
+                    }
+                }
+                // Start polling new deps
+                for (const dep of deps) {
+                    if (!watchedFiles.has(dep)) {
+                        fs_1.default.watchFile(dep, { persistent: true, interval: pollInterval }, (curr, prev) => {
+                            if (curr.mtimeMs !== prev.mtimeMs)
+                                scheduleReload();
+                        });
+                        watchedFiles.add(dep);
+                    }
+                }
+            }
+            else {
+                // Native fs.watch path
+                for (const w of depWatchers)
+                    w.close();
+                depWatchers = [];
+                for (const dep of deps) {
+                    try {
+                        const w = fs_1.default.watch(dep, { persistent: true }, (eventType) => {
+                            if (eventType !== 'change' && eventType !== 'rename')
+                                return;
+                            scheduleReload();
+                        });
+                        w.on('error', (err) => console.error(`🔥[watch]: Watcher error for ${dep}:`, err));
+                        depWatchers.push(w);
+                    }
+                    catch (_a) {
+                        // File may have been removed; skip
+                    }
+                }
+            }
+        }
+        rewatchDeps();
+        const watchMode = usePolling ? `stat polling (${pollInterval}ms)` : 'fs.watch';
+        console.log(`🔥[watch]: Watching seed and ${trackedDeps.size} dep(s) via ${watchMode} — ${seedFilePath}`);
+    }
     // Register signal handlers
     process.on('SIGINT', () => gracefulShutdown('SIGINT'));
     process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@centeredgesoft/runtime-mock-routes",
-  "version": "2.10.3",
+  "version": "2.11.1",
   "description": "",
   "main": "build/index.js",
   "scripts": {
     "build": "tsc --project ./",
     "start": "nodemon -r dotenv/config index.ts",
     "test": "jest",
-    "serve": "ts-node run.ts -s ./example/seed.js"
+    "serve": "ts-node run.ts --watch --seed ./example/seed.js",
+    "serve.poll": "ts-node run.ts --watch --watch-poll=5000 --seed ./example/seed.js"
   },
   "bin": {
     "runtime-mock-routes": "./build/run.js"

package/server.ts

@@ -3,7 +3,7 @@ import http from 'http';
 import https from 'https';
 import { Express } from 'express'
 import { program } from 'commander';
-import { resolve } from 'path';
+import path, { resolve } from 'path';
 import { appFactory as appFactoryV1 } from './src/app';
 import { appFactory as appFactoryV2 } from './src/appV2';
 import { NodeSDK } from '@opentelemetry/sdk-node';
@@ -21,14 +21,42 @@ const runServer = (sdk: NodeSDK) => {
         .option("--tlsKey <tlsKeyPath>", "Path to the TLS key file", process.env.HTTPS_CERT_KEY_FILE)
         .option("-s, --seed <filePath>", "File path to seed the application", process.env.RUNTIME_MOCK_ROUTES_FILE_PATH)
         .option("-a, --appVersion <appVersion>", "App Version to use", AppVersion.v2)
+        .option("-w, --watch", "Watch the seed file for changes and reload routes without restarting", false)
+        .option("--watch-poll [interval]", "Use stat polling instead of fs.watch (useful for network drives / containers / bind mounts). Optionally specify poll interval in ms.", false)
 
     program.parse(process.argv);
 
-    let initialRequests: any = {};
-    if (program.seed) {
-        const filePath = resolve(program.seed);
+    const seedFilePath = program.seed ? resolve(program.seed) : null;
+
+    // Tracks all files transitively required by the seed so we can bust & re-watch them
+    let trackedDeps = new Set<string>();
+
+    function loadSeed(filePath: string): any {
+
+        // Bust cache for all previously tracked deps so we get fresh modules on reload
+        for (const key of trackedDeps) {
+            delete require.cache[key];
+        }
+
+        // Snapshot before requiring — anything new afterwards is a transitive dep
+        const cacheBefore = new Set(Object.keys(require.cache));
         const funcOrJson = require(filePath);
-        initialRequests = typeof funcOrJson === 'function' ? funcOrJson() : funcOrJson;
+
+        trackedDeps = new Set<string>();
+        for (const key of Object.keys(require.cache)) {
+            const normalizedKey = path.normalize(key);
+            const segments = normalizedKey.split(path.sep);
+            if (!cacheBefore.has(key) && !segments.includes('node_modules')) {
+                trackedDeps.add(key);
+            }
+        }
+
+        return typeof funcOrJson === 'function' ? funcOrJson() : funcOrJson;
+    }
+
+    let initialRequests: any = {};
+    if (seedFilePath) {
+        initialRequests = loadSeed(seedFilePath);
     }
 
     type AppFactory = (...args: any[]) => Express;
@@ -39,7 +67,9 @@ const runServer = (sdk: NodeSDK) => {
     }
     const appFactory = appVersions[program.appVersion] || appFactoryV2;
 
-    const app = appFactory(initialRequests);
+    // Use a mutable handler so the servers don't need to rebind ports on reload
+    let currentApp = appFactory(initialRequests);
+    const handler: http.RequestListener = (req, res) => currentApp(req, res);
 
     // Setup HTTPS options
     const httpsOptions = program.tlsCert && program.tlsKey && fs.existsSync(program.tlsCert) && fs.existsSync(program.tlsKey)
@@ -50,16 +80,88 @@ const runServer = (sdk: NodeSDK) => {
         }
         : { enabled: false };
 
-    const httpServer = http.createServer(app);
-    const httpsServer = httpsOptions.enabled ? https.createServer(httpsOptions, app) : null;  
+    const httpServer = http.createServer(handler);
+    const httpsServer = httpsOptions.enabled ? https.createServer(httpsOptions, handler) : null;
 
     httpServer.listen(program.port, () => {
         console.log(`⚡️[server]: Server is running at http://localhost:${program.port}`);
     });
+
     if (httpsServer) {
-    httpsServer.listen(program.httpsPort, () => {
-        console.log(`⚡️[server]: Server is running at https://localhost:${program.httpsPort}`);
-    });
+        httpsServer.listen(program.httpsPort, () => {
+            console.log(`⚡️[server]: Server is running at https://localhost:${program.httpsPort}`);
+        });
+    }
+
+    // Watch seed and all transitive dependencies for changes
+    if (program.watch && seedFilePath) {
+        let watchDebounce: ReturnType<typeof setTimeout> | null = null;
+        const usePolling = program.watchPoll !== false;
+        const pollInterval = typeof program.watchPoll === 'string' ? parseInt(program.watchPoll, 10) || 300 : 300;
+
+        function doReload() {
+            watchDebounce = null;
+            try {
+                const newRequests = loadSeed(seedFilePath);
+                currentApp = appFactory(newRequests);
+                console.log(`🔥[watch]: Seed reloaded — watching ${trackedDeps.size} file(s)`);
+                rewatchDeps();
+            } catch (err) {
+                console.error('🔥[watch]: Failed to reload seed:', err);
+            }
+        }
+
+        function scheduleReload() {
+            if (watchDebounce) clearTimeout(watchDebounce);
+            watchDebounce = setTimeout(doReload, 100);
+        }
+
+        let watchedFiles = new Set<string>();
+        let depWatchers: fs.FSWatcher[] = [];
+
+        function rewatchDeps() {
+            const deps = [...trackedDeps].filter(d => fs.existsSync(d));
+
+            if (usePolling) {
+                // Stop polling files no longer in the dep set
+                for (const f of watchedFiles) {
+                    if (!trackedDeps.has(f)) {
+                        fs.unwatchFile(f);
+                        watchedFiles.delete(f);
+                    }
+                }
+                // Start polling new deps
+                for (const dep of deps) {
+                    if (!watchedFiles.has(dep)) {
+                        fs.watchFile(dep, { persistent: true, interval: pollInterval }, (curr, prev) => {
+                            if (curr.mtimeMs !== prev.mtimeMs) scheduleReload();
+                        });
+                        watchedFiles.add(dep);
+                    }
+                }
+            } else {
+                // Native fs.watch path
+                for (const w of depWatchers) w.close();
+                depWatchers = [];
+
+                for (const dep of deps) {
+                    try {
+                        const w = fs.watch(dep, { persistent: true }, (eventType) => {
+                            if (eventType !== 'change' && eventType !== 'rename') return;
+                            scheduleReload();
+                        });
+                        w.on('error', (err) => console.error(`🔥[watch]: Watcher error for ${dep}:`, err));
+                        depWatchers.push(w);
+                    } catch {
+                        // File may have been removed; skip
+                    }
+                }
+            }
+        }
+
+        rewatchDeps();
+        const watchMode = usePolling ? `stat polling (${pollInterval}ms)` : 'fs.watch';
+        console.log(`🔥[watch]: Watching seed and ${trackedDeps.size} dep(s) via ${watchMode} — ${seedFilePath}`);
     }
 
     // Register signal handlers