impulse-api 3.0.8 → 3.0.10

package/package.json

@@ -9,10 +9,12 @@
   ],
   "scripts": {
     "lint": "eslint --ignore-path .gitignore .",
-    "test": "nyc --reporter=lcov --reporter=text-summary mocha",
+    "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-server": "node ./test/integration/test-server.js"
   },
-  "version": "3.0.8",
+  "version": "3.0.10",
   "engines": {
     "node": ">=22"
   },

package/src/server.js

@@ -92,9 +92,8 @@ class Server {
         this.http.use(express.urlencoded({
             extended: true,
         }));
-        this.http.use(express.json({
-            extended: true,
-        }));
+        // Don't use global express.json() - apply it per-route to avoid conflicts with rawBody routes
+        // express.urlencoded() is safe to keep global as it only parses application/x-www-form-urlencoded
         this.http.use(fileUpload({
             preserveExtension: 10
         }));
@@ -178,6 +177,40 @@ class Server {
         };
 
         function sendResponse(error, response) {
+            // 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) {
@@ -485,10 +518,10 @@ class Server {
                     if (route.rawBody === true) {
                         this.http[verb](route.endpoint, express.raw({ type: 'application/json' }), this.preprocessor.bind(this, route));
                     } else {
+                        // Apply express.json() per-route for routes that need JSON parsing
                         // express-fileupload handles multipart/form-data (including files)
-                        // express.json() handles JSON bodies
-                        // multer().none() is not needed and conflicts with file uploads
-                        this.http[verb](route.endpoint, this.preprocessor.bind(this, route));
+                        // express.urlencoded() is already global and only parses form-encoded data
+                        this.http[verb](route.endpoint, express.json({ extended: true }), this.preprocessor.bind(this, route));
                     }
 
                 });

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

@@ -0,0 +1,113 @@
+const Server = require('../../src/server');
+const assert = require('assert');
+const http = require('http');
+const path = require('path');
+
+describe('rawBody HTTP Integration', () => {
+    let testServer;
+    let testRouteDir;
+    let testPort = 9998;
+
+    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.http) {
+            await new Promise((resolve) => {
+                if (testServer.http.listening) {
+                    testServer.http.close(() => resolve());
+                } else {
+                    resolve();
+                }
+            });
+        }
+    });
+
+    it('should receive raw Buffer via HTTP request when rawBody is true', async () => {
+
+        // Make HTTP POST request
+        const testBody = JSON.stringify({ test: 'data', value: 123 });
+        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 });
+                });
+            });
+
+            req.on('error', reject);
+            req.write(testBody);
+            req.end();
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        const responseBody = JSON.parse(response.body);
+        assert.strictEqual(responseBody.success, true);
+        assert.strictEqual(responseBody.isBuffer, true);
+        assert.strictEqual(responseBody.rawBodyString, testBody);
+    });
+
+    it('should receive parsed JSON via HTTP request when rawBody is false', async () => {
+
+        // Make HTTP POST request
+        const testBody = JSON.stringify({ test: 'data', value: 123 });
+        const response = await new Promise((resolve, reject) => {
+            const options = {
+                hostname: 'localhost',
+                port: testPort,
+                path: '/normal',
+                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 });
+                });
+            });
+
+            req.on('error', reject);
+            req.write(testBody);
+            req.end();
+        });
+
+        assert.strictEqual(response.statusCode, 200);
+        const responseBody = JSON.parse(response.body);
+        assert.strictEqual(responseBody.success, true);
+        assert.strictEqual(responseBody.test, 'data');
+        assert.strictEqual(responseBody.value, 123);
+    });
+});
+

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

@@ -0,0 +1,259 @@
+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.http) {
+            await new Promise((resolve) => {
+                if (testServer.http.listening) {
+                    testServer.http.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/normal.js

@@ -0,0 +1,24 @@
+exports.normal = {
+    name: 'normal',
+    method: 'post',
+    endpoint: '/normal',
+    inputs: {
+        test: {
+            required: true
+        },
+        value: {
+            required: true
+        }
+    },
+    run: (services, inputs, next) => {
+        if (inputs.rawBody !== undefined) {
+            return next(500, { error: 'rawBody should not be set' });
+        }
+        next(200, { 
+            success: true,
+            test: inputs.test,
+            value: inputs.value
+        });
+    }
+};
+

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/integration/routes/webhook.js

@@ -0,0 +1,18 @@
+exports.webhook = {
+    name: 'webhook',
+    method: 'post',
+    endpoint: '/webhook',
+    rawBody: true,
+    run: (services, inputs, next) => {
+        if (!Buffer.isBuffer(inputs.rawBody)) {
+            return next(500, { error: 'rawBody is not a Buffer' });
+        }
+        next(200, { 
+            success: true, 
+            isBuffer: Buffer.isBuffer(inputs.rawBody),
+            rawBodyLength: inputs.rawBody.length,
+            rawBodyString: inputs.rawBody.toString()
+        });
+    }
+};
+

package/test/{api-test.js → unit/api-test.js}

@@ -1,4 +1,4 @@
-const Api = require('../src/api');
+const Api = require('../../src/api');
 const assert = require('assert');
 
 describe('server-test', () => {

package/test/{custom-jwt-validation.js → unit/custom-jwt-validation.js}

@@ -1,6 +1,6 @@
 const assert = require('assert');
-const Api = require('../src/api');
-const Auth = require('../src/auth');
+const Api = require('../../src/api');
+const Auth = require('../../src/auth');
 
 describe('Custom JWT Validation', () => {
     let testServer;