impulse-api 3.0.6 → 3.0.8

package/package.json

@@ -12,7 +12,7 @@
     "test": "nyc --reporter=lcov --reporter=text-summary mocha",
     "test-server": "node ./test/integration/test-server.js"
   },
-  "version": "3.0.6",
+  "version": "3.0.8",
   "engines": {
     "node": ">=22"
   },

package/src/server.js

@@ -266,16 +266,23 @@ class Server {
 
         if (route.inputs) {
             try {
-                data = this.buildParameters(
-                    Object.assign(req.query || {}, req.body || {}, req.params || {}, req.files || {}),
-                    route.inputs
-                );
+                // When rawBody is true, exclude req.body from inputs processing since it's a Buffer
+                const paramsForInputs = route.rawBody === true
+                    ? Object.assign(req.query || {}, req.params || {}, req.files || {})
+                    : Object.assign(req.query || {}, req.body || {}, req.params || {}, req.files || {});
+                
+                data = this.buildParameters(paramsForInputs, route.inputs);
             } catch (error) {
                 sendResponse(error);
                 return;
             }
         }
 
+        // Handle rawBody - append the raw Buffer if rawBody flag is set
+        if (route.rawBody === true) {
+            data.rawBody = req.body; // This will be a Buffer, not a parsed object
+        }
+
         if (route.headers) {
             try {
                 data.headers = this.buildParameters(req.headers, route.headers);
@@ -474,10 +481,15 @@ class Server {
                     method = route.method.toLowerCase();
                     verb = (verbMap[method]) ? verbMap[method] : method;
 
-                    // 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));
+                    // For routes that need raw body (e.g., webhooks), use express.raw() instead of JSON
+                    if (route.rawBody === true) {
+                        this.http[verb](route.endpoint, express.raw({ type: 'application/json' }), this.preprocessor.bind(this, route));
+                    } else {
+                        // 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));
+                    }
 
                 });
             });

package/test/custom-jwt-validation.js

@@ -253,12 +253,13 @@ exports.testRoute = {
         });
 
         it('should validate custom validator function type', () => {
+            const auth = new Auth('test-secret');
             assert.throws(() => {
-                Auth.createCustomValidator('not-a-function');
+                auth.createCustomValidator('not-a-function');
             }, /Custom validator must be a function/);
 
             assert.doesNotThrow(() => {
-                Auth.createCustomValidator(() => {});
+                auth.createCustomValidator(() => {});
             });
         });
     });

package/test/server-test.js

@@ -449,7 +449,7 @@ describe('server-test', () => {
                     auth.createCustomValidator('not-a-function');
                     assert.fail('Should have thrown an error');
                 } catch (e) {
-                    assert.contains(e.message, 'must be a function');
+                    assert.contains(e.message, 'Custom validator must be a function');
                 }
             });
 
@@ -499,4 +499,281 @@ describe('server-test', () => {
             assert.strictEqual(server.auth, null);
         });
     });
+
+    describe('rawBody functionality', () => {
+        it('should set rawBody as Buffer when route.rawBody is true', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = Buffer.from(JSON.stringify({ test: '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 = {
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-raw-body',
+                method: 'post',
+                endpoint: '/test',
+                rawBody: true,
+                run: (services, inputs, next) => {
+                    assert.strictEqual(Buffer.isBuffer(inputs.rawBody), true);
+                    assert.deepStrictEqual(inputs.rawBody, testBody);
+                    next(200, { success: true });
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+        });
+
+        it('should not set rawBody when route.rawBody is false', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = { test: '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 = {
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-no-raw-body',
+                method: 'post',
+                endpoint: '/test',
+                rawBody: false,
+                run: (services, inputs, next) => {
+                    assert.strictEqual(inputs.rawBody, undefined);
+                    next(200, { success: true });
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+        });
+
+        it('should process inputs alongside rawBody when both are present', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = Buffer.from(JSON.stringify({ test: 'data' }));
+            const req = {
+                body: testBody,
+                query: { param1: 'value1' },
+                params: { id: '123' },
+                files: {},
+                headers: {},
+                get: (header) => {
+                    if (header === 'origin') return 'http://localhost:4000';
+                    if (header === 'host') return 'localhost:4000';
+                    return null;
+                }
+            };
+            const res = {
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-raw-body-with-inputs',
+                method: 'post',
+                endpoint: '/test/:id',
+                rawBody: true,
+                inputs: {
+                    param1: {
+                        required: true
+                    },
+                    id: {
+                        required: true
+                    }
+                },
+                run: (services, inputs, next) => {
+                    assert.strictEqual(Buffer.isBuffer(inputs.rawBody), true);
+                    assert.deepStrictEqual(inputs.rawBody, testBody);
+                    assert.strictEqual(inputs.param1, 'value1');
+                    assert.strictEqual(inputs.id, '123');
+                    next(200, { success: true });
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+        });
+
+        it('should handle rawBody without inputs', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = Buffer.from('raw string 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 = {
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-raw-body-only',
+                method: 'post',
+                endpoint: '/test',
+                rawBody: true,
+                run: (services, inputs, next) => {
+                    assert.strictEqual(Buffer.isBuffer(inputs.rawBody), true);
+                    assert.deepStrictEqual(inputs.rawBody, testBody);
+                    next(200, { success: true });
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+        });
+
+        it('should not include Buffer body in inputs processing when rawBody is true', async () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+
+            const testBody = Buffer.from(JSON.stringify({ test: 'data', shouldNotBeParsed: true }));
+            const req = {
+                body: testBody,
+                query: { param1: 'value1' },
+                params: { id: '123' },
+                files: {},
+                headers: {},
+                get: (header) => {
+                    if (header === 'origin') return 'http://localhost:4000';
+                    if (header === 'host') return 'localhost:4000';
+                    return null;
+                }
+            };
+            const res = {
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                send: (data) => {
+                    res.sentData = data;
+                }
+            };
+
+            const route = {
+                name: 'test-raw-body-excluded-from-inputs',
+                method: 'post',
+                endpoint: '/test/:id',
+                rawBody: true,
+                inputs: {
+                    param1: {
+                        required: true
+                    },
+                    id: {
+                        required: true
+                    },
+                    // This should NOT be found in inputs even though it's in the Buffer body
+                    test: {
+                        required: false
+                    },
+                    shouldNotBeParsed: {
+                        required: false
+                    }
+                },
+                run: (services, inputs, next) => {
+                    // Verify rawBody is still a Buffer
+                    assert.strictEqual(Buffer.isBuffer(inputs.rawBody), true);
+                    assert.deepStrictEqual(inputs.rawBody, testBody);
+                    
+                    // Verify inputs from query/params work
+                    assert.strictEqual(inputs.param1, 'value1');
+                    assert.strictEqual(inputs.id, '123');
+                    
+                    // Verify that parsed body fields are NOT in inputs (because Buffer was excluded)
+                    // buildParameters sets missing optional params to empty string, not undefined
+                    assert.strictEqual(inputs.test, "");
+                    assert.strictEqual(inputs.shouldNotBeParsed, "");
+                    
+                    next(200, { success: true });
+                }
+            };
+
+            await Api.preprocessor(route, req, res);
+            assert.strictEqual(res.statusCode, 200);
+        });
+    });
 });