@ubercode/multipart-stream 1.0.0 → 1.1.0

package/README.md

@@ -14,8 +14,7 @@ npm install @ubercode/multipart-stream
 yarn add @ubercode/multipart-stream
 ```
 
-Requires Node `>= 20.18.0`. Single runtime dependency: `dicer@0.3.1` (pinned
-exact).
+Requires Node `>= 20.18.0`. The sole runtime dependency is `streamsearch@1.1.0`; multipart headers and part streams are parsed inside this package.
 
 ## Quickstart
 
@@ -101,10 +100,7 @@ for await (const part of parseMultipartRelated(req as unknown as Readable, {
 }
 ```
 
-The library never pauses dicer's internal state machine on your behalf —
-your parser must drain or destroy each `part.body` before requesting the
-next part. If you don't, the iterator's `finally` destroys leftover bodies
-for you (FR-010), but that costs latency.
+Drain or destroy each `part.body` before requesting the next part. The parser applies backpressure while a body is waiting for a reader; the iterator destroys leftover bodies when it closes.
 
 ## API
 

package/dist/index.cjs

@@ -1,11 +1,11 @@
 'use strict';
 
 var stream = require('stream');
-var dicerMod = require('dicer');
+var StreamSearch = require('streamsearch');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var dicerMod__default = /*#__PURE__*/_interopDefault(dicerMod);
+var StreamSearch__default = /*#__PURE__*/_interopDefault(StreamSearch);
 
 // src/errors.ts
 var MultipartIdleTimeoutError = class extends Error {
@@ -299,7 +299,7 @@ function flattenHeaderValue(v) {
   }
   return "";
 }
-function flattenDicerHeaders(raw) {
+function flattenPartHeaders(raw) {
   if (raw == null) return {};
   const out = {};
   for (const key of Object.keys(raw)) {
@@ -309,6 +309,213 @@ function flattenDicerHeaders(raw) {
   }
   return out;
 }
+var HEADER_END = Buffer.from("\r\n\r\n");
+var INITIAL_CRLF = Buffer.from("\r\n");
+var CLOSING_DASHES = Buffer.from("--");
+var CLOSING_CR = Buffer.from("--\r");
+var MAX_HEADER_BYTES = 80 * 1024;
+var MAX_HEADER_PAIRS = 2e3;
+var MultipartPartStream = class extends stream.Readable {
+  constructor(onRead) {
+    super();
+    this.onRead = onRead;
+  }
+  onRead;
+  _read() {
+    this.onRead();
+  }
+};
+function parseHeaders(block) {
+  const headers = /* @__PURE__ */ Object.create(null);
+  if (block.length === 0) return headers;
+  const lines = block.toString("latin1").split("\r\n");
+  let previousName;
+  let count = 0;
+  for (const line of lines) {
+    if (line.startsWith(" ") || line.startsWith("	")) {
+      if (previousName === void 0) {
+        throw new Error("Unexpected folded header value");
+      }
+      const values = headers[previousName];
+      if (values === void 0) throw new Error("Malformed part header");
+      values[values.length - 1] += line;
+      continue;
+    }
+    const colon = line.indexOf(":");
+    if (colon <= 0) throw new Error("Malformed part header");
+    const name = line.slice(0, colon);
+    if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) {
+      throw new Error("Malformed part header");
+    }
+    const value = line.slice(colon + 1).replace(/^[ \t]/, "");
+    if (/[\x00-\x08\x0a-\x1f\x7f]/.test(value)) {
+      throw new Error("Malformed part header");
+    }
+    const key = name.toLowerCase();
+    (headers[key] ??= []).push(value);
+    previousName = key;
+    if (++count > MAX_HEADER_PAIRS) throw new Error("Too many part headers");
+  }
+  return headers;
+}
+var MultipartParser = class extends stream.Writable {
+  needle;
+  search;
+  state = "preamble";
+  part;
+  headerBytes = Buffer.alloc(0);
+  suffix = Buffer.alloc(0);
+  candidate = false;
+  pausedPart;
+  pendingWrite;
+  openParts = 0;
+  finalCallback;
+  constructor(boundary) {
+    super();
+    if (boundary.length === 0) throw new TypeError("Boundary required");
+    this.needle = Buffer.from(`\r
+--${boundary}`);
+    this.search = new StreamSearch__default.default(this.needle, (matched, data, start, end, safe) => {
+      if (this.state !== "done" && data && start < end) {
+        const chunk = data.subarray(start, end);
+        this.consume(safe ? chunk : Buffer.from(chunk));
+      }
+      if (this.state === "done") return;
+      if (matched) {
+        if (this.state === "headers") throw new Error("Malformed part header");
+        this.candidate = true;
+      }
+    });
+    this.search.push(INITIAL_CRLF);
+  }
+  _write(chunk, _encoding, callback) {
+    try {
+      this.search.push(chunk);
+      if (this.pausedPart) this.pendingWrite = callback;
+      else callback();
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  _final(callback) {
+    try {
+      this.search.destroy();
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error(String(error)));
+      return;
+    }
+    if (this.candidate && this.suffix.equals(CLOSING_DASHES)) {
+      this.candidate = false;
+      this.endPart();
+      this.state = "done";
+    }
+    if (this.state !== "done") {
+      const error = new Error("Unexpected end of multipart data");
+      this.endPart();
+      callback(error);
+      return;
+    }
+    if (this.openParts === 0) callback();
+    else this.finalCallback = callback;
+  }
+  resumeWrite(part) {
+    if (this.pausedPart !== part) return;
+    this.pausedPart = void 0;
+    const callback = this.pendingWrite;
+    this.pendingWrite = void 0;
+    callback?.();
+  }
+  endPart() {
+    const part = this.part;
+    if (part === void 0) return;
+    this.part = void 0;
+    part.push(null);
+  }
+  beginPart() {
+    this.headerBytes = Buffer.alloc(0);
+    this.state = "headers";
+    const part = new MultipartPartStream(() => this.resumeWrite(part));
+    this.part = part;
+    this.openParts++;
+    let settled = false;
+    const onPartDone = () => {
+      if (settled) return;
+      settled = true;
+      this.openParts--;
+      this.resumeWrite(part);
+      if (this.openParts === 0 && this.finalCallback) {
+        const callback = this.finalCallback;
+        this.finalCallback = void 0;
+        callback();
+      }
+    };
+    part.once("end", onPartDone);
+    part.once("close", onPartDone);
+    this.emit("part", part);
+  }
+  consume(data) {
+    if (this.candidate) {
+      if (this.suffix.length < 2) {
+        const taken = Math.min(2 - this.suffix.length, data.length);
+        this.suffix = Buffer.concat([this.suffix, data.subarray(0, taken)]);
+        data = data.subarray(taken);
+      }
+      if (this.suffix.length < 2) return;
+      if (this.suffix.equals(CLOSING_DASHES)) {
+        if (data.length === 0) return;
+        if (data[0] === 13) {
+          this.suffix = CLOSING_CR;
+          data = data.subarray(1);
+          if (data.length === 0) return;
+        }
+      }
+      if (this.suffix.equals(CLOSING_CR) && data.length === 0) return;
+      const suffix = this.suffix;
+      this.suffix = Buffer.alloc(0);
+      this.candidate = false;
+      if (suffix.equals(INITIAL_CRLF)) {
+        this.endPart();
+        this.beginPart();
+      } else if (suffix.equals(CLOSING_CR) && data[0] === 10) {
+        data = data.subarray(1);
+        this.endPart();
+        this.state = "done";
+        return;
+      } else if (this.state === "headers") {
+        data = Buffer.concat([this.needle, suffix, data]);
+      } else if (this.state === "body") {
+        this.consumeBody(this.needle);
+        this.consumeBody(suffix);
+      }
+    }
+    if (this.state === "headers") {
+      const pending = this.headerBytes.length;
+      const scan = data.subarray(0, MAX_HEADER_BYTES + HEADER_END.length - pending);
+      const combined = Buffer.concat([this.headerBytes, scan]);
+      const empty = combined.length >= 2 && combined.subarray(0, 2).equals(INITIAL_CRLF);
+      const end = empty ? 0 : combined.indexOf(HEADER_END);
+      if (end < 0) {
+        if (combined.length > MAX_HEADER_BYTES) throw new Error("Part headers too large");
+        this.headerBytes = combined;
+        return;
+      }
+      if (end > MAX_HEADER_BYTES) throw new Error("Part headers too large");
+      const headers = parseHeaders(combined.subarray(0, end));
+      const rawHeaders = Buffer.from(combined.subarray(0, end + (empty ? 2 : HEADER_END.length)));
+      this.headerBytes = Buffer.alloc(0);
+      this.state = "body";
+      this.part?.emit("header", headers, rawHeaders);
+      this.consumeBody(data.subarray(end + (empty ? 2 : HEADER_END.length) - pending));
+    } else if (this.state === "body") {
+      this.consumeBody(data);
+    }
+  }
+  consumeBody(data) {
+    if (data.length > 0 && this.part && !this.part.destroyed && !this.part.push(data)) {
+      this.pausedPart = this.part;
+    }
+  }
+};
 function looksLikeResponse(input) {
   if (typeof Response !== "undefined" && input instanceof Response) {
     return true;
@@ -470,19 +677,6 @@ function setupTimers(opts, startMs) {
 }
 
 // src/parse-multipart-related.ts
-function measureHeaderValueBytes(value) {
-  if (typeof value === "string") return Buffer.byteLength(value);
-  if (Array.isArray(value)) {
-    let total = 0;
-    for (const inner of value) {
-      total += measureHeaderValueBytes(inner);
-    }
-    return total;
-  }
-  if (Buffer.isBuffer(value)) return value.length;
-  return 0;
-}
-var Dicer = dicerMod__default.default.default ?? dicerMod__default.default;
 function parseMultipartRelated(input, opts) {
   return parseMultipartRelatedImpl(input, opts);
 }
@@ -497,11 +691,11 @@ async function* parseMultipartRelatedImpl(input, opts) {
     boundary: opts.boundary
   });
   const logger = opts.logger ?? defaultLogger;
-  const dicer = new Dicer({ boundary });
+  const parser = new MultipartParser(boundary);
   const queue = createQueueNotifier();
   let bytesReceived = 0;
   let nextPartIndex = 0;
-  let dicerFinished = false;
+  let parserFinished = false;
   let cleaned = false;
   let abortPushed = false;
   const allPartStreams = /* @__PURE__ */ new Set();
@@ -559,21 +753,13 @@ async function* parseMultipartRelatedImpl(input, opts) {
     const headersAccumulator = {
       value: {}
     };
-    const onHeader = (raw) => {
+    const onHeader = (raw, rawHeaderBlock) => {
       const bag = raw;
       let headerCount = 0;
-      let headerBytes = 0;
-      if (bag != null) {
-        for (const name of Object.keys(bag)) {
-          const value = bag[name];
-          const nameBytes = Buffer.byteLength(name);
-          const values = Array.isArray(value) ? value : [value];
-          for (const inner of values) {
-            headerCount += 1;
-            headerBytes += nameBytes + 4 + measureHeaderValueBytes(inner);
-          }
-        }
+      if (bag !== void 0) {
+        for (const values of Object.values(bag)) headerCount += values.length;
       }
+      const headerBytes = rawHeaderBlock.length;
       if (headerCount > maxHeadersPerPart) {
         if (!partStream.destroyed) partStream.destroy();
         queue.signalError(
@@ -598,7 +784,7 @@ async function* parseMultipartRelatedImpl(input, opts) {
         );
         return;
       }
-      headersAccumulator.value = flattenDicerHeaders(
+      headersAccumulator.value = flattenPartHeaders(
         raw
       );
       const headers = headersAccumulator.value;
@@ -650,12 +836,12 @@ async function* parseMultipartRelatedImpl(input, opts) {
         index: partIndex,
         boundary,
         headers,
-        rawHeaders: Buffer.alloc(0),
+        rawHeaders: rawHeaderBlock,
         contentType,
         ...contentId !== void 0 ? { contentId } : {},
         ...contentLength !== void 0 ? { contentLength } : {},
         // When maxPartBytes is configured, body is the PassThrough that
-        // wraps dicer's per-part Readable; otherwise body is dicer's
+        // wraps parser's per-part Readable; otherwise body is parser's
         // per-part Readable directly. Both expose Node `Readable`.
         body: publicBody
       };
@@ -676,10 +862,10 @@ async function* parseMultipartRelatedImpl(input, opts) {
     });
   };
   const onFinish = () => {
-    dicerFinished = true;
+    parserFinished = true;
     queue.signalEnd();
   };
-  const onDicerError = (err) => {
+  const onParserError = (err) => {
     if (cleaned) {
       logger({
         level: "warn",
@@ -699,18 +885,18 @@ async function* parseMultipartRelatedImpl(input, opts) {
   };
   const onSourceEnd = () => {
     setImmediate(() => {
-      if (dicerFinished) return;
+      if (parserFinished) return;
       if (cleaned) return;
       queue.signalError(new MultipartTruncatedError(bytesReceived));
     });
   };
-  dicer.on("part", onPart);
-  dicer.on("finish", onFinish);
-  dicer.on("error", onDicerError);
+  parser.on("part", onPart);
+  parser.on("finish", onFinish);
+  parser.on("error", onParserError);
   source.on("data", onSourceData);
   source.on("error", onSourceError);
   source.on("end", onSourceEnd);
-  source.pipe(dicer);
+  source.pipe(parser);
   const cleanup = () => {
     if (cleaned) return;
     cleaned = true;
@@ -718,7 +904,7 @@ async function* parseMultipartRelatedImpl(input, opts) {
     source.off("error", onSourceError);
     source.off("end", onSourceEnd);
     try {
-      source.unpipe(dicer);
+      source.unpipe(parser);
     } catch (err) {
       logger({
         level: "warn",
@@ -736,8 +922,8 @@ async function* parseMultipartRelatedImpl(input, opts) {
       if (!partStream.destroyed) partStream.destroy();
     }
     allPartStreams.clear();
-    dicer.off("part", onPart);
-    dicer.off("finish", onFinish);
+    parser.off("part", onPart);
+    parser.off("finish", onFinish);
     timers.signal.removeEventListener("abort", onCombinedAbort);
     timers.cleanup();
   };