impulse-api 3.0.7 → 3.0.9

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.7",
+  "version": "3.0.9",
   "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
         }));
@@ -266,10 +265,12 @@ 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;
@@ -483,10 +484,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/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/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/server-test.js

@@ -701,5 +701,79 @@ describe('server-test', () => {
             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);
+        });
     });
 });

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;

package/test/unit/server-test.js

@@ -0,0 +1,779 @@
+const Server = require('../../src/server');
+const Auth = require('../../src/auth');
+const assert = require('assert');
+const sinon = require('sinon');
+
+const testApi = new Server({
+    name: 'test-server',
+    routeDir: './test-routes',
+    port: 4000,
+    env: 'test',
+    services: {}
+});
+
+assert.contains = (orig, key, message) => {
+    assert.strictEqual(orig.indexOf(key) >= 0, true, message);
+};
+
+describe('server-test', () => {
+    describe('instantiation', () => {
+        it('should throw an error if a configuration object is missing', () => {
+            try {
+                new Server();
+            } catch (e) {
+                assert.contains(e.message, 'valid config');
+            }
+        });
+        it('should throw an error if service name is missing', () => {
+            try {
+                new Server({
+                    routeDir: './'
+                });
+            } catch (e) {
+                assert.contains(e.message, 'name');
+            }
+        });
+        it('should throw an error if route directory is missing', () => {
+            try {
+                new Server({
+                    name: 'test-Server'
+                });
+            } catch (e) {
+                assert.contains(e.message, 'route');
+            }
+        });
+        it('should property set the port', () => {
+            const Api = new Server({
+                name: 'test-server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+            assert.strictEqual(Api.port, 4000);
+        });
+        it('should properly set the environment', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+            });
+
+            assert.strictEqual(Api.env, 'test');
+        });
+        it('should set the app key to whatever is passed in', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './routes/sample-routes',
+                port: 4000,
+                env: 'test',
+                appKey: 'TestKey'
+            });
+
+            assert.strictEqual(Api.appKey, 'TestKey');
+        });
+    });
+
+    describe('route parameters', () => {
+        it('should not crash if there are no inputs provided', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+            });
+            Api.buildParameters({}, null);
+        });
+        it('should not crash if there are no params provided', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+            });
+            Api.buildParameters(null, {});
+        });
+        it('should pass a param with a true/false value', () => {
+             const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+            });
+            const output = Api.buildParameters({ grade: 0 }, {
+                grade: {
+                    required: true
+                }
+            });
+
+            assert.strictEqual(output.grade, 0);
+        });
+        it('should throw an error if there is a required input that is not in the params', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+            });
+            try {
+                Api.buildParameters({
+                        'test-param': {
+                            required: true
+                        },
+                    },
+                    {}
+                );
+            } catch (e) {
+                console.log(e)
+                assert.contains(e.message, 'Missing parameter [test-param]');
+            }
+        });
+        it('should apply a formatter if the input provides one', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test'
+            });
+
+            let output;
+
+            try {
+                output = Api.buildParameters({
+                    param1: '1',
+                    param2: '2'
+                }, {
+                    param1: {
+                        required: true,
+                        formatter: (param) => {
+                            assert.strictEqual(param, '1');
+                            return parseInt(param, 10) + 1;
+                        }
+                    },
+                    param2: {
+                        required: true
+                    }
+                });
+
+                assert.strictEqual(output.param1, 2);
+                assert.strictEqual(output.param2, '2');
+            } catch (e) {
+                assert.ifError(e);
+            }
+        });
+        it('should run parameters through the validator after being formatted', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+            });
+            let output;
+            try {
+                output = Api.buildParameters({
+                    param1: '1',
+                    param2: '2'
+                }, {
+                    param1: {
+                        required: true,
+                        formatter: (param) => {
+                            assert.strictEqual(param, '1');
+                            return parseInt(param, 10) + 1;
+                        },
+                        validator: () => {
+                            assert.strictEqual(output.param1, 2);
+                        }
+                    },
+                    param2: {
+                        required: true
+                    }
+                });
+
+                assert.strictEqual(output.param1, 2);
+                assert.strictEqual(output.param2, '2');
+            } catch (e) {
+                assert.ifError(e);
+            }
+        });
+        it('should return only the data that is defined in the inputs', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+            });
+            let output;
+            try {
+                output = Api.buildParameters({
+                    param1: '1',
+                    param2: '2',
+                    param3: '3'
+                }, {
+                    param1: {
+                        required: true
+                    },
+                    param2: {
+                        required: true
+                    }
+                });
+
+                assert.strictEqual(output.param1, '1');
+                assert.strictEqual(output.param2, '2');
+                assert.strictEqual(output.param3, undefined);
+            } catch (e) {
+                assert.ifError(e);
+            }
+        });
+    });
+
+    describe('#loadRoutes', () => {
+        it('it should return an error if the route does not have a "run" method', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: require('path').join(__dirname, '../routes'),
+                port: 4000,
+                env: 'test'
+            });
+            const routeFiles = [
+                'missing-run.js'
+            ];
+            Api.loadRoutes(routeFiles).catch((error) => {
+                assert.contains(error.message, 'missing a "run" property');
+
+            });
+        });
+        it('it should return an error if the route does not have a name', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: require('path').join(__dirname, '../routes'),
+                port: 4000,
+                env: 'test'
+            });
+            const routeFiles = [
+                'missing-name.js'
+            ];
+            Api.loadRoutes(routeFiles).catch((error) => {
+                assert.contains(error.message, 'missing a "name" property');
+            });
+        });
+        it('should return an error if the route does not have an endpoint', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: require('path').join(__dirname, '../routes'),
+                port: 4000,
+                env: 'test'
+            });
+            const routeFiles = [
+                'missing-endpoint.js'
+            ];
+            Api.loadRoutes(routeFiles).catch((error) => {
+                assert.contains(error.message, 'missing an endpoint');
+            });
+        });
+
+        it('should return an error if the input is missing', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: require('path').join(__dirname, '../routes'),
+                port: 4000,
+                env: 'test'
+            });
+            const routeFiles = [
+                'missing-params.js'
+            ];
+            Api.loadRoutes(routeFiles).catch((error) => {
+                assert.contains(error.message, 'Missing required input');
+            });
+        });
+
+        it('should return an error if the route does not have a method', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: require('path').join(__dirname, '../routes'),
+                port: 4000,
+                env: 'test'
+            });
+            const routeFiles = [
+                'missing-method.js'
+            ];
+            Api.loadRoutes(routeFiles).catch((error) => {
+                assert.contains(error.message, 'missing http method');
+            });
+        });
+    });
+    describe('#loadRouteFiles', () => {
+        it('should return an error if given a broken directory', () => {
+            const Api = new Server({
+                name: 'test-Server',
+                routeDir: 'missing',
+                port: 4000,
+                env: 'test'
+            });
+
+            Api.loadRouteFiles().catch((error) => {
+                assert.contains(error.message, 'file or directory');
+            });
+        });
+    });
+
+    describe('#checkConflictingRoutes', () => {
+        it('should not call callback if routes array is empty', () => {
+            const spy = sinon.spy();
+            testApi.checkConflictingRoutes([], spy);
+            sinon.assert.notCalled(spy);
+        });
+
+        it('should find conflicting endpoints', () => {
+            const spy = sinon.spy();
+            const routes = [
+                { method: 'get', endpoint: '/api/user/info' },
+                { method: 'get', endpoint: '/api/user/:id' }
+            ];
+            testApi.checkConflictingRoutes(routes, spy);
+            sinon.assert.calledOnce(spy);
+            sinon.assert.calledWith(spy, routes[1], routes[0]);
+        });
+
+        it('should find conflicting endpoints with multiple dynamic parameters', () => {
+            const spy = sinon.spy();
+            const routes = [
+                { method: 'get', endpoint: '/api/user/info/:test' },
+                { method: 'get', endpoint: '/api/user/:id/:test' }
+            ];
+            testApi.checkConflictingRoutes(routes, spy);
+            sinon.assert.calledOnce(spy);
+            sinon.assert.calledWith(spy, routes[1], routes[0]);
+        });
+
+        it('should not find conflicting endpoints when HTTP verbs are different', () => {
+            const spy = sinon.spy();
+            const routes = [
+                { method: 'post', endpoint: '/api/user/info' },
+                { method: 'get', endpoint: '/api/user/:id' }
+            ];
+            testApi.checkConflictingRoutes(routes, spy);
+            sinon.assert.notCalled(spy);
+        });
+    });
+
+    describe('Auth module', () => {
+        describe('instantiation', () => {
+            it('should throw an error if secretKey is not provided', () => {
+                try {
+                    new Auth();
+                    assert.fail('Should have thrown an error');
+                } catch (e) {
+                    assert.contains(e.message, 'must be initialized with secretKey');
+                }
+            });
+
+            it('should throw an error if secretKey is null', () => {
+                try {
+                    new Auth(null);
+                    assert.fail('Should have thrown an error');
+                } catch (e) {
+                    assert.contains(e.message, 'must be initialized with secretKey');
+                }
+            });
+
+            it('should throw an error if secretKey is undefined', () => {
+                try {
+                    new Auth(undefined);
+                    assert.fail('Should have thrown an error');
+                } catch (e) {
+                    assert.contains(e.message, 'must be initialized with secretKey');
+                }
+            });
+
+            it('should create an instance when secretKey is provided', () => {
+                const auth = new Auth('test-secret-key');
+                assert.strictEqual(auth.secretKey, 'test-secret-key');
+            });
+        });
+
+        describe('generateToken', () => {
+            it('should generate a token without requiring secretKey parameter', () => {
+                const auth = new Auth('test-secret-key');
+                const params = { userId: 'test-user', role: 'admin' };
+                const token = auth.generateToken(params);
+                assert.strictEqual(typeof token, 'string');
+                assert.strictEqual(token.length > 0, true);
+            });
+
+            it('should generate different tokens for different params', () => {
+                const auth = new Auth('test-secret-key');
+                const token1 = auth.generateToken({ userId: 'user1' });
+                const token2 = auth.generateToken({ userId: 'user2' });
+                assert.notStrictEqual(token1, token2);
+            });
+        });
+
+        describe('verifyToken', () => {
+            it('should verify a token without requiring secretKey parameter', () => {
+                const auth = new Auth('test-secret-key');
+                const params = { userId: 'test-user', role: 'admin' };
+                const token = auth.generateToken(params);
+                const decoded = auth.verifyToken(token);
+                assert.strictEqual(decoded.userId, 'test-user');
+                assert.strictEqual(decoded.role, 'admin');
+            });
+
+            it('should throw an error when verifying a token with wrong secretKey', () => {
+                const auth1 = new Auth('secret-key-1');
+                const auth2 = new Auth('secret-key-2');
+                const token = auth1.generateToken({ userId: 'test-user' });
+                try {
+                    auth2.verifyToken(token);
+                    assert.fail('Should have thrown an error');
+                } catch (e) {
+                    assert.contains(e.message, 'invalid signature');
+                }
+            });
+
+            it('should throw an error when verifying an invalid token', () => {
+                const auth = new Auth('test-secret-key');
+                try {
+                    auth.verifyToken('invalid-token-string');
+                    assert.fail('Should have thrown an error');
+                } catch (e) {
+                    assert.strictEqual(typeof e.message, 'string');
+                }
+            });
+        });
+
+        describe('createCustomValidator', () => {
+            it('should throw an error if validator is not a function', () => {
+                const auth = new Auth('test-secret-key');
+                try {
+                    auth.createCustomValidator('not-a-function');
+                    assert.fail('Should have thrown an error');
+                } catch (e) {
+                    assert.contains(e.message, 'Custom validator must be a function');
+                }
+            });
+
+            it('should return the validator function if valid', () => {
+                const auth = new Auth('test-secret-key');
+                const validatorFn = () => true;
+                const result = auth.createCustomValidator(validatorFn);
+                assert.strictEqual(result, validatorFn);
+            });
+        });
+    });
+
+    describe('Server Auth integration', () => {
+        it('should create auth instance when secretKey is provided', () => {
+            const server = new Server({
+                name: 'test-server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                secretKey: 'test-secret-key',
+                services: {}
+            });
+            assert.strictEqual(server.auth !== null, true);
+            assert.strictEqual(server.auth.secretKey, 'test-secret-key');
+        });
+
+        it('should not create auth instance when secretKey is not provided', () => {
+            const server = new Server({
+                name: 'test-server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                services: {}
+            });
+            assert.strictEqual(server.auth, null);
+        });
+
+        it('should not create auth instance when secretKey is null', () => {
+            const server = new Server({
+                name: 'test-server',
+                routeDir: './test-routes',
+                port: 4000,
+                env: 'test',
+                secretKey: null,
+                services: {}
+            });
+            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);
+        });
+    });
+});