impulse-api 3.0.9 → 3.0.10

package/package.json

@@ -14,7 +14,7 @@
     "test:integration": "nyc --reporter=lcov --reporter=text-summary mocha 'test/integration/**/*-test.js'",
     "test-server": "node ./test/integration/test-server.js"
   },
-  "version": "3.0.9",
+  "version": "3.0.10",
   "engines": {
     "node": ">=22"
   },

package/src/server.js

@@ -177,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) {

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/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/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',