feat(requestInput): allow to receive array request body (#2648)

Author: alexandrebouthinon

lib/api/controllers/securityController.ts

@@ -21,6 +21,7 @@
 import Bluebird from "bluebird";
 import { isEmpty, isNil } from "lodash";
 import { v4 as uuidv4 } from "uuid";
+import { JSONObject } from "kuzzle-sdk";
 
 import { BadRequestError, KuzzleError } from "../../kerror/errors";
 import { KuzzleRequest, Request } from "../request";
@@ -662,8 +663,8 @@ export default class SecurityController extends NativeController {
 
     if (
       request.input.body &&
-      request.input.body.ids &&
-      Object.keys(request.input.body.ids).length
+      (request.input.body as JSONObject).ids &&
+      Object.keys((request.input.body as JSONObject).ids).length
     ) {
       ids = request.getBodyArray("ids");
     } else {

lib/api/request/requestInput.ts

@@ -290,12 +290,12 @@ export class RequestInput {
    *   body         <== that
    *  }
    */
-  get body(): JSONObject | null {
+  get body(): JSONObject | Array<any> | null {
     return this[_body];
   }
 
-  set body(obj: JSONObject) {
-    this[_body] = assert.assertObject("body", obj);
+  set body(obj: JSONObject | Array<any>) {
+    this[_body] = assert.assertArrayOrObject("body", obj);
   }
 
   /**

lib/core/realtime/hotelClerk.ts

@@ -321,7 +321,7 @@ export class HotelClerk {
    * filters will be fetched from the cluster.
    */
   async join(request: KuzzleRequest): Promise<{ channel; roomId }> {
-    const roomId = request.input.body.roomId;
+    const roomId = (request.input.body as JSONObject).roomId;
 
     if (!this.rooms.has(roomId)) {
       const normalized: NormalizedFilter = await global.kuzzle.ask(

lib/util/assertType.js

@@ -44,6 +44,29 @@ function assertObject(attr, data) {
   return data;
 }
 
+/**
+ * Throws if the provided data is not an object or an array.
+ * Returns the unmodified data if validated
+ *
+ * @throws
+ * @param {string} attr - tested attribute name
+ * @param {*} data
+ * @return {object|array}
+ */
+function assertArrayOrObject(attr, data) {
+  if (data === null || data === undefined) {
+    return null;
+  }
+
+  if (typeof data !== "object") {
+    throw new BadRequestError(
+      `Attribute ${attr} must be of type "object" or "array"`,
+    );
+  }
+
+  return data;
+}
+
 /**
  * Throws if the provided data is not an array containing exclusively
  * values of the specified "type"
@@ -120,6 +143,7 @@ function assertInteger(attr, data) {
 
 module.exports = {
   assertArray,
+  assertArrayOrObject,
   assertInteger,
   assertObject,
   assertString,

test/api/request/requestInput.test.js

@@ -78,7 +78,7 @@ describe("#RequestInput", () => {
 
   it("should throw if an invalid data parameter is provided", () => {
     // testing object-only parameters
-    ["volatile", "body"].forEach((k) => {
+    ["volatile"].forEach((k) => {
       should(function () {
         new RequestInput({ [k]: [] });
       }).throw(`Attribute ${k} must be of type "object"`);
@@ -93,6 +93,18 @@ describe("#RequestInput", () => {
       }).throw(`Attribute ${k} must be of type "object"`);
     });
 
+    ["body"].forEach((k) => {
+      should(function () {
+        new RequestInput({ [k]: 123 });
+      }).throw(`Attribute ${k} must be of type "object" or "array"`);
+      should(function () {
+        new RequestInput({ [k]: false });
+      }).throw(`Attribute ${k} must be of type "object" or "array"`);
+      should(function () {
+        new RequestInput({ [k]: "foobar" });
+      }).throw(`Attribute ${k} must be of type "object" or "array"`);
+    });
+
     // testing string-only parameters
     ["controller", "action", "jwt"].forEach((k) => {
       should(function () {
@@ -133,4 +145,14 @@ describe("#RequestInput", () => {
 
     should(input.action).eql("foo");
   });
+
+  it("should accept both array and object for body property", () => {
+    let input = new RequestInput({ body: { some: "content" } });
+
+    should(input.body).be.deepEqual({ some: "content" });
+
+    input = new RequestInput({ body: [1, 2, 3] });
+
+    should(input.body).be.deepEqual([1, 2, 3]);
+  });
 });