impulse-api 3.0.5 → 3.0.7

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.5",
+  "version": "3.0.7",
   "engines": {
     "node": ">=22"
   },
@@ -25,7 +25,6 @@
     "jsonwebtoken": "8.5.1",
     "lodash": "4.17.21",
     "morgan": "1.10.0",
-    "multer": "1.4.5-lts.2",
     "path-to-regexp": "0.1.12"
   },
   "devDependencies": {

package/src/server.js

@@ -1,6 +1,5 @@
 const fs = require('fs');
 const express = require('express');
-const multer = require('multer');
 const cors = require('cors');
 const morgan = require('morgan');
 const pathToRegexp = require('path-to-regexp');
@@ -277,6 +276,11 @@ class Server {
             }
         }
 
+        // 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);
@@ -475,9 +479,13 @@ class Server {
                     method = route.method.toLowerCase();
                     verb = (verbMap[method]) ? verbMap[method] : method;
 
-                    if (verb === 'post' || verb === 'patch' || verb === 'put') {
-                        this.http[verb](route.endpoint, multer().none(), 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,207 @@ 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);
+        });
+    });
 });