feat: merge request.files into request.data field, delete files and body fields

update deletes request.files and request.body fields

BREAKING CHANGE: request.files and request.body fields no longer exists, use request.data instead

Author: Harrison Ifeanyichukwu

server.js

@@ -6,9 +6,14 @@ const server = new Server();
 
 // process form upload from our examples index.html file
 server.post('/', function (req, res) {
-  const result = JSON.stringify(Object.assign({}, req.body, req.files));
+  const result = JSON.stringify(req.data, (key, value) => {
+    if (Buffer.isBuffer(value)) {
+      return undefined;
+    }
+    return value;
+  });
 
-  writeFileSync('./upload.pdf', req.files['file-cv'].data);
+  writeFileSync('./upload.pdf', req.data['file-cv'].data);
   return res.json(jsBeautify.js(result));
 });
 

src/@types/index.ts

@@ -163,12 +163,12 @@ export interface FileEntry {
   type: string;
 }
 
-export interface Files {
-  [fieldName: string]: FileEntry | Array<FileEntry>;
+export interface Query {
+  [propName: string]: string | string[];
 }
 
 export interface Data {
-  [propName: string]: string | string[];
+  [propName: string]: string | string[] | FileEntry | FileEntry[];
 }
 
 export type PathParameters<T extends string = string> = Record<
@@ -201,31 +201,43 @@ export interface RouteParameter {
 
 export type Routes = Record<Exclude<Method, '*'>, RouteInstance[]>;
 
-export interface RouteResponse<Data = {}, Errors = {}> {
+export interface RouteResponse<DataType = {}, ErrorsType = {}> {
   statusCode?: number;
   message?: string;
-  data?: Data;
-  errors?: Errors;
+  data?: DataType;
+  errors?: ErrorsType;
   headers?: IncomingHttpHeaders;
 }
 
-export interface APIExecutor<RequestBody, Data, Errors = {}> {
-  (arg: {
-    /**
-     * request body, should be a combination of parsed post body and url search params
-     */
-    body: RequestBody;
+export interface ApiExecutorProps<
+  RequestDataType,
+  PathParametersType = Record<string, string | boolean | number>
+> {
+  /**
+   * request data type, a combination of query parameters and request body
+   */
+  data: RequestDataType;
 
-    /**
-     * request http headers
-     */
-    headers: IncomingHttpHeaders;
+  /**
+   * request http headers
+   */
+  headers: IncomingHttpHeaders;
 
-    /**
-     * request path parameters, as contained in the routing path
-     */
-    pathParams: PathParameters;
-  }): Promise<RouteResponse<Data, Errors> | null>;
+  /**
+   * request path parameters, as contained in the routing path
+   */
+  pathParams: PathParametersType;
+}
+
+export interface APIExecutor<
+  RequestDataType = {},
+  PathParametersType = {},
+  ResponseDataType = {},
+  ResponseErrorsType = {}
+> {
+  (
+    arg: ApiExecutorProps<RequestDataType, PathParametersType>
+  ): Promise<RouteResponse<ResponseDataType, ResponseErrorsType> | null>;
 
   /**
    * assigned name of the handler

src/modules/BodyParser.ts

@@ -1,4 +1,4 @@
-import { Data, Files, MultipartHeaders, FileEntry } from '../@types/index';
+import { Data, MultipartHeaders, FileEntry, Query } from '../@types/index';
 import { generateRandomText } from '@teclone/utils';
 import { CRLF, BLANK_LINE } from './Constants';
 
@@ -18,31 +18,23 @@ export class BodyParser {
     }
   }
 
-  /**
-   * assigns a single field or multi value field value to the body
-   */
-  private assignBodyValue(body: Data, fieldName: string, value: string) {
-    const { name, isMultiValue } = this.resolveFieldName(fieldName);
-
-    let target: string | string[] = value;
-    if (isMultiValue) {
-      target = body[name] || [];
-      (target as string[]).push(value);
-    }
-    body[name] = target;
-  }
-
   /**
    * stores a file into the given files object
    */
-  private assignFileValue(files: Files, fieldName: string, value: FileEntry) {
+  private assignDataEntry(
+    data: Data,
+    fieldName: string,
+    value: FileEntry | string
+  ) {
     const { name, isMultiValue } = this.resolveFieldName(fieldName);
-    let target: FileEntry | FileEntry[] = value;
-    if (isMultiValue) {
-      target = files[name] || [];
-      (target as FileEntry[]).push(value);
+    if (!isMultiValue) {
+      data[name] = value;
+      return;
+    }
+    if (typeof data[name] === 'undefined') {
+      data[name] = [];
     }
-    files[name] = target;
+    (data[name] as Array<typeof value>).push(value);
   }
 
   /**
@@ -93,14 +85,13 @@ export class BodyParser {
    * parse multipart form data
    *@see https://www.w3.org/Protocols/rfc1341/7_2_Multipart.html
    */
-  private parseMultiPart(string: string, headerBoundary: string | null) {
-    const body = {},
-      files = {};
+  private parseMultiPart(string: string, headerBoundary: string | null): Data {
+    const result: Data = {};
 
     //if boundary is null, detect it using the last encapsulation boundary format
     if (!headerBoundary) {
       if (!/^-{2}(-*[a-z0-9]+)-{2}/gim.test(string)) {
-        return { body, files };
+        return {};
       }
       headerBoundary = RegExp.$1;
     }
@@ -134,18 +125,18 @@ export class BodyParser {
           content,
           headers.type.startsWith('text/') ? 'utf8' : 'binary'
         );
-        this.assignFileValue(files, headers.fieldName, {
+        this.assignDataEntry(result, headers.fieldName, {
           name: headers.fileName.replace(/\.\./g, ''),
           data,
           size: data.byteLength,
           type: headers.type,
         });
       } else if (!headers.isFile) {
-        this.assignBodyValue(body, headers.fieldName, content);
+        this.assignDataEntry(result, headers.fieldName, content);
       }
     });
 
-    return { body, files };
+    return result;
   }
 
   /**
@@ -163,26 +154,26 @@ export class BodyParser {
   /**
    * parse url encoded request body
    */
-  private parseUrlEncoded(string: string): Data {
-    const body: Data = {};
+  private parseUrlEncoded(string: string): Query {
+    const result: Query = {};
     if (string) {
       const pairs = string.split('&');
       pairs.forEach((pair) => {
         const [name, value] = pair.split('=');
-        this.assignBodyValue(
-          body,
+        this.assignDataEntry(
+          result,
           decodeURIComponent(name),
           decodeURIComponent(value || '')
         );
       });
     }
-    return body;
+    return result;
   }
 
   /**
    * parse the query parameters in the given url
    */
-  parseQueryString(url: string): Data {
+  parseQueryString(url: string): Query {
     if (url.indexOf('?') > -1) {
       return this.parseUrlEncoded(url.split('?')[1]);
     } else {
@@ -207,7 +198,7 @@ export class BodyParser {
    *@param {Buffer} buffer - the buffer data
    *@param {string} contentType - the request content type
    */
-  parse(buffer: Buffer, contentType: string): { files: Files; body: Data } {
+  parse(buffer: Buffer, contentType: string): Data {
     const content = buffer.toString('latin1');
     const tokens = contentType.split(/;\s*/);
 
@@ -219,14 +210,14 @@ export class BodyParser {
     switch (tokens[0].toLowerCase()) {
       case 'text/plain':
       case 'application/x-www-form-urlencoded':
-        return { files: {}, body: this.parseUrlEncoded(content) };
+        return this.parseUrlEncoded(content);
 
       case 'text/json':
       case 'application/json':
-        return { files: {}, body: this.parseJSON(content) };
+        return this.parseJSON(content);
 
       default:
-        return { body: {}, files: {} };
+        return {};
     }
   }
 }

src/modules/Request.ts

@@ -1,6 +1,6 @@
 import { IncomingMessage } from 'http';
 import { Http2ServerRequest } from 'http2';
-import { Data, Files, Method } from '../@types';
+import { Data, Method, Query } from '../@types';
 
 export type ServerRequest<
   T extends typeof IncomingMessage | typeof Http2ServerRequest =
@@ -15,11 +15,7 @@ export type ServerRequest<
 
   endedAt: Date | null;
 
-  files: Files;
-
-  query: Data;
-
-  body: Data;
+  query: Query;
 
   data: Data;
 
@@ -53,9 +49,7 @@ const createRequestClass = <
   RequestClass.prototype.init = function (encrypted) {
     this.buffer = Buffer.alloc(0);
 
-    this.files = {};
     this.query = {};
-    this.body = {};
 
     // data is a merge of query and body
     this.data = {};

src/modules/Server.ts

@@ -340,18 +340,13 @@ export class Server<
     //parse the request body
     if (request.buffer.length > 0) {
       const contentType = request.headers['content-type'] || 'text/plain';
+      const data = this.bodyParser.parse(request.buffer, contentType);
 
-      //TODO: add support for content encoding
-      const result = this.bodyParser.parse(request.buffer, contentType);
-
-      request.body = result.body;
-      request.files = result.files;
+      request.data = {
+        ...request.query,
+        ...data,
+      };
     }
-
-    request.data = {
-      ...request.query,
-      ...request.body,
-    };
   }
 
   /**

tests/modules/BodyParser.spec.ts

@@ -43,59 +43,56 @@ describe('BodyParser', function () {
 
   describe(`#parse(buffer: Buffer, contentType: string): {files: Files, body: Data}`, function () {
     it(`should inspect the given contentType, and parse the buffer data accordingly, passing
-            data as urlencoded into body if contentType is text/plain or application/x-www-form-urlencoded`, function () {
-      expect(bodyParser.parse(buffer, 'text/plain').body).toEqual(data);
+          as urlencoded if contentType is text/plain or application/x-www-form-urlencoded`, function () {
+      expect(bodyParser.parse(buffer, 'text/plain')).toEqual(data);
       expect(
-        bodyParser.parse(buffer, 'application/x-www-form-urlencoded').body
+        bodyParser.parse(buffer, 'application/x-www-form-urlencoded')
       ).toEqual(data);
     });
 
     it(`should inspect the given contentType, and parse the buffer data accordingly, passing
-            data as json encoded into body if contentType is text/json or application/json`, function () {
+            content as json encoded if contentType is text/json or application/json`, function () {
       const buffer = Buffer.from(JSON.stringify(data));
-      expect(bodyParser.parse(buffer, 'text/json').body).toEqual(data);
-      expect(bodyParser.parse(buffer, 'application/json').body).toEqual(data);
+      expect(bodyParser.parse(buffer, 'text/json')).toMatchObject(data);
+      expect(bodyParser.parse(buffer, 'application/json')).toMatchObject(data);
     });
 
     it(`should catch json decode error for erronous json strings and return empty object`, function () {
       const erronousJson = "{'age': 20}";
       const buffer = Buffer.from(erronousJson);
-      expect(bodyParser.parse(buffer, 'text/json').body).toEqual({});
+      expect(bodyParser.parse(buffer, 'text/json')).toEqual({});
     });
 
     it(`should inspect the given contentType, and parse the buffer data accordingly, passing
-            data as multipart form data into body and files object if contentType is
+            data as multipart form data if contentType is
             multipart/form-data`, function () {
       const buffer = fs.readFileSync(multipartLogFile);
       const contentType = `multipart/form-data; boundary=${multipartBoundary}`;
 
       const result = bodyParser.parse(buffer, contentType);
-      expect(result.body).toEqual(data);
+      expect(result).toMatchObject(data);
     });
 
     it(`should detect the multipart boundary if not given`, function () {
       const buffer = fs.readFileSync(multipartLogFile);
       const contentType = `multipart/form-data`;
 
       const result = bodyParser.parse(buffer, contentType);
-      expect(result.body).toEqual(data);
+      expect(result).toMatchObject(data);
     });
 
-    it(`should return empty body and files object if multipart boundary is not given and it
+    it(`should return empty object if multipart boundary is not given and it
         could not be detected`, function () {
       const buffer = fs.readFileSync(multipartLogFileNoBoundary);
       const contentType = `multipart/form-data`;
 
       const result = bodyParser.parse(buffer, contentType);
-      expect(result.body).toEqual({});
-      expect(result.files).toEqual({});
+      expect(result).toEqual({});
     });
 
-    it(`should do nothing if contentType is not recognised and return empty body and files
-        object`, function () {
+    it(`should do nothing if contentType is not recognised and return object`, function () {
       const buffer = Buffer.from(JSON.stringify(data));
-      expect(bodyParser.parse(buffer, '').body).toEqual({});
-      expect(bodyParser.parse(buffer, '').files).toEqual({});
+      expect(bodyParser.parse(buffer, '')).toEqual({});
     });
   });
 });