te.js 2.1.6 → 2.2.1

package/server/ammo/body-parser.js

@@ -28,190 +28,194 @@ async function parseDataBasedOnContentType(req) {
 }
 
 function parseJSONRequestBody(req) {
-  return new Promise((resolve, reject) => {
-    let body = '';
-    let size = 0;
-    const maxSize = env('BODY_MAX_SIZE');
-    const timeout = setTimeout(() => {
-      reject(new BodyParserError('Request timeout', 408));
-    }, env('BODY_TIMEOUT'));
-
-    req.on('data', (chunk) => {
-      size += chunk.length;
-      if (size > maxSize) {
-        clearTimeout(timeout);
-        reject(new BodyParserError('Request entity too large', 413));
-        req.destroy();
-        return;
-      }
-      body += chunk.toString();
-    });
-
-    req.on('error', (err) => {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  let body = '';
+  let size = 0;
+  const maxSize = env('BODY_MAX_SIZE');
+  const timeout = setTimeout(() => {
+    reject(new BodyParserError('Request timeout', 408));
+  }, env('BODY_TIMEOUT'));
+
+  req.on('data', (chunk) => {
+    size += chunk.length;
+    if (size > maxSize) {
       clearTimeout(timeout);
-      reject(new BodyParserError(`Request error: ${err.message}`, 400));
-    });
+      reject(new BodyParserError('Request entity too large', 413));
+      req.destroy();
+      return;
+    }
+    body += chunk.toString();
+  });
 
-    req.on('end', () => {
-      clearTimeout(timeout);
-      try {
-        if (!body) {
-          resolve({});
-          return;
-        }
-        const jsonData = JSON.parse(body);
-        if (typeof jsonData !== 'object') {
-          throw new TejError(400, 'Invalid JSON structure');
-        }
-        resolve(jsonData);
-      } catch (err) {
-        reject(new TejError(400, `Invalid JSON: ${err.message}`));
-      }
-    });
+  req.on('error', (err) => {
+    clearTimeout(timeout);
+    reject(new BodyParserError(`Request error: ${err.message}`, 400));
   });
-}
 
-function parseUrlEncodedData(req) {
-  return new Promise((resolve, reject) => {
-    let body = '';
-    let size = 0;
-    const maxSize = env('BODY_MAX_SIZE');
-    const timeout = setTimeout(() => {
-      reject(new BodyParserError('Request timeout', 408));
-    }, env('BODY_TIMEOUT'));
-
-    req.on('data', (chunk) => {
-      size += chunk.length;
-      if (size > maxSize) {
-        clearTimeout(timeout);
-        reject(new BodyParserError('Request entity too large', 413));
-        req.destroy();
+  req.on('end', () => {
+    clearTimeout(timeout);
+    try {
+      if (!body) {
+        resolve({});
         return;
       }
-      body += chunk.toString();
-    });
+      const jsonData = JSON.parse(body);
+      if (typeof jsonData !== 'object') {
+        throw new TejError(400, 'Invalid JSON structure');
+      }
+      resolve(jsonData);
+    } catch (err) {
+      reject(new TejError(400, `Invalid JSON: ${err.message}`));
+    }
+  });
 
-    req.on('error', (err) => {
-      clearTimeout(timeout);
-      reject(new BodyParserError(`Request error: ${err.message}`, 400));
-    });
+  return promise;
+}
 
-    req.on('end', () => {
+function parseUrlEncodedData(req) {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  let body = '';
+  let size = 0;
+  const maxSize = env('BODY_MAX_SIZE');
+  const timeout = setTimeout(() => {
+    reject(new BodyParserError('Request timeout', 408));
+  }, env('BODY_TIMEOUT'));
+
+  req.on('data', (chunk) => {
+    size += chunk.length;
+    if (size > maxSize) {
       clearTimeout(timeout);
-      try {
-        if (!body) {
-          resolve({});
-          return;
-        }
-        const data = new URLSearchParams(body);
-        const parsedData = Object.fromEntries(data);
-        resolve(parsedData);
-      } catch (err) {
-        reject(new BodyParserError('Invalid URL encoded data', 400));
-      }
-    });
+      reject(new BodyParserError('Request entity too large', 413));
+      req.destroy();
+      return;
+    }
+    body += chunk.toString();
   });
-}
 
-function parseFormData(req) {
-  return new Promise((resolve, reject) => {
-    let body = '';
-    let size = 0;
-    const maxSize = env('BODY_MAX_SIZE');
-    const timeout = setTimeout(() => {
-      reject(new BodyParserError('Request timeout', 408));
-    }, env('BODY_TIMEOUT'));
-
-    req.on('data', (chunk) => {
-      size += chunk.length;
-      if (size > maxSize) {
-        clearTimeout(timeout);
-        reject(new BodyParserError('Request entity too large', 413));
-        req.destroy();
+  req.on('error', (err) => {
+    clearTimeout(timeout);
+    reject(new BodyParserError(`Request error: ${err.message}`, 400));
+  });
+
+  req.on('end', () => {
+    clearTimeout(timeout);
+    try {
+      if (!body) {
+        resolve({});
         return;
       }
-      body += chunk.toString();
-    });
+      const data = new URLSearchParams(body);
+      const parsedData = Object.fromEntries(data);
+      resolve(parsedData);
+    } catch (err) {
+      reject(new BodyParserError('Invalid URL encoded data', 400));
+    }
+  });
 
-    req.on('error', (err) => {
-      clearTimeout(timeout);
-      reject(new BodyParserError(`Request error: ${err.message}`, 400));
-    });
+  return promise;
+}
 
-    req.on('end', () => {
+function parseFormData(req) {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  let body = '';
+  let size = 0;
+  const maxSize = env('BODY_MAX_SIZE');
+  const timeout = setTimeout(() => {
+    reject(new BodyParserError('Request timeout', 408));
+  }, env('BODY_TIMEOUT'));
+
+  req.on('data', (chunk) => {
+    size += chunk.length;
+    if (size > maxSize) {
       clearTimeout(timeout);
-      try {
-        if (!body.trim()) {
-          resolve([]);
-          return;
-        }
+      reject(new BodyParserError('Request entity too large', 413));
+      req.destroy();
+      return;
+    }
+    body += chunk.toString();
+  });
 
-        const contentType = req.headers['content-type'];
-        const boundaryMatch = contentType.match(
-          /boundary=(?:"([^"]+)"|([^;]+))/i,
-        );
+  req.on('error', (err) => {
+    clearTimeout(timeout);
+    reject(new BodyParserError(`Request error: ${err.message}`, 400));
+  });
 
-        if (!boundaryMatch) {
-          throw new TejError(400, 'Missing boundary in content-type');
-        }
+  req.on('end', () => {
+    clearTimeout(timeout);
+    try {
+      if (!body.trim()) {
+        resolve([]);
+        return;
+      }
 
-        const boundary = '--' + (boundaryMatch[1] || boundaryMatch[2]);
-        const parts = body
-          .split(boundary)
-          .filter((part) => part.trim() !== '' && part.trim() !== '--');
+      const contentType = req.headers['content-type'];
+      const boundaryMatch = contentType.match(
+        /boundary=(?:"([^"]+)"|([^;]+))/i,
+      );
 
-        const parsedData = parts.map((part) => {
-          const [headerString, ...contentParts] = part.split('\r\n\r\n');
-          if (!headerString || contentParts.length === 0) {
-            throw new TejError(400, 'Malformed multipart part');
-          }
+      if (!boundaryMatch) {
+        throw new TejError(400, 'Missing boundary in content-type');
+      }
 
-          const headers = {};
-          const headerLines = headerString.trim().split('\r\n');
+      const boundary = '--' + (boundaryMatch[1] || boundaryMatch[2]);
+      const parts = body
+        .split(boundary)
+        .filter((part) => part.trim() !== '' && part.trim() !== '--');
 
-          headerLines.forEach((line) => {
-            const [key, ...valueParts] = line.split(': ');
-            if (!key || valueParts.length === 0) {
-              throw new TejError(400, 'Malformed header');
-            }
-            headers[key.toLowerCase()] = valueParts.join(': ');
-          });
+      const parsedData = parts.map((part) => {
+        const [headerString, ...contentParts] = part.split('\r\n\r\n');
+        if (!headerString || contentParts.length === 0) {
+          throw new TejError(400, 'Malformed multipart part');
+        }
 
-          const value = contentParts.join('\r\n\r\n').replace(/\r\n$/, '');
+        const headers = Object.create(null);
+        const headerLines = headerString.trim().split('\r\n');
 
-          // Parse content-disposition
-          const disposition = headers['content-disposition'];
-          if (!disposition) {
-            throw new TejError(400, 'Missing content-disposition header');
+        headerLines.forEach((line) => {
+          const [key, ...valueParts] = line.split(': ');
+          if (!key || valueParts.length === 0) {
+            throw new TejError(400, 'Malformed header');
           }
+          headers[key.toLowerCase()] = valueParts.join(': ');
+        });
 
-          const nameMatch = disposition.match(/name="([^"]+)"/);
-          const filename = disposition.match(/filename="([^"]+)"/);
+        const value = contentParts.join('\r\n\r\n').replace(/\r\n$/, '');
 
-          return {
-            name: nameMatch ? nameMatch[1] : undefined,
-            filename: filename ? filename[1] : undefined,
-            headers,
-            value,
-          };
-        });
+        const disposition = headers['content-disposition'];
+        if (!disposition) {
+          throw new TejError(400, 'Missing content-disposition header');
+        }
 
-        resolve(parsedData);
-      } catch (err) {
-        reject(
-          new BodyParserError(
-            `Invalid multipart form data: ${err.message}`,
-            400,
-          ),
-        );
-      }
-    });
+        const nameMatch = disposition.match(/name="([^"]+)"/);
+        const filename = disposition.match(/filename="([^"]+)"/);
+
+        return {
+          name: nameMatch ? nameMatch[1] : undefined,
+          filename: filename ? filename[1] : undefined,
+          headers,
+          value,
+        };
+      });
+
+      resolve(parsedData);
+    } catch (err) {
+      reject(
+        new BodyParserError(`Invalid multipart form data: ${err.message}`, 400),
+      );
+    }
   });
+
+  return promise;
 }
 
 class BodyParserError extends TejError {
-  constructor(message, statusCode = 400) {
-    super(statusCode, message);
+  /**
+   * @param {string} message     - Human-readable description
+   * @param {number} [statusCode=400] - HTTP status code
+   * @param {{ cause?: Error }} [options] - Optional cause for chaining
+   */
+  constructor(message, statusCode = 400, options) {
+    super(statusCode, message, options);
     this.name = 'BodyParserError';
   }
 }

package/server/ammo/body-parser.test.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Tests for body-parser (JSON, URL-encoded, multipart).
+ */
+import { describe, it, expect } from 'vitest';
+import parseDataBasedOnContentType, { BodyParserError } from './body-parser.js';
+import { MockRequest } from '../../tests/helpers/mock-http.js';
+
+function makeReq(contentType, body) {
+  const req = new MockRequest({
+    method: 'POST',
+    headers: contentType ? { 'content-type': contentType } : {},
+  });
+  // Schedule body emission after current tick
+  setImmediate(() => req.simulateBody(body || ''));
+  return req;
+}
+
+describe('parseDataBasedOnContentType', () => {
+  it('should return empty object when no content-type', async () => {
+    const req = new MockRequest({ method: 'POST', headers: {} });
+    const result = await parseDataBasedOnContentType(req);
+    expect(result).toEqual({});
+  });
+
+  it('should parse JSON body', async () => {
+    const req = makeReq('application/json', JSON.stringify({ name: 'Tejas' }));
+    const result = await parseDataBasedOnContentType(req);
+    expect(result).toEqual({ name: 'Tejas' });
+  });
+
+  it('should return empty object for empty JSON body', async () => {
+    const req = makeReq('application/json', '');
+    const result = await parseDataBasedOnContentType(req);
+    expect(result).toEqual({});
+  });
+
+  it('should reject on invalid JSON', async () => {
+    const req = makeReq('application/json', '{not valid json}');
+    await expect(parseDataBasedOnContentType(req)).rejects.toBeInstanceOf(
+      Error,
+    );
+  });
+
+  it('should parse URL-encoded body', async () => {
+    const req = makeReq(
+      'application/x-www-form-urlencoded',
+      'name=Alice&age=30',
+    );
+    const result = await parseDataBasedOnContentType(req);
+    expect(result.name).toBe('Alice');
+    expect(result.age).toBe('30');
+  });
+
+  it('should throw BodyParserError for unsupported content type', async () => {
+    const req = new MockRequest({
+      method: 'POST',
+      headers: { 'content-type': 'text/xml' },
+    });
+    setImmediate(() => req.simulateBody('<xml/>'));
+    await expect(parseDataBasedOnContentType(req)).rejects.toBeInstanceOf(
+      BodyParserError,
+    );
+  });
+});
+
+describe('BodyParserError', () => {
+  it('should extend TejError', async () => {
+    const TejError = (await import('../error.js')).default;
+    const err = new BodyParserError('Bad body', 400);
+    expect(err).toBeInstanceOf(TejError);
+    expect(err.statusCode).toBe(400);
+    expect(err.name).toBe('BodyParserError');
+  });
+
+  it('should default statusCode to 400', () => {
+    const err = new BodyParserError('Bad body');
+    expect(err.statusCode).toBe(400);
+  });
+});

package/server/ammo/enhancer.js

@@ -13,19 +13,23 @@ function hostname(req) {
 }
 
 async function generatePayload(req) {
-  const obj = {};
+  const obj = Object.create(null);
 
-  const searchParams = new URLSearchParams(req.url.split('?')[1]);
+  const searchParams = new URLSearchParams((req.url ?? '').split('?')[1] ?? '');
   for (const [key, value] of searchParams) {
     obj[key] = value;
   }
 
   // Only parse body for methods that typically have a body
-  if (req.method !== 'GET' && req.method !== 'HEAD' && req.method !== 'DELETE') {
+  if (
+    req.method !== 'GET' &&
+    req.method !== 'HEAD' &&
+    req.method !== 'DELETE'
+  ) {
     const body = await bodyParser(req);
     if (body) Object.assign(obj, body);
   }
-  
+
   return obj;
 }