milliparsec 5.0.2 → 5.1.1

package/README.md

@@ -20,7 +20,7 @@ Check out [deno-libs/parsec](https://github.com/deno-libs/parsec) for Deno port.
 - 📦 tiny package size (8KB dist size)
 - 🔥 no dependencies
 - ✨ [tinyhttp](https://github.com/tinyhttp/tinyhttp) and Express support
-- ⚡ 40% faster than body-parser and 20x faster than formidable
+- ⚡ ~15% faster than body-parser, ~4x faster than formidable
 
 ## Install
 

package/dist/index.d.ts

@@ -1,52 +1,36 @@
 import { Buffer } from 'node:buffer';
-import type { IncomingMessage, ServerResponse as Response } from 'node:http';
-type NextFunction = (err?: any) => void;
-/**
- * Request extension with a body
- */
-export type ReqWithBody<T = any> = IncomingMessage & {
-    body?: T;
-};
-export declare const hasBody: (method: string) => boolean;
-export type LimitErrorFn = (limit: number) => Error;
-export type ParserOptions = Partial<{
-    /**
-     * Limit payload size (in bytes)
-     * @default '100KB'
-     */
-    payloadLimit: number;
-    /**
-     * Custom error function for payload limit
-     */
-    payloadLimitErrorFn: LimitErrorFn;
-}>;
-export declare const p: <T = any>(fn: (body: Buffer) => void, payloadLimit?: number, payloadLimitErrorFn?: LimitErrorFn) => (req: ReqWithBody<T>, _res: Response, next?: (err?: any) => void) => Promise<void>;
+import type { ServerResponse as Response } from 'node:http';
+import type { LimitErrorFn, NextFunction, ParserOptions, ReqWithBody } from './types.ts';
+export * from './types.ts';
+export declare const p: <T = any>(fn: (body: Buffer, req: ReqWithBody<T>) => void, payloadLimit?: number, payloadLimitErrorFn?: LimitErrorFn) => (req: ReqWithBody<T>, _res: Response, next?: (err?: any) => void) => Promise<T | undefined>;
 /**
  * Parse payload with a custom function
  * @param fn
  */
-declare const custom: <T = any>(fn: (body: Buffer) => any) => (req: ReqWithBody, _res: Response, next?: NextFunction) => Promise<void>;
+declare const custom: <T = any>(fn: (body: Buffer) => any, type?: ParserOptions["type"]) => (req: ReqWithBody, _res: Response, next?: NextFunction) => Promise<void>;
 /**
  * Parse JSON payload
  * @param options
  */
-declare const json: ({ payloadLimit, payloadLimitErrorFn }?: ParserOptions) => (req: ReqWithBody, res: Response, next?: NextFunction) => Promise<void>;
+declare const json: ({ payloadLimit, payloadLimitErrorFn, type, reviver }?: ParserOptions<{
+    reviver?: (this: any, key: string, value: any) => any;
+}>) => (req: ReqWithBody, res: Response, next?: NextFunction) => Promise<void>;
 /**
  * Parse raw payload
  * @param options
  */
-declare const raw: ({ payloadLimit, payloadLimitErrorFn }?: ParserOptions) => (req: ReqWithBody, _res: Response, next?: NextFunction) => Promise<void>;
+declare const raw: ({ payloadLimit, payloadLimitErrorFn, type }?: ParserOptions) => (req: ReqWithBody, _res: Response, next?: NextFunction) => Promise<void>;
 /**
  * Stringify request payload
  * @param param0
  * @returns
  */
-declare const text: ({ payloadLimit, payloadLimitErrorFn }?: ParserOptions) => (req: ReqWithBody, _res: Response, next?: NextFunction) => Promise<void>;
+declare const text: ({ payloadLimit, payloadLimitErrorFn, type }?: ParserOptions) => (req: ReqWithBody, _res: Response, next?: NextFunction) => Promise<void>;
 /**
  * Parse urlencoded payload
  * @param options
  */
-declare const urlencoded: ({ payloadLimit, payloadLimitErrorFn }?: ParserOptions) => (req: ReqWithBody, _res: Response, next?: NextFunction) => Promise<void>;
+declare const urlencoded: ({ payloadLimit, payloadLimitErrorFn, type }?: ParserOptions) => (req: ReqWithBody, _res: Response, next?: NextFunction) => Promise<void>;
 type MultipartOptions = Partial<{
     /**
      * Limit number of files
@@ -67,5 +51,5 @@ type MultipartOptions = Partial<{
  * Does not restrict total payload size by default.
  * @param options
  */
-declare const multipart: ({ payloadLimit, payloadLimitErrorFn, ...opts }?: MultipartOptions & ParserOptions) => (req: ReqWithBody, res: Response, next?: NextFunction) => Promise<void>;
+declare const multipart: ({ payloadLimit, payloadLimitErrorFn, type, ...opts }?: MultipartOptions & ParserOptions) => (req: ReqWithBody, res: Response, next?: NextFunction) => Promise<void>;
 export { custom, json, raw, text, urlencoded, multipart };

package/dist/index.js

@@ -1,90 +1,116 @@
 import { Buffer, File } from 'node:buffer';
-export const hasBody = (method) => ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method);
-const defaultPayloadLimit = 102400; // 100KB
+import { checkType, hasBody } from "./utils.js";
+export * from "./types.js";
+const defaultPayloadLimit = 102400; // 100KiB
 const defaultErrorFn = (payloadLimit) => new Error(`Payload too large. Limit: ${payloadLimit} bytes`);
 // Main function
-export const p = (fn, payloadLimit = defaultPayloadLimit, payloadLimitErrorFn = defaultErrorFn) => async (req, _res, next) => {
-    try {
-        const body = [];
-        for await (const chunk of req) {
-            const totalSize = body.reduce((total, buffer) => total + buffer.byteLength, 0);
-            if (totalSize > payloadLimit)
-                throw payloadLimitErrorFn(payloadLimit);
+export const p = (fn, payloadLimit = defaultPayloadLimit, payloadLimitErrorFn = defaultErrorFn) => (req, _res, next) => new Promise((resolve) => {
+    const body = [];
+    let totalSize = 0;
+    req.on('data', (chunk) => {
+        totalSize += chunk.byteLength;
+        if (totalSize > payloadLimit) {
+            req.removeAllListeners();
+            next === null || next === void 0 ? void 0 : next(payloadLimitErrorFn(payloadLimit));
+            resolve(undefined);
+        }
+        else {
             body.push(chunk);
         }
-        return fn(Buffer.concat(body));
-    }
-    catch (e) {
-        next === null || next === void 0 ? void 0 : next(e);
-    }
-};
+    });
+    req.on('end', () => {
+        try {
+            resolve(fn(body.length === 1 ? body[0] : Buffer.concat(body), req));
+        }
+        catch (e) {
+            next === null || next === void 0 ? void 0 : next(e);
+            resolve(undefined);
+        }
+    });
+    req.on('error', (err) => {
+        next === null || next === void 0 ? void 0 : next(err);
+        resolve(undefined);
+    });
+});
 /**
  * Parse payload with a custom function
  * @param fn
  */
-const custom = (fn) => async (req, _res, next) => {
-    if (hasBody(req.method))
-        req.body = await p(fn)(req, _res, next);
-    next === null || next === void 0 ? void 0 : next();
+const custom = (fn, type) => {
+    const parse = p(fn);
+    return async (req, _res, next) => {
+        if (hasBody(req.method) && checkType(req, type))
+            req.body = await parse(req, _res, next);
+        next === null || next === void 0 ? void 0 : next();
+    };
 };
 /**
  * Parse JSON payload
  * @param options
  */
-const json = ({ payloadLimit, payloadLimitErrorFn } = {}) => async (req, res, next) => {
-    if (hasBody(req.method)) {
-        req.body = await p((x) => {
-            const str = td.decode(x);
-            return str ? JSON.parse(str) : {};
-        }, payloadLimit, payloadLimitErrorFn)(req, res, next);
-    }
-    next === null || next === void 0 ? void 0 : next();
+const json = ({ payloadLimit, payloadLimitErrorFn, type, reviver } = {}) => {
+    const parse = p((x) => (x.length === 0 ? {} : JSON.parse(x.toString(), reviver)), payloadLimit, payloadLimitErrorFn);
+    return async (req, res, next) => {
+        if (hasBody(req.method) && checkType(req, type)) {
+            req.body = await parse(req, res, next);
+        }
+        next === null || next === void 0 ? void 0 : next();
+    };
 };
 /**
  * Parse raw payload
  * @param options
  */
-const raw = ({ payloadLimit, payloadLimitErrorFn } = {}) => async (req, _res, next) => {
-    if (hasBody(req.method)) {
-        req.body = await p((x) => x, payloadLimit, payloadLimitErrorFn)(req, _res, next);
-    }
-    next === null || next === void 0 ? void 0 : next();
+const raw = ({ payloadLimit, payloadLimitErrorFn, type } = {}) => {
+    const parse = p((x) => x, payloadLimit, payloadLimitErrorFn);
+    return async (req, _res, next) => {
+        if (hasBody(req.method) && checkType(req, type)) {
+            req.body = await parse(req, _res, next);
+        }
+        next === null || next === void 0 ? void 0 : next();
+    };
 };
-const td = new TextDecoder();
 /**
  * Stringify request payload
  * @param param0
  * @returns
  */
-const text = ({ payloadLimit, payloadLimitErrorFn } = {}) => async (req, _res, next) => {
-    if (hasBody(req.method)) {
-        req.body = await p((x) => td.decode(x), payloadLimit, payloadLimitErrorFn)(req, _res, next);
-    }
-    next === null || next === void 0 ? void 0 : next();
+const text = ({ payloadLimit, payloadLimitErrorFn, type } = {}) => {
+    const parse = p((x) => x.toString(), payloadLimit, payloadLimitErrorFn);
+    return async (req, _res, next) => {
+        if (hasBody(req.method) && checkType(req, type)) {
+            req.body = await parse(req, _res, next);
+        }
+        next === null || next === void 0 ? void 0 : next();
+    };
 };
+const td = new TextDecoder();
 /**
  * Parse urlencoded payload
  * @param options
  */
-const urlencoded = ({ payloadLimit, payloadLimitErrorFn } = {}) => async (req, _res, next) => {
-    if (hasBody(req.method)) {
-        req.body = await p((x) => Object.fromEntries(new URLSearchParams(x.toString()).entries()), payloadLimit, payloadLimitErrorFn)(req, _res, next);
-    }
-    next === null || next === void 0 ? void 0 : next();
+const urlencoded = ({ payloadLimit, payloadLimitErrorFn, type } = {}) => {
+    const parse = p((x) => Object.fromEntries(new URLSearchParams(x.toString()).entries()), payloadLimit, payloadLimitErrorFn);
+    return async (req, _res, next) => {
+        if (hasBody(req.method) && checkType(req, type)) {
+            req.body = await parse(req, _res, next);
+        }
+        next === null || next === void 0 ? void 0 : next();
+    };
 };
 const getBoundary = (contentType) => {
     const match = /boundary=(.+);?/.exec(contentType);
     return match ? `--${match[1]}` : null;
 };
 const defaultFileSizeLimitErrorFn = (limit) => new Error(`File too large. Limit: ${limit} bytes`);
-const defaultFileSizeLimit = 200 * 1024 * 1024;
+const defaultFileSizeLimit = 200 * 1024 * 1024; // 200MiB
 const parseMultipart = (body, boundary, { fileCountLimit, fileSizeLimit = defaultFileSizeLimit, fileSizeLimitErrorFn = defaultFileSizeLimitErrorFn }) => {
     const parts = body.split(new RegExp(`${boundary}(--)?`)).filter((part) => !!part && /content-disposition/i.test(part));
     const parsedBody = {};
     if (fileCountLimit && parts.length > fileCountLimit)
         throw new Error(`Too many files. Limit: ${fileCountLimit}`);
-    // biome-ignore lint/complexity/noForEach: for...of fails
     parts.forEach((part) => {
+        var _a, _b;
         const [headers, ...lines] = part.split('\r\n').filter((part) => !!part);
         const data = lines.join('\r\n').trim();
         if (data.length > fileSizeLimit)
@@ -96,11 +122,11 @@ const parseMultipart = (body, boundary, { fileCountLimit, fileSizeLimit = defaul
             const contentTypeMatch = /Content-Type: (.+)/i.exec(data);
             const fileContent = data.slice(contentTypeMatch[0].length + 2);
             const file = new File([fileContent], filename[1], { type: contentTypeMatch[1] });
-            parsedBody[name] = parsedBody[name] ? [...parsedBody[name], file] : [file];
+            ((_a = parsedBody[name]) !== null && _a !== void 0 ? _a : (parsedBody[name] = [])).push(file);
             return;
         }
-        parsedBody[name] = parsedBody[name] ? [...parsedBody[name], data] : [data];
-        return;
+        ;
+        ((_b = parsedBody[name]) !== null && _b !== void 0 ? _b : (parsedBody[name] = [])).push(data);
     });
     return parsedBody;
 };
@@ -110,15 +136,18 @@ const parseMultipart = (body, boundary, { fileCountLimit, fileSizeLimit = defaul
  * Does not restrict total payload size by default.
  * @param options
  */
-const multipart = ({ payloadLimit = Number.POSITIVE_INFINITY, payloadLimitErrorFn, ...opts } = {}) => async (req, res, next) => {
-    if (hasBody(req.method)) {
-        req.body = await p((x) => {
-            const boundary = getBoundary(req.headers['content-type']);
-            if (boundary)
-                return parseMultipart(td.decode(x), boundary, opts);
-            return {};
-        }, payloadLimit, payloadLimitErrorFn)(req, res, next);
-    }
-    next === null || next === void 0 ? void 0 : next();
+const multipart = ({ payloadLimit = Number.POSITIVE_INFINITY, payloadLimitErrorFn, type, ...opts } = {}) => {
+    const parse = p((x, req) => {
+        const boundary = getBoundary(req.headers['content-type']);
+        if (boundary)
+            return parseMultipart(td.decode(x), boundary, opts);
+        return {};
+    }, payloadLimit, payloadLimitErrorFn);
+    return async (req, res, next) => {
+        if (hasBody(req.method) && checkType(req, type)) {
+            req.body = await parse(req, res, next);
+        }
+        next === null || next === void 0 ? void 0 : next();
+    };
 };
 export { custom, json, raw, text, urlencoded, multipart };

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage } from 'node:http';
+/**
+ * Request extension with a body
+ */
+export type ReqWithBody<T = any> = IncomingMessage & {
+    body?: T;
+};
+export type LimitErrorFn = (limit: number) => Error;
+export type ParserOptions<T extends Record<string, any> = Record<string, any>> = Partial<{
+    /**
+     * Limit payload size (in bytes)
+     * @default 102400
+     */
+    payloadLimit: number;
+    /**
+     * Custom error function for payload limit
+     */
+    payloadLimitErrorFn: LimitErrorFn;
+    /**
+     * Middleware content type
+     */
+    type: (req: IncomingMessage) => boolean;
+}> & T;
+export type NextFunction = (err?: any) => void;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import type { IncomingMessage } from 'node:http';
+import type { ParserOptions } from './types.ts';
+export declare const hasBody: (method: string) => boolean;
+export declare const checkType: (req: IncomingMessage, type: ParserOptions["type"]) => boolean;

package/dist/utils.js

@@ -0,0 +1,3 @@
+const bodyMethods = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
+export const hasBody = (method) => bodyMethods.has(method);
+export const checkType = (req, type) => typeof type === 'function' ? type(req) : true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "milliparsec",
-  "version": "5.0.2",
+  "version": "5.1.1",
   "description": "tiniest body parser in the universe",
   "repository": {
     "type": "git",
@@ -21,25 +21,25 @@
   },
   "exports": "./dist/index.js",
   "devDependencies": {
-    "@biomejs/biome": "1.9.3",
-    "@tinyhttp/app": "^2.4.0",
-    "@types/node": "^18.19.76",
+    "@biomejs/biome": "2.2.2",
+    "@tinyhttp/app": "^2.5.2",
+    "@types/express": "^5.0.6",
+    "@types/node": "^18.19.130",
     "c8": "10.1.2",
+    "express": "^5.2.1",
     "supertest-fetch": "^2.0.0",
-    "tsx": "^4.19.1",
-    "typescript": "^5.6.2"
+    "typescript": "^5.9.3"
   },
   "files": [
     "dist"
   ],
-  "publishConfig": {
-    "provenance": true
-  },
   "scripts": {
-    "test": "tsx --test test.ts",
+    "test": "node --test test.ts",
     "test:coverage": "c8 --include=src pnpm test",
     "test:report": "c8 report --reporter=text-lcov > coverage.lcov",
     "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "pnpm build && pnpm test",
     "check": "biome check --write"
-  }
-}
+  },
+  "packageManager": "pnpm@10.11.0"
+}