@centeredgesoft/runtime-mock-routes 2.10.2 → 2.11.0

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,42 @@ 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);
     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 +109,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 +119,54 @@ 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;
+        let depWatchers = [];
+        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 rewatchDeps() {
+            for (const w of depWatchers) {
+                w.close();
+            }
+            depWatchers = [];
+            for (const dep of trackedDeps) {
+                if (!fs_1.default.existsSync(dep)) {
+                    continue;
+                }
+                try {
+                    const w = fs_1.default.watch(dep, { persistent: true }, (eventType) => {
+                        if (eventType !== 'change' && eventType !== 'rename') {
+                            return;
+                        }
+                        if (watchDebounce) {
+                            clearTimeout(watchDebounce);
+                        }
+                        watchDebounce = setTimeout(doReload, 100);
+                    });
+                    w.on('error', (err) => {
+                        console.error(`🔥[watch]: Watcher error for ${dep}:`, err);
+                    });
+                    depWatchers.push(w);
+                }
+                catch (_a) {
+                    // File may have been removed; skip
+                }
+            }
+        }
+        rewatchDeps();
+        console.log(`🔥[watch]: Watching seed and ${trackedDeps.size} dep(s) — ${seedFilePath}`);
+    }
     // Register signal handlers
     process.on('SIGINT', () => gracefulShutdown('SIGINT'));
     process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));

package/build/src/appV2.js

@@ -103,19 +103,26 @@ const appFactory = (runtimeCollection) => {
     if (process.env.LOG_MOCK_REQUESTS === 'true') {
         const logger = api_logs_1.logs.getLogger('mock-requests-logger');
         app.use((req, res, next) => {
-            // log the request
+            let severity = api_logs_1.SeverityNumber.INFO;
+            let severityText = 'INFO';
+            // Log root requests as trace
+            if (req.path === '/') {
+                severity = api_logs_1.SeverityNumber.TRACE;
+                severityText = 'TRACE';
+            }
+            // Log the request
             logger.emit({
-                severityNumber: api_logs_1.SeverityNumber.INFO,
-                severityText: 'INFO',
+                severityNumber: severity,
+                severityText: severityText,
                 body: `Request ${req.path}`,
                 attributes: {
-                    'http.headers': req.headers,
                     'http.method': req.method,
                     'http.url': req.url,
                     'http.request_body': req.body,
+                    'http.request_headers': req.headers,
                 }
             });
-            // log the response
+            // Log the response
             const originalSend = res.send;
             let firstSend = true;
             res.send = function (body) {
@@ -123,14 +130,15 @@ const appFactory = (runtimeCollection) => {
                     // For some reason send gets called twice per request, this ensures we only log once
                     firstSend = false;
                     logger.emit({
-                        severityNumber: api_logs_1.SeverityNumber.INFO,
-                        severityText: 'INFO',
+                        severityNumber: severity,
+                        severityText: severityText,
                         body: `Response ${req.path}`,
                         attributes: {
                             'http.status_code': res.statusCode,
                             'http.method': req.method,
                             'http.url': req.url,
                             'http.response_body': body,
+                            'http.response_headers': res.getHeaders()
                         }
                     });
                 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@centeredgesoft/runtime-mock-routes",
-  "version": "2.10.2",
+  "version": "2.11.0",
   "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 -s ./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,41 @@ 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)
 
     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 +66,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,8 +79,8 @@ 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}`);
@@ -62,6 +91,61 @@ const runServer = (sdk: NodeSDK) => {
     });
     }
 
+    // Watch seed and all transitive dependencies for changes
+    if (program.watch && seedFilePath) {
+        let watchDebounce: ReturnType<typeof setTimeout> | null = null;
+        let depWatchers: fs.FSWatcher[] = [];
+
+        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 rewatchDeps() {
+            for (const w of depWatchers) {
+                w.close();
+            }
+
+            depWatchers = [];
+
+            for (const dep of trackedDeps) {
+                if (!fs.existsSync(dep)) {
+                    continue;
+                }
+
+                try {
+                    const w = fs.watch(dep, { persistent: true }, (eventType) => {
+                        if (eventType !== 'change' && eventType !== 'rename') {
+                            return;
+                        }
+
+                        if (watchDebounce) {
+                            clearTimeout(watchDebounce);
+                        }
+
+                        watchDebounce = setTimeout(doReload, 100);
+                    });
+                    w.on('error', (err) => {
+                        console.error(`🔥[watch]: Watcher error for ${dep}:`, err);
+                    });
+                    depWatchers.push(w);
+                } catch {
+                    // File may have been removed; skip
+                }
+            }
+        }
+
+        rewatchDeps();
+        console.log(`🔥[watch]: Watching seed and ${trackedDeps.size} dep(s) — ${seedFilePath}`);
+    }
+
     // Register signal handlers
     process.on('SIGINT', () => gracefulShutdown('SIGINT'));
     process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));

package/src/appV2.ts

@@ -121,20 +121,30 @@ export const appFactory = (runtimeCollection?: RuntimeRequestCollection) => {
         const logger = logs.getLogger('mock-requests-logger');
 
         app.use((req, res, next) => {
-            // log the request
+
+            let severity = SeverityNumber.INFO;
+            let severityText = 'INFO';
+
+            // Log root requests as trace
+            if (req.path === '/') {
+                severity = SeverityNumber.TRACE;
+                severityText = 'TRACE';
+            }
+
+            // Log the request
             logger.emit({
-                severityNumber: SeverityNumber.INFO,
-                severityText: 'INFO',
+                severityNumber: severity,
+                severityText: severityText,
                 body: `Request ${req.path}`,
                 attributes: {
-                    'http.headers': req.headers,
                     'http.method': req.method,
                     'http.url': req.url,
                     'http.request_body': req.body,
+                    'http.request_headers': req.headers,
                 }
             });
 
-            // log the response
+            // Log the response
             const originalSend = res.send;
             let firstSend = true;
             res.send = function (body) {
@@ -143,14 +153,15 @@ export const appFactory = (runtimeCollection?: RuntimeRequestCollection) => {
                     firstSend = false;
 
                     logger.emit({
-                        severityNumber: SeverityNumber.INFO,
-                        severityText: 'INFO',
+                        severityNumber: severity,
+                        severityText: severityText,
                         body: `Response ${req.path}`,
                         attributes: {
                             'http.status_code': res.statusCode,
                             'http.method': req.method,
                             'http.url': req.url,
                             'http.response_body': body,
+                            'http.response_headers': res.getHeaders()
                         }
                     });
                 }
@@ -305,7 +316,7 @@ export const appFactory = (runtimeCollection?: RuntimeRequestCollection) => {
     app.put(/\/.*/, catchAllHandler);
     app.patch(/\/.*/, catchAllHandler);
     app.delete(/\/.*/, catchAllHandler);
-    
+
     Object.defineProperty(app, 'runtimeRequestCollection', {
         get: () => {
             return cloneDeep(runtimeRequestCollection);