feat: Add configurable request body size limit option (#380)

* feat: Add configurable request body size limit option

Author: contactjittu

README.md

@@ -158,6 +158,14 @@ with the CLI.
 npx faas-js-runtime ./index.js
 ```
 
+### --bodyLimit
+Sets the maximum allowed payload size for incoming requests. Default is '1mb'.
+
+Example:
+```console
+faas-js-runtime function.js --bodyLimit 2mb
+```
+
 ## Debugging Locally
 
 During local development, it is often necessary to set breakpoints in your code for debugging.  Since functions are just javascript files, using any current debugging(VS Code, Chrome Dev Tools) method will work. The linked blog post shows how to setup and use VS Code for development debugging.

bin/cli.js

@@ -13,6 +13,7 @@ program
   .option('--log-level <log-level>', 'change the log level of the function', defaults.LOG_LEVEL)
   .option('--port <port>', 'change the port the runtime listens on', defaults.PORT)
   .option('--include-raw', 'include the raw body in the request context', defaults.INCLUDE_RAW)
+  .option('--bodyLimit <bodyLimit>)', 'maximum size of the request payload in bytes', defaults.BODY_LIMIT)
   .arguments('<file>')
   .action(runServer);
 
@@ -26,6 +27,7 @@ async function runServer(file) {
       logLevel: process.env.FUNC_LOG_LEVEL || programOpts['logLevel'] || defaults.LOG_LEVEL,
       port: process.env.FUNC_PORT || programOpts.port || defaults.PORT,
       includeRaw: process.env.FUNC_INCLUDE_RAW ? true : programOpts.includeRaw || defaults.INCLUDE_RAW,
+      bodyLimit: process.env.FUNC_BODY_LIMIT || programOpts.bodyLimit || defaults.BODY_LIMIT
     };
 
     const filePath = extractFullPath(file);

index.d.ts

@@ -21,6 +21,7 @@ export declare const defaults: {
   LOG_LEVEL: LogLevel,
   PORT: number,
   INCLUDE_RAW: boolean,
+  BODY_LIMIT: number,
 };
 
 // re-export

index.js

@@ -21,6 +21,9 @@ const PORT = 8080;
 // Don't Include Raw body by default
 const INCLUDE_RAW = false;
 
+// Default maximum request payload size (1MB in bytes)
+const BODY_LIMIT = 1048576;
+
 /**
  * Starts the provided Function. If the function is a module, it will be
  * inspected for init, shutdown, cors, liveness, and readiness functions and those
@@ -113,6 +116,7 @@ function initializeServer(config) {
         }),
       },
     },
+    bodyLimit: Number(config.bodyLimit),
   });
 
   if (config.includeRaw) {
@@ -191,13 +195,15 @@ function initializeServer(config) {
  * @param {String} options.config Path to a func.yaml file
  * @param {String} options.logLevel Log level - one of 'fatal', 'error', 'warn', 'info', 'debug', 'trace', 'silent'
  * @param {number} options.port Port to listen on
+ * @param {number} [options.bodyLimit=1048576] - Maximum request payload size in bytes
  * @returns {Config} Configuration object
  */
 function loadConfig(options) {
   const opts = { ...options, ...readFuncYaml(options.config) };
   opts.logLevel = opts.logLevel || LOG_LEVEL;
   opts.port = opts.port || PORT;
   opts.includeRaw = opts.includeRaw || INCLUDE_RAW;
+  opts.bodyLimit = opts.bodyLimit || BODY_LIMIT;
   return opts;
 }
 
@@ -235,5 +241,5 @@ function readFuncYaml(fileOrDirPath) {
 
 module.exports = exports = {
   start,
-  defaults: { LOG_LEVEL, PORT, INCLUDE_RAW },
+  defaults: { LOG_LEVEL, PORT, INCLUDE_RAW, BODY_LIMIT },
 };

test/test-http-body.js

@@ -135,3 +135,91 @@ test('Provides HTTP POST empty body as empty string parameter and rawBody', t =>
       });
   }, errHandler(t));
 });
+
+test('Rejects HTTP POST exceeding bodyLimit', t => {
+  const largeBody = 'x'.repeat(1048576 + 1);
+  t.plan(2);
+  start((_, receivedBody) => receivedBody, { bodyLimit: 1048576 })
+    .then(server => {
+      request(server)
+        .post('/')
+        .send(largeBody)
+        .set({ 'Content-Type': 'text/plain' })
+        .expect(413)
+        .end((err, res) => {
+          t.error(err, 'No error');
+          t.equal(res.status, 413, 'Should reject payload larger than limit');
+          t.end();
+          server.close();
+        });
+    }, errHandler(t));
+});
+
+test('Accepts HTTP POST within bodyLimit', t => {
+  const body = 'x'.repeat(1048576);
+  t.plan(2);
+  start((_, receivedBody) => {
+    t.equal(receivedBody, body);
+    return receivedBody;
+  }, { bodyLimit: 1048576 })
+    .then(server => {
+      request(server)
+        .post('/')
+        .send(body)
+        .set({ 'Content-Type': 'text/plain' })
+        .expect('Content-Type', /plain/)
+        .expect(200)
+        .end((err, _) => {
+          t.error(err, 'No error');
+          t.end();
+          server.close();
+        });
+    }, errHandler(t));
+});
+
+test('Rejects payload exceeding environment variable bodyLimit', t => {
+  const bodyLimit = 1048576;
+  const largeBody = 'x'.repeat(bodyLimit + 1);
+  process.env.FUNC_BODY_LIMIT = bodyLimit;
+  t.plan(2);
+  start((_, receivedBody) => receivedBody)
+    .then(server => {
+      request(server)
+        .post('/')
+        .send(largeBody)
+        .set({ 'Content-Type': 'text/plain' })
+        .expect(413)
+        .end((err, res) => {
+          t.error(err, 'No error');
+          t.equal(res.status, 413, 'Should reject payload larger than env var limit');
+          delete process.env.FUNC_BODY_LIMIT;
+          t.end();
+          server.close();
+        });
+    }, errHandler(t));
+});
+
+test('Accepts payload within environment variable bodyLimit', t => {
+  const bodyLimit = 524288;
+  const body = 'x'.repeat(bodyLimit);
+  process.env.FUNC_BODY_LIMIT = bodyLimit;
+  t.plan(2);
+  start((_, receivedBody) => {
+    t.equal(receivedBody, body);
+    return receivedBody;
+  })
+    .then(server => {
+      request(server)
+        .post('/')
+        .send(body)
+        .set({ 'Content-Type': 'text/plain' })
+        .expect('Content-Type', /plain/)
+        .expect(200)
+        .end((err, _) => {
+          t.error(err, 'No error');
+          delete process.env.FUNC_BODY_LIMIT;
+          t.end();
+          server.close();
+        });
+    }, errHandler(t));
+});