impulse-api 3.0.10 → 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.10",
+  "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,13 @@ 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.
@@ -249,7 +255,7 @@ class Server {
                     success: false,
                     error: err
                 });
-                return;
+                return Promise.resolve();
             }
 
             try {
@@ -278,7 +284,7 @@ class Server {
                     success: false,
                     error
                 });
-                return;
+                return Promise.resolve();
             }
         }
 
@@ -289,7 +295,7 @@ class Server {
         if (route.applicationAuth) {
             if (!key || key !== this.appKey) {
                 sendResponse(this.errors.UnauthorizedUser());
-                return;
+                return Promise.resolve();
             }
         }
 
@@ -307,7 +313,7 @@ class Server {
                 data = this.buildParameters(paramsForInputs, route.inputs);
             } catch (error) {
                 sendResponse(error);
-                return;
+                return Promise.resolve();
             }
         }
 
@@ -321,7 +327,7 @@ class Server {
                 data.headers = this.buildParameters(req.headers, route.headers);
             } catch (error) {
                 sendResponse(error);
-                return;
+                return Promise.resolve();
             }
         }
 
@@ -332,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

@@ -23,10 +23,13 @@ describe('rawResponse 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/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

@@ -935,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);
+        });
+    });
 });