impulse-api 3.0.9 → 3.0.11

package/package.json

@@ -10,11 +10,11 @@
   "scripts": {
     "lint": "eslint --ignore-path .gitignore .",
     "test": "npm run test:unit && npm run test:integration",
-    "test:unit": "nyc --reporter=lcov --reporter=text-summary mocha test/unit/**/*.js",
-    "test:integration": "nyc --reporter=lcov --reporter=text-summary mocha 'test/integration/**/*-test.js'",
+    "test:unit": "mocha test/unit/**/*.js",
+    "test:integration": "mocha test/integration/**/*-test.js",
     "test-server": "node ./test/integration/test-server.js"
   },
-  "version": "3.0.9",
+  "version": "3.0.11",
   "engines": {
     "node": ">=22"
   },
@@ -24,7 +24,7 @@
     "express": "4.21.2",
     "express-fileupload": "1.5.1",
     "http-errors": "2.0.0",
-    "jsonwebtoken": "8.5.1",
+    "jsonwebtoken": "^9.0.2",
     "lodash": "4.17.21",
     "morgan": "1.10.0",
     "path-to-regexp": "0.1.12"
@@ -32,7 +32,7 @@
   "devDependencies": {
     "eslint": "^9.23.0",
     "eslint-plugin-import": "^2.31.0",
-    "nyc": "^17.1.0",
+    "mocha": "^10.2.0",
     "pre-commit": "^1.2.2",
     "sinon": "4.4.6"
   },

package/src/server.js

@@ -71,8 +71,8 @@ class Server {
                 return;
             }
 
-            // Start the HTTP server
-            this.http.listen(this.port, () => {
+            // Start the HTTP server - store the server instance so we can close it later
+            this.server = this.http.listen(this.port, () => {
                 console.log('Server initialized:');
                 console.log(`-- name: ${this.name}`);
                 console.log(`-- version: ${this.version}`);
@@ -176,7 +176,47 @@ class Server {
             }).bind(req)
         };
 
-        function sendResponse(error, response) {
+        function sendResponse(error, response, headers) {
+            // Set headers if provided (for rawResponse mode)
+            if (headers && typeof headers === 'object') {
+                Object.keys(headers).forEach(key => {
+                    res.setHeader(key, headers[key]);
+                });
+            }
+            // Handle raw responses - send Buffer/string as-is without JSON serialization
+            // When rawResponse is true, only Buffer and string are sent raw via res.end().
+            // All other types fall through to default JSON serialization below.
+            if (route.rawResponse === true) {
+                if (response && !error) {
+                    // Successful response - send raw if Buffer or string
+                    if (Buffer.isBuffer(response) || typeof response === 'string') {
+                        res.status(200).end(response);
+                        return;
+                    }
+                    // Not raw-compatible, fall through to default JSON serialization
+                } else if (error && !response) {
+                    // Error response - send raw if Buffer or string
+                    if (Buffer.isBuffer(error) || typeof error === 'string') {
+                        const statusCode = (typeof error === 'number' && !isNaN(error)) ? error : 400;
+                        res.status(statusCode).end(error);
+                        return;
+                    }
+                    // Not raw-compatible, fall through to default JSON serialization
+                } else if (error && response) {
+                    // Status code with response (redirects, etc.)
+                    if ((error === 302 || error === 301 || error === 307 || error === 308) && response.Location) {
+                        res.status(error).header('Location', response.Location).end();
+                        return;
+                    } else if (Buffer.isBuffer(response) || typeof response === 'string') {
+                        res.status(error).end(response);
+                        return;
+                    }
+                    // Not raw-compatible, fall through to default JSON serialization
+                }
+                // If rawResponse is true but response is not Buffer/string, fall through to default
+            }
+
+            // Default JSON serialization behavior
             if (error instanceof Error) {
                 res.status(error.statusCode ? error.statusCode : 400).send(error);
             } else if (error && !response) {
@@ -215,7 +255,7 @@ class Server {
                     success: false,
                     error: err
                 });
-                return;
+                return Promise.resolve();
             }
 
             try {
@@ -244,7 +284,7 @@ class Server {
                     success: false,
                     error
                 });
-                return;
+                return Promise.resolve();
             }
         }
 
@@ -255,7 +295,7 @@ class Server {
         if (route.applicationAuth) {
             if (!key || key !== this.appKey) {
                 sendResponse(this.errors.UnauthorizedUser());
-                return;
+                return Promise.resolve();
             }
         }
 
@@ -273,7 +313,7 @@ class Server {
                 data = this.buildParameters(paramsForInputs, route.inputs);
             } catch (error) {
                 sendResponse(error);
-                return;
+                return Promise.resolve();
             }
         }
 
@@ -287,7 +327,7 @@ class Server {
                 data.headers = this.buildParameters(req.headers, route.headers);
             } catch (error) {
                 sendResponse(error);
-                return;
+                return Promise.resolve();
             }
         }
 
@@ -298,10 +338,19 @@ class Server {
         data.decoded = decoded;
         data._host = req.get('origin') || req.get('host')
 
-        route.run.bind(routeContext)(this.container, data, ((responseError, response) => {
-            sendResponse(responseError, response);
-            return;
-        }).bind(this));
+        return new Promise((resolve) => {
+            try {
+                route.run.bind(routeContext)(this.container, data, ((responseError, response, headers) => {
+                    sendResponse(responseError, response, headers);
+                    resolve();
+                    return;
+                }).bind(this));
+            } catch (error) {
+                // If route.run throws synchronously, handle it
+                sendResponse(error);
+                resolve();
+            }
+        });
     }
 
     buildParameters(params, inputs) {

package/test/integration/rawbody-integration-test.js

@@ -23,10 +23,13 @@ describe('rawBody HTTP Integration', () => {
 
     after(async () => {
         // Clean up test server
-        if (testServer && testServer.http) {
+        if (testServer && testServer.server) {
             await new Promise((resolve) => {
-                if (testServer.http.listening) {
-                    testServer.http.close(() => resolve());
+                if (testServer.server.listening) {
+                    testServer.server.closeAllConnections();
+                    testServer.server.close(() => {
+                        resolve();
+                    });
                 } else {
                     resolve();
                 }

package/test/integration/rawresponse-integration-test.js

@@ -0,0 +1,262 @@
+const Server = require('../../src/server');
+const assert = require('assert');
+const http = require('http');
+const path = require('path');
+
+describe('rawResponse HTTP Integration', () => {
+    let testServer;
+    let testRouteDir;
+    let testPort = 9999;
+
+    before(async () => {
+        testRouteDir = path.join(__dirname, 'routes');
+        // Create and start test server once for all tests (use 'dev' env so server actually starts)
+        testServer = new Server({
+            name: 'test-server',
+            routeDir: testRouteDir,
+            port: testPort,
+            env: 'dev',
+            services: {}
+        });
+        await testServer.init();
+    });
+
+    after(async () => {
+        // Clean up test server
+        if (testServer && testServer.server) {
+            await new Promise((resolve) => {
+                if (testServer.server.listening) {
+                    testServer.server.closeAllConnections();
+                    testServer.server.close(() => {
+                        resolve();
+                    });
+                } else {
+                    resolve();
+                }
+            });
+        }
+    });
+
+    it('should send raw Buffer response when rawResponse is true', async () => {
+        const response = await new Promise((resolve, reject) => {
+            const options = {
+                hostname: 'localhost',
+                port: testPort,
+                path: '/raw-response-buffer',
+                method: 'GET'
+            };
+
+            const req = http.request(options, (res) => {
+                let data = Buffer.alloc(0);
+                res.on('data', (chunk) => {
+                    data = Buffer.concat([data, chunk]);
+                });
+                res.on('end', () => {
+                    resolve({ 
+                        statusCode: res.statusCode, 
+                        body: data,
+                        headers: res.headers
+                    });
+                });
+            });
+
+            req.on('error', reject);
+            req.end();
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        assert.strictEqual(Buffer.isBuffer(response.body), true);
+        assert.strictEqual(response.body.toString(), 'raw buffer response data');
+        // Should not have JSON content-type since it's raw
+        assert.strictEqual(response.headers['content-type'], undefined);
+    });
+
+    it('should send raw string response when rawResponse is true', async () => {
+        const response = await new Promise((resolve, reject) => {
+            const options = {
+                hostname: 'localhost',
+                port: testPort,
+                path: '/raw-response-string',
+                method: 'GET'
+            };
+
+            const req = http.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    resolve({ 
+                        statusCode: res.statusCode, 
+                        body: data,
+                        headers: res.headers
+                    });
+                });
+            });
+
+            req.on('error', reject);
+            req.end();
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        assert.strictEqual(typeof response.body, 'string');
+        assert.strictEqual(response.body, 'raw string response data');
+        // Should not have JSON content-type since it's raw
+        assert.strictEqual(response.headers['content-type'], undefined);
+    });
+
+    it('should send JSON serialized response when rawResponse is false', async () => {
+        const response = await new Promise((resolve, reject) => {
+            const options = {
+                hostname: 'localhost',
+                port: testPort,
+                path: '/json-response',
+                method: 'GET'
+            };
+
+            const req = http.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    resolve({ 
+                        statusCode: res.statusCode, 
+                        body: data,
+                        headers: res.headers
+                    });
+                });
+            });
+
+            req.on('error', reject);
+            req.end();
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        const responseBody = JSON.parse(response.body);
+        assert.strictEqual(responseBody.success, true);
+        assert.strictEqual(responseBody.message, 'This is a JSON response');
+        assert.deepStrictEqual(responseBody.data, { test: 'value' });
+        // Should have JSON content-type when serialized
+        assert.ok(response.headers['content-type'].includes('application/json'));
+    });
+
+    it('should send JSON serialized response when rawResponse is true but object is returned', async () => {
+        const response = await new Promise((resolve, reject) => {
+            const options = {
+                hostname: 'localhost',
+                port: testPort,
+                path: '/raw-response-object',
+                method: 'GET'
+            };
+
+            const req = http.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    resolve({ 
+                        statusCode: res.statusCode, 
+                        body: data,
+                        headers: res.headers
+                    });
+                });
+            });
+
+            req.on('error', reject);
+            req.end();
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        // Even with rawResponse: true, objects should fall through to JSON serialization
+        const responseBody = JSON.parse(response.body);
+        assert.strictEqual(responseBody.success, true);
+        assert.strictEqual(responseBody.message, 'This should be JSON serialized');
+        // Should have JSON content-type when serialized
+        assert.ok(response.headers['content-type'].includes('application/json'));
+    });
+
+    it('should handle raw response with route parameters', async () => {
+        const testBody = JSON.stringify({ prefix: 'PREFIX' });
+        const response = await new Promise((resolve, reject) => {
+            const options = {
+                hostname: 'localhost',
+                port: testPort,
+                path: '/raw-response-params',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(testBody)
+                }
+            };
+
+            const req = http.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    resolve({ 
+                        statusCode: res.statusCode, 
+                        body: data,
+                        headers: res.headers
+                    });
+                });
+            });
+
+            req.on('error', reject);
+            req.write(testBody);
+            req.end();
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        assert.strictEqual(typeof response.body, 'string');
+        assert.strictEqual(response.body, 'PREFIX: raw response with params');
+        // Should not have JSON content-type since it's raw
+        assert.strictEqual(response.headers['content-type'], undefined);
+    });
+
+    it('should handle both rawBody and rawResponse together', async () => {
+        const testBody = 'raw request body';
+        const response = await new Promise((resolve, reject) => {
+            const options = {
+                hostname: 'localhost',
+                port: testPort,
+                path: '/webhook',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(testBody)
+                }
+            };
+
+            const req = http.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    resolve({ 
+                        statusCode: res.statusCode, 
+                        body: data,
+                        headers: res.headers
+                    });
+                });
+            });
+
+            req.on('error', reject);
+            req.write(testBody);
+            req.end();
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        // The webhook route returns JSON (doesn't have rawResponse), so verify JSON
+        const responseBody = JSON.parse(response.body);
+        assert.strictEqual(responseBody.success, true);
+        assert.strictEqual(responseBody.isBuffer, true);
+        // Original functionality: rawBody works for requests
+        assert.strictEqual(responseBody.rawBodyString, testBody);
+    });
+});
+

package/test/integration/routes/raw-response.js

@@ -0,0 +1,65 @@
+exports.rawResponseBuffer = {
+    name: 'rawResponseBuffer',
+    method: 'get',
+    endpoint: '/raw-response-buffer',
+    rawResponse: true,
+    run: (services, inputs, next) => {
+        const buffer = Buffer.from('raw buffer response data');
+        next(null, buffer);
+    }
+};
+
+exports.rawResponseString = {
+    name: 'rawResponseString',
+    method: 'get',
+    endpoint: '/raw-response-string',
+    rawResponse: true,
+    run: (services, inputs, next) => {
+        next(null, 'raw string response data');
+    }
+};
+
+exports.rawResponseWithParams = {
+    name: 'rawResponseWithParams',
+    method: 'post',
+    endpoint: '/raw-response-params',
+    rawResponse: true,
+    inputs: {
+        prefix: {
+            required: true
+        }
+    },
+    run: (services, inputs, next) => {
+        const response = `${inputs.prefix}: raw response with params`;
+        next(null, response);
+    }
+};
+
+exports.jsonResponse = {
+    name: 'jsonResponse',
+    method: 'get',
+    endpoint: '/json-response',
+    rawResponse: false,
+    run: (services, inputs, next) => {
+        next(null, {
+            success: true,
+            message: 'This is a JSON response',
+            data: { test: 'value' }
+        });
+    }
+};
+
+exports.rawResponseObject = {
+    name: 'rawResponseObject',
+    method: 'get',
+    endpoint: '/raw-response-object',
+    rawResponse: true,
+    run: (services, inputs, next) => {
+        // Even with rawResponse: true, objects should fall through to JSON serialization
+        next(null, {
+            success: true,
+            message: 'This should be JSON serialized'
+        });
+    }
+};
+

package/test/unit/api-test.js

@@ -3,7 +3,7 @@ const assert = require('assert');
 
 describe('server-test', () => {
     describe('instantiation', () => {
-        it('should expoes the Errors functions', () => {
+        it('should expose the Errors functions', () => {
             assert(Api.Errors !== undefined);
         });
     });

package/test/unit/custom-jwt-validation.js

@@ -37,6 +37,7 @@ describe('Custom JWT Validation', () => {
                 routeDir: testRouteDir,
                 secretKey: 'test-secret',
                 tokenValidator: customValidator,
+                env: 'test',
                 services: {
                     testService: { name: 'test' }
                 }
@@ -77,6 +78,7 @@ exports.testRoute = {
                 name: 'test-api',
                 routeDir: testRouteDir,
                 secretKey: 'test-secret',
+                env: 'test',
                 services: {}
             };
 
@@ -128,6 +130,7 @@ exports.testRoute = {
                 routeDir: testRouteDir,
                 secretKey: 'test-secret',
                 tokenValidator: serverValidator,
+                env: 'test',
                 services: {}
             };
 
@@ -181,6 +184,7 @@ exports.testRoute = {
                 routeDir: testRouteDir,
                 secretKey: 'test-secret',
                 tokenValidator: serverValidator,
+                env: 'test',
                 services: {}
             };
 
@@ -222,6 +226,7 @@ exports.testRoute = {
                 routeDir: testRouteDir,
                 secretKey: 'test-secret',
                 tokenValidator: failingValidator,
+                env: 'test',
                 services: {}
             };
 
@@ -270,6 +275,7 @@ exports.testRoute = {
                 name: 'test-api',
                 routeDir: testRouteDir,
                 secretKey: 'test-secret',
+                env: 'test',
                 services: {}
             };
 

package/test/unit/server-test.js

@@ -596,7 +596,166 @@ describe('server-test', () => {
             assert.strictEqual(res.statusCode, 200);
         });
 
-        it('should process inputs alongside rawBody when both are present', async () => {
+        it('should send raw response as Buffer when route.rawResponse is true', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = { test: 'data' };
+            const testResponse = Buffer.from('raw response data');
+            const req = {
+                body: testBody,
+                query: {},
+                params: {},
+                files: {},
+                headers: {},
+                get: (header) => {
+                    if (header === 'origin') return 'http://localhost:4000';
+                    if (header === 'host') return 'localhost:4000';
+                    return null;
+                }
+            };
+            const res = {
+                statusCode: 200,
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                },
+                end: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-raw-response',
+                method: 'post',
+                endpoint: '/test',
+                rawResponse: true,
+                run: (services, inputs, next) => {
+                    next(null, testResponse);
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+            assert.strictEqual(Buffer.isBuffer(res.sentData), true);
+            assert.deepStrictEqual(res.sentData, testResponse);
+        });
+
+        it('should send raw response as string when route.rawResponse is true', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = { test: 'data' };
+            const testResponse = 'raw string response';
+            const req = {
+                body: testBody,
+                query: {},
+                params: {},
+                files: {},
+                headers: {},
+                get: (header) => {
+                    if (header === 'origin') return 'http://localhost:4000';
+                    if (header === 'host') return 'localhost:4000';
+                    return null;
+                }
+            };
+            const res = {
+                statusCode: 200,
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                },
+                end: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-raw-response-string',
+                method: 'post',
+                endpoint: '/test',
+                rawResponse: true,
+                run: (services, inputs, next) => {
+                    next(null, testResponse);
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+            assert.strictEqual(typeof res.sentData, 'string');
+            assert.strictEqual(res.sentData, testResponse);
+        });
+
+        it('should JSON serialize response when route.rawResponse is false', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = { test: 'data' };
+            const testResponse = { success: true, data: 'test' };
+            const req = {
+                body: testBody,
+                query: {},
+                params: {},
+                files: {},
+                headers: {},
+                get: (header) => {
+                    if (header === 'origin') return 'http://localhost:4000';
+                    if (header === 'host') return 'localhost:4000';
+                    return null;
+                }
+            };
+            const res = {
+                statusCode: 200,
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                },
+                end: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-json-response',
+                method: 'post',
+                endpoint: '/test',
+                rawResponse: false,
+                run: (services, inputs, next) => {
+                    next(null, testResponse);
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+            // When rawResponse is false, Express will JSON serialize objects
+            assert.deepStrictEqual(res.sentData, testResponse);
+        });
+
+        it('should process inputs alongside rawResponse when both are present', async () => {
             const Api = new Server({
                 name: 'test-Server',
                 routeDir: './test-routes',
@@ -776,4 +935,191 @@ describe('server-test', () => {
             assert.strictEqual(res.statusCode, 200);
         });
     });
+
+    describe('response headers functionality', () => {
+        it('should set headers when passed via next() with rawResponse: true', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = { test: 'data' };
+            const testResponse = Buffer.from('raw response data');
+            const testHeaders = {
+                'Content-Type': 'application/octet-stream',
+                'X-Custom-Header': 'custom-value',
+                'Cache-Control': 'no-cache'
+            };
+            const req = {
+                body: testBody,
+                query: {},
+                params: {},
+                files: {},
+                headers: {},
+                get: (header) => {
+                    if (header === 'origin') return 'http://localhost:4000';
+                    if (header === 'host') return 'localhost:4000';
+                    return null;
+                }
+            };
+            const res = {
+                statusCode: 200,
+                headers: {},
+                setHeader: (key, value) => {
+                    res.headers[key] = value;
+                },
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                },
+                end: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-headers-raw-response',
+                method: 'post',
+                endpoint: '/test',
+                rawResponse: true,
+                run: (services, inputs, next) => {
+                    next(null, testResponse, testHeaders);
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+            assert.strictEqual(Buffer.isBuffer(res.sentData), true);
+            assert.deepStrictEqual(res.sentData, testResponse);
+            assert.strictEqual(res.headers['Content-Type'], 'application/octet-stream');
+            assert.strictEqual(res.headers['X-Custom-Header'], 'custom-value');
+            assert.strictEqual(res.headers['Cache-Control'], 'no-cache');
+        });
+
+        it('should set headers when passed via next() with regular JSON response', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = { test: 'data' };
+            const testResponse = { success: true, message: 'test response' };
+            const testHeaders = {
+                'Content-Type': 'application/json',
+                'X-Request-ID': '12345',
+                'X-Rate-Limit': '100'
+            };
+            const req = {
+                body: testBody,
+                query: {},
+                params: {},
+                files: {},
+                headers: {},
+                get: (header) => {
+                    if (header === 'origin') return 'http://localhost:4000';
+                    if (header === 'host') return 'localhost:4000';
+                    return null;
+                }
+            };
+            const res = {
+                statusCode: 200,
+                headers: {},
+                setHeader: (key, value) => {
+                    res.headers[key] = value;
+                },
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                },
+                end: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-headers-json-response',
+                method: 'post',
+                endpoint: '/test',
+                rawResponse: false,
+                run: (services, inputs, next) => {
+                    next(null, testResponse, testHeaders);
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+            assert.deepStrictEqual(res.sentData, testResponse);
+            assert.strictEqual(res.headers['Content-Type'], 'application/json');
+            assert.strictEqual(res.headers['X-Request-ID'], '12345');
+            assert.strictEqual(res.headers['X-Rate-Limit'], '100');
+        });
+
+        it('should handle routes without headers parameter', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = { test: 'data' };
+            const testResponse = { success: true };
+            const req = {
+                body: testBody,
+                query: {},
+                params: {},
+                files: {},
+                headers: {},
+                get: (header) => {
+                    if (header === 'origin') return 'http://localhost:4000';
+                    if (header === 'host') return 'localhost:4000';
+                    return null;
+                }
+            };
+            const res = {
+                statusCode: 200,
+                headers: {},
+                setHeader: (key, value) => {
+                    res.headers[key] = value;
+                },
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-no-headers',
+                method: 'post',
+                endpoint: '/test',
+                rawResponse: false,
+                run: (services, inputs, next) => {
+                    // Call next without headers parameter (backward compatibility)
+                    next(null, testResponse);
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+            assert.deepStrictEqual(res.sentData, testResponse);
+            // No headers should be set
+            assert.strictEqual(Object.keys(res.headers).length, 0);
+        });
+    });
 });