@orpc/node 2.0.0-beta.27 → 2.0.0-beta.28

package/README.md

@@ -118,6 +118,7 @@ Like what we build over at [middleapi](https://github.com/middleapi)? You can he
    <td align="center"><a href="https://github.com/Ryanjso?ref=orpc" target="_blank" rel="sponsored noopener" title="Ryan Soderberg"><img src="https://avatars.githubusercontent.com/u/39172778?u=5ed913c31d57e7221b75784abcad48c7ebddde27&amp;v=4" width="139" alt="Ryan Soderberg"/><br />Ryan Soderberg</a></td>
    <td align="center"><a href="https://github.com/itigoore01?ref=orpc" target="_blank" rel="sponsored noopener" title="shota"><img src="https://avatars.githubusercontent.com/u/11831107?u=c976a6dc7e055eb026304c46c99100ed22b0c8e0&amp;v=4" width="139" alt="shota"/><br />shota</a></td>
    <td align="center"><a href="https://github.com/ellis-driscoll?ref=orpc" target="_blank" rel="sponsored noopener" title="Ellis Driscoll"><img src="https://avatars.githubusercontent.com/u/70685966?u=c5f95bc33b5991d9744abe00052542e4a2ed3cb9&amp;v=4" width="139" alt="Ellis Driscoll"/><br />Ellis Driscoll</a></td>
+   <td align="center"><a href="https://github.com/hoangbn?ref=orpc" target="_blank" rel="sponsored noopener" title="Hoang Nguyen"><img src="https://avatars.githubusercontent.com/u/38968280?u=c90084c6de65c56facabab7ba13a72a49ddbc3e4&amp;v=4" width="139" alt="Hoang Nguyen"/><br />Hoang Nguyen</a></td>
   </tr>
 </table>
 

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
+import { FilePropertyBag } from 'node:buffer';
 
 interface StaticFileHandlerPluginOptions {
     /**
@@ -126,5 +127,113 @@ declare class StaticFileHandlerPlugin<T extends Context> implements StandardHand
     private serve;
 }
 
-export { StaticFileHandlerPlugin };
-export type { StaticFileHandlerPluginOptions };
+interface TmpFileUploadHandlerPluginMaxBodySize {
+    /**
+     * The maximum total size in bytes of request body content that is parsed
+     * into memory: JSON, URL-encoded forms, and the plain fields of a multipart
+     * body. A larger body rejects the request with `PAYLOAD_TOO_LARGE`. Usually
+     * the lowest of the three limits, because this content cannot stream anywhere.
+     */
+    memory: number;
+    /**
+     * The maximum total size in bytes of upload content a request streams into
+     * temporary files: file bodies and the file parts of a multipart body
+     * combined. A larger body rejects the request with `PAYLOAD_TOO_LARGE`.
+     */
+    file: number;
+    /**
+     * The maximum total size in bytes of a request body that is consumed as a
+     * stream: event streams and raw binary streams. Enforced while the stream is
+     * consumed, so an oversized stream fails at the reader. Usually the highest
+     * of the three limits, because this content is consumed on the fly.
+     */
+    stream: number;
+}
+interface TmpFileUploadHandlerPluginOptions {
+    /**
+     * The directory temporary files are created under. Each request that spools
+     * an upload gets its own subdirectory inside it, removed when the request
+     * finishes.
+     *
+     * @default os.tmpdir()
+     */
+    tmpDir?: string;
+    /**
+     * The size limit for each kind of request body. Every kind is required when
+     * the option is given, so none is left unbounded by accident; set a kind to
+     * `Number.POSITIVE_INFINITY` to deliberately leave it unlimited.
+     *
+     * @default unlimited for every kind
+     */
+    maxBodySize?: TmpFileUploadHandlerPluginMaxBodySize;
+}
+/**
+ * A `File` whose content lives in a temporary file on disk and is read lazily,
+ * so it can represent an upload far larger than available memory.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/tmp-file-upload | Tmp File Upload Plugin}
+ */
+declare class TmpFile extends File {
+    /**
+     * Absolute path of the temporary file holding this file's content.
+     * The file is removed when the request finishes, so move or copy it
+     * to keep the content. The `File` reads from this path, so it must
+     * not be read after the file is moved or removed.
+     */
+    readonly path: string;
+    constructor(blob: Blob, 
+    /**
+     * Absolute path of the temporary file holding this file's content.
+     * The file is removed when the request finishes, so move or copy it
+     * to keep the content. The `File` reads from this path, so it must
+     * not be read after the file is moved or removed.
+     */
+    path: string, name: string, options?: FilePropertyBag);
+}
+/**
+ * Parses file uploads into temporary files instead of memory. Bodies the standard
+ * body parser would buffer into an in-memory `File`, and multipart file parts, are
+ * streamed to disk and surfaced as lazily read {@link TmpFile} instances, so requests
+ * far larger than available memory parse in constant memory. Every other body is left
+ * to the standard parser.
+ *
+ * Request body sizes are limited per content category: memory-parsed, spooled to
+ * disk, and streamed. This subsumes the request limit plugin while sizing each
+ * kind of body to what it actually costs.
+ *
+ * @remarks
+ * Temporary files are removed when the request finishes. A streaming response body,
+ * an event iterator or a raw stream, keeps them alive until it completes, so
+ * responses that read the upload while streaming work. Any other response is
+ * transmitted after removal, so one that embeds the upload itself, as a `File` or
+ * inside `FormData`, needs the content copied or the file moved first.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/tmp-file-upload | Tmp File Upload Plugin}
+ */
+declare class TmpFileUploadHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should parse the original request body instead of batched sub-requests.
+     */
+    after: string[];
+    /**
+     * Should run inside the limit and compression plugins, so spooling receives
+     * the size-checked, decompressed bytes.
+     */
+    before: string[];
+    private readonly tmpDir;
+    private readonly maxBodySize;
+    constructor(options?: TmpFileUploadHandlerPluginOptions);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+    private resolveBody;
+    /**
+     * Enforces a size limit on a body the standard parser handles, counting the
+     * raw bytes before handing them back for regular parsing.
+     */
+    private parseLimitedBody;
+    private spoolFileBody;
+    private parseMultipartBody;
+}
+
+export { StaticFileHandlerPlugin, TmpFile, TmpFileUploadHandlerPlugin };
+export type { StaticFileHandlerPluginOptions, TmpFileUploadHandlerPluginMaxBodySize, TmpFileUploadHandlerPluginOptions };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
+import { FilePropertyBag } from 'node:buffer';
 
 interface StaticFileHandlerPluginOptions {
     /**
@@ -126,5 +127,113 @@ declare class StaticFileHandlerPlugin<T extends Context> implements StandardHand
     private serve;
 }
 
-export { StaticFileHandlerPlugin };
-export type { StaticFileHandlerPluginOptions };
+interface TmpFileUploadHandlerPluginMaxBodySize {
+    /**
+     * The maximum total size in bytes of request body content that is parsed
+     * into memory: JSON, URL-encoded forms, and the plain fields of a multipart
+     * body. A larger body rejects the request with `PAYLOAD_TOO_LARGE`. Usually
+     * the lowest of the three limits, because this content cannot stream anywhere.
+     */
+    memory: number;
+    /**
+     * The maximum total size in bytes of upload content a request streams into
+     * temporary files: file bodies and the file parts of a multipart body
+     * combined. A larger body rejects the request with `PAYLOAD_TOO_LARGE`.
+     */
+    file: number;
+    /**
+     * The maximum total size in bytes of a request body that is consumed as a
+     * stream: event streams and raw binary streams. Enforced while the stream is
+     * consumed, so an oversized stream fails at the reader. Usually the highest
+     * of the three limits, because this content is consumed on the fly.
+     */
+    stream: number;
+}
+interface TmpFileUploadHandlerPluginOptions {
+    /**
+     * The directory temporary files are created under. Each request that spools
+     * an upload gets its own subdirectory inside it, removed when the request
+     * finishes.
+     *
+     * @default os.tmpdir()
+     */
+    tmpDir?: string;
+    /**
+     * The size limit for each kind of request body. Every kind is required when
+     * the option is given, so none is left unbounded by accident; set a kind to
+     * `Number.POSITIVE_INFINITY` to deliberately leave it unlimited.
+     *
+     * @default unlimited for every kind
+     */
+    maxBodySize?: TmpFileUploadHandlerPluginMaxBodySize;
+}
+/**
+ * A `File` whose content lives in a temporary file on disk and is read lazily,
+ * so it can represent an upload far larger than available memory.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/tmp-file-upload | Tmp File Upload Plugin}
+ */
+declare class TmpFile extends File {
+    /**
+     * Absolute path of the temporary file holding this file's content.
+     * The file is removed when the request finishes, so move or copy it
+     * to keep the content. The `File` reads from this path, so it must
+     * not be read after the file is moved or removed.
+     */
+    readonly path: string;
+    constructor(blob: Blob, 
+    /**
+     * Absolute path of the temporary file holding this file's content.
+     * The file is removed when the request finishes, so move or copy it
+     * to keep the content. The `File` reads from this path, so it must
+     * not be read after the file is moved or removed.
+     */
+    path: string, name: string, options?: FilePropertyBag);
+}
+/**
+ * Parses file uploads into temporary files instead of memory. Bodies the standard
+ * body parser would buffer into an in-memory `File`, and multipart file parts, are
+ * streamed to disk and surfaced as lazily read {@link TmpFile} instances, so requests
+ * far larger than available memory parse in constant memory. Every other body is left
+ * to the standard parser.
+ *
+ * Request body sizes are limited per content category: memory-parsed, spooled to
+ * disk, and streamed. This subsumes the request limit plugin while sizing each
+ * kind of body to what it actually costs.
+ *
+ * @remarks
+ * Temporary files are removed when the request finishes. A streaming response body,
+ * an event iterator or a raw stream, keeps them alive until it completes, so
+ * responses that read the upload while streaming work. Any other response is
+ * transmitted after removal, so one that embeds the upload itself, as a `File` or
+ * inside `FormData`, needs the content copied or the file moved first.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/tmp-file-upload | Tmp File Upload Plugin}
+ */
+declare class TmpFileUploadHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should parse the original request body instead of batched sub-requests.
+     */
+    after: string[];
+    /**
+     * Should run inside the limit and compression plugins, so spooling receives
+     * the size-checked, decompressed bytes.
+     */
+    before: string[];
+    private readonly tmpDir;
+    private readonly maxBodySize;
+    constructor(options?: TmpFileUploadHandlerPluginOptions);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+    private resolveBody;
+    /**
+     * Enforces a size limit on a body the standard parser handles, counting the
+     * raw bytes before handing them back for regular parsing.
+     */
+    private parseLimitedBody;
+    private spoolFileBody;
+    private parseMultipartBody;
+}
+
+export { StaticFileHandlerPlugin, TmpFile, TmpFileUploadHandlerPlugin };
+export type { StaticFileHandlerPluginOptions, TmpFileUploadHandlerPluginMaxBodySize, TmpFileUploadHandlerPluginOptions };

package/dist/index.mjs

@@ -1,10 +1,14 @@
-import { createReadStream } from 'node:fs';
-import { realpath, stat } from 'node:fs/promises';
+import { createReadStream, openAsBlob } from 'node:fs';
+import { realpath, stat, mkdtemp, appendFile, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { Readable } from 'node:stream';
-import { toArray, mergeHttpPath, tryDecodeURIComponent, matchesHttpPathPrefix, isCompressibleContentType, parseAcceptEncodingQualities, getOpenTelemetryConfig } from '@orpc/shared';
-import { parseStandardUrl, flattenStandardHeader } from '@standardserver/core';
+import { toArray, mergeHttpPath, tryDecodeURIComponent, matchesHttpPathPrefix, isCompressibleContentType, parseAcceptEncodingQualities, getOpenTelemetryConfig, isAsyncIteratorObject, override, wrapAsyncIterator, wrapReadableStream } from '@orpc/shared';
+import { parseStandardUrl, flattenStandardHeader, resolveStandardBodyHint, getFilenameFromContentDisposition } from '@standardserver/core';
 import mime from 'mime';
+import { Buffer } from 'node:buffer';
+import { tmpdir } from 'node:os';
+import { ORPCError } from '@orpc/server';
+import { toFetchHeaders, toStandardBody } from '@standardserver/fetch';
 
 const TEXT_CONTENT_TYPE_REGEX = /^text\//;
 const PRECOMPRESSED_ENCODINGS = [
@@ -325,4 +329,407 @@ function parseByteRange(range, size) {
   return [start, end];
 }
 
-export { StaticFileHandlerPlugin };
+const MAX_PART_HEADER_SIZE = 16 * 1024;
+const CRLF = Buffer.from("\r\n");
+const HEADER_BLOCK_END = Buffer.from("\r\n\r\n");
+async function parseMultipart(source, boundary, onPart) {
+  const delimiter = Buffer.from(`\r
+--${boundary}`);
+  let buffer = CRLF;
+  let state = "preamble";
+  let writer;
+  let done = false;
+  const process = async () => {
+    while (true) {
+      if (state === "preamble" || state === "body") {
+        const index = buffer.indexOf(delimiter);
+        if (index === -1) {
+          const settledLength = buffer.length - delimiter.length + 1;
+          if (settledLength > 0) {
+            if (state === "body") {
+              await writer.write(buffer.subarray(0, settledLength));
+            }
+            buffer = buffer.subarray(settledLength);
+          }
+          return;
+        }
+        if (state === "body") {
+          if (index > 0) {
+            await writer.write(buffer.subarray(0, index));
+          }
+          await writer.end();
+          writer = void 0;
+        }
+        buffer = buffer.subarray(index + delimiter.length);
+        state = "delimiter-end";
+        continue;
+      }
+      if (state === "delimiter-end") {
+        if (buffer.length < 2) {
+          return;
+        }
+        if (buffer[0] === 45 && buffer[1] === 45) {
+          done = true;
+          buffer = Buffer.alloc(0);
+          return;
+        }
+        let index = 0;
+        while (index < buffer.length && (buffer[index] === 32 || buffer[index] === 9)) {
+          index++;
+        }
+        if (index + 1 >= buffer.length) {
+          return;
+        }
+        if (buffer[index] !== 13 || buffer[index + 1] !== 10) {
+          throw new TypeError("Invalid multipart body: expected CRLF after a boundary delimiter");
+        }
+        buffer = buffer.subarray(index + 2);
+        state = "headers";
+        continue;
+      }
+      if (buffer[0] === 13 && buffer[1] === 10) {
+        throw new TypeError("Invalid multipart body: part is missing the content-disposition header");
+      }
+      const headerEnd = buffer.indexOf(HEADER_BLOCK_END);
+      if (headerEnd === -1) {
+        if (buffer.length > MAX_PART_HEADER_SIZE) {
+          throw new TypeError("Invalid multipart body: part headers exceed the maximum allowed size");
+        }
+        return;
+      }
+      const part = parsePartHeaders(buffer.subarray(0, headerEnd).toString());
+      buffer = buffer.subarray(headerEnd + HEADER_BLOCK_END.length);
+      writer = await onPart(part);
+      state = "body";
+    }
+  };
+  for await (const chunk of source) {
+    if (done) {
+      continue;
+    }
+    buffer = buffer.length === 0 ? Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength) : Buffer.concat([buffer, chunk]);
+    await process();
+  }
+  if (!done) {
+    throw new TypeError("Invalid multipart body: unexpected end of body");
+  }
+}
+function parsePartHeaders(block) {
+  let contentDisposition;
+  let contentType;
+  for (const line of block.split("\r\n")) {
+    const colon = line.indexOf(":");
+    if (colon === -1) {
+      throw new TypeError("Invalid multipart body: malformed part header");
+    }
+    const name2 = line.slice(0, colon).trim().toLowerCase();
+    if (name2 === "content-disposition") {
+      contentDisposition = line.slice(colon + 1).trim();
+    } else if (name2 === "content-type") {
+      contentType = line.slice(colon + 1).trim();
+    }
+  }
+  if (contentDisposition === void 0) {
+    throw new TypeError("Invalid multipart body: part is missing the content-disposition header");
+  }
+  const semicolon = contentDisposition.indexOf(";");
+  const dispositionType = (semicolon === -1 ? contentDisposition : contentDisposition.slice(0, semicolon)).trim().toLowerCase();
+  if (dispositionType !== "form-data") {
+    throw new TypeError("Invalid multipart body: content-disposition must be form-data");
+  }
+  const parameters = parseHeaderParameters(contentDisposition);
+  const name = parameters.get("name");
+  if (name === void 0) {
+    throw new TypeError("Invalid multipart body: content-disposition header is missing the name parameter");
+  }
+  const filename = parameters.get("filename");
+  return {
+    name: decodeContentDispositionParameter(name),
+    filename: filename === void 0 ? void 0 : decodeContentDispositionParameter(filename),
+    type: contentType
+  };
+}
+function decodeContentDispositionParameter(value) {
+  return value.replaceAll("%22", '"').replaceAll("%0D", "\r").replaceAll("%0A", "\n");
+}
+function parseHeaderParameters(header) {
+  const parameters = /* @__PURE__ */ new Map();
+  let index = header.indexOf(";");
+  while (index !== -1 && index < header.length) {
+    index++;
+    while (index < header.length && (header[index] === " " || header[index] === "	")) {
+      index++;
+    }
+    const equals = header.indexOf("=", index);
+    const nextSemicolon = header.indexOf(";", index);
+    if (equals === -1 || nextSemicolon !== -1 && nextSemicolon < equals) {
+      if (nextSemicolon === -1) {
+        break;
+      }
+      index = nextSemicolon;
+      continue;
+    }
+    const key = header.slice(index, equals).trim().toLowerCase();
+    index = equals + 1;
+    let value;
+    if (header[index] === '"') {
+      const closing = header.indexOf('"', index + 1);
+      value = closing === -1 ? header.slice(index + 1) : header.slice(index + 1, closing);
+      index = closing === -1 ? -1 : header.indexOf(";", closing + 1);
+    } else {
+      const semicolon = header.indexOf(";", index);
+      value = (semicolon === -1 ? header.slice(index) : header.slice(index, semicolon)).trim();
+      index = semicolon;
+    }
+    if (!parameters.has(key)) {
+      parameters.set(key, value);
+    }
+  }
+  return parameters;
+}
+
+class TmpFile extends File {
+  constructor(blob, path2, name, options) {
+    super([blob], name, options);
+    this.path = path2;
+  }
+}
+class TmpFileUploadHandlerPlugin {
+  name = "~tmp-file-upload";
+  /**
+   * Should parse the original request body instead of batched sub-requests.
+   */
+  after = ["~batch"];
+  /**
+   * Should run inside the limit and compression plugins, so spooling receives
+   * the size-checked, decompressed bytes.
+   */
+  before = ["~request-limit", "~request-compression"];
+  tmpDir;
+  maxBodySize;
+  constructor(options = {}) {
+    this.tmpDir = options.tmpDir ?? tmpdir();
+    this.maxBodySize = options.maxBodySize ?? {
+      memory: Number.POSITIVE_INFINITY,
+      file: Number.POSITIVE_INFINITY,
+      stream: Number.POSITIVE_INFINITY
+    };
+  }
+  init(options) {
+    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+      const tmpFiles = new RequestTmpFiles(this.tmpDir);
+      let cleanupDeferred = false;
+      try {
+        const result = await next({
+          ...interceptorOptions,
+          request: {
+            ...interceptorOptions.request,
+            resolveBody: (hint) => this.resolveBody(interceptorOptions.request, hint, tmpFiles)
+          }
+        });
+        if (result.matched && tmpFiles.inUse) {
+          const body = result.response.body;
+          if (isAsyncIteratorObject(body)) {
+            cleanupDeferred = true;
+            return {
+              matched: true,
+              response: {
+                ...result.response,
+                /**
+                 * @warning
+                 * Remember use `override` for AsyncIteratorObject to remain other special properties
+                 */
+                body: override(body, wrapAsyncIterator(body, { onFinish: () => tmpFiles.cleanup() }))
+              }
+            };
+          }
+          if (body instanceof ReadableStream) {
+            cleanupDeferred = true;
+            return {
+              matched: true,
+              response: {
+                ...result.response,
+                body: wrapReadableStream(body, { onFinish: () => tmpFiles.cleanup() })
+              }
+            };
+          }
+        }
+        return result;
+      } finally {
+        if (!cleanupDeferred) {
+          await tmpFiles.cleanup();
+        }
+      }
+    };
+    return {
+      ...options,
+      routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
+    };
+  }
+  async resolveBody(request, hint, tmpFiles) {
+    const resolvedHint = hint ?? resolveStandardBodyHint(request.headers);
+    if (resolvedHint === "form-data") {
+      return this.parseMultipartBody(request, tmpFiles);
+    }
+    if (resolvedHint === "file") {
+      return this.spoolFileBody(request, tmpFiles);
+    }
+    if (resolvedHint === "json" || resolvedHint === "url-search-params") {
+      return this.parseLimitedBody(request, hint, resolvedHint, this.maxBodySize.memory);
+    }
+    if (resolvedHint === "event-stream" || resolvedHint === "octet-stream") {
+      return this.parseLimitedBody(request, hint, resolvedHint, this.maxBodySize.stream);
+    }
+    return request.resolveBody(hint);
+  }
+  /**
+   * Enforces a size limit on a body the standard parser handles, counting the
+   * raw bytes before handing them back for regular parsing.
+   */
+  async parseLimitedBody(request, hint, resolvedHint, limit) {
+    if (limit === Number.POSITIVE_INFINITY) {
+      return request.resolveBody(hint);
+    }
+    assertContentLengthWithin(request.headers, limit);
+    const stream = await request.resolveBody("octet-stream");
+    if (!(stream instanceof ReadableStream)) {
+      return stream;
+    }
+    const response = new Response(limitStream(stream, limit), {
+      headers: toFetchHeaders(request.headers)
+    });
+    return toStandardBody(response, { hint: resolvedHint });
+  }
+  async spoolFileBody(request, tmpFiles) {
+    assertContentLengthWithin(request.headers, this.maxBodySize.file);
+    const stream = await request.resolveBody("octet-stream");
+    if (!(stream instanceof ReadableStream)) {
+      return stream;
+    }
+    const contentDisposition = flattenStandardHeader(request.headers["content-disposition"]);
+    const fileName = contentDisposition !== void 0 ? getFilenameFromContentDisposition(contentDisposition) : void 0;
+    const contentType = flattenStandardHeader(request.headers["content-type"]);
+    const limited = this.maxBodySize.file === Number.POSITIVE_INFINITY ? stream : limitStream(stream, this.maxBodySize.file);
+    const tmpPath = await tmpFiles.allocate();
+    for await (const chunk of limited) {
+      await tmpFiles.append(tmpPath, chunk);
+    }
+    return tmpFiles.seal(tmpPath, fileName ?? "blob", contentType ?? "");
+  }
+  async parseMultipartBody(request, tmpFiles) {
+    const contentType = flattenStandardHeader(request.headers["content-type"]);
+    const boundary = contentType === void 0 ? void 0 : parseHeaderParameters(contentType).get("boundary");
+    if (boundary === void 0 || boundary === "") {
+      throw new TypeError("Invalid multipart body: content-type header is missing the boundary parameter");
+    }
+    const totalLimit = this.maxBodySize.memory + this.maxBodySize.file;
+    assertContentLengthWithin(request.headers, totalLimit);
+    const stream = await request.resolveBody("octet-stream");
+    if (!(stream instanceof ReadableStream)) {
+      return stream;
+    }
+    const limited = totalLimit === Number.POSITIVE_INFINITY ? stream : limitStream(stream, totalLimit);
+    const form = new FormData();
+    let memoryUsed = 0;
+    let fileUsed = 0;
+    await parseMultipart(limited, boundary, (part) => {
+      const name = part.name;
+      if (part.filename === void 0) {
+        const chunks = [];
+        return {
+          write: (chunk) => {
+            memoryUsed += chunk.length;
+            if (memoryUsed > this.maxBodySize.memory) {
+              throw new ORPCError("PAYLOAD_TOO_LARGE");
+            }
+            chunks.push(Buffer.from(chunk));
+          },
+          end: () => {
+            form.append(name, Buffer.concat(chunks).toString());
+          }
+        };
+      }
+      const filename = part.filename;
+      const type = part.type ?? "text/plain";
+      let tmpPath;
+      return {
+        write: async (chunk) => {
+          fileUsed += chunk.length;
+          if (fileUsed > this.maxBodySize.file) {
+            throw new ORPCError("PAYLOAD_TOO_LARGE");
+          }
+          tmpPath ??= await tmpFiles.allocate();
+          await tmpFiles.append(tmpPath, chunk);
+        },
+        end: async () => {
+          tmpPath ??= await tmpFiles.allocate();
+          form.append(name, await tmpFiles.seal(tmpPath, filename, type));
+        }
+      };
+    });
+    return form;
+  }
+}
+function assertContentLengthWithin(headers, limit) {
+  const contentLength = Number(flattenStandardHeader(headers["content-length"]));
+  if (Number.isFinite(contentLength) && contentLength > limit) {
+    throw new ORPCError("PAYLOAD_TOO_LARGE");
+  }
+}
+function limitStream(stream, limit) {
+  let total = 0;
+  return stream.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      total += chunk.byteLength;
+      if (total > limit) {
+        controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+        return;
+      }
+      controller.enqueue(chunk);
+    }
+  }));
+}
+const EMPTY_CHUNK = new Uint8Array(0);
+class RequestTmpFiles {
+  constructor(tmpDir) {
+    this.tmpDir = tmpDir;
+  }
+  dir;
+  count = 0;
+  get inUse() {
+    return this.dir !== void 0;
+  }
+  async allocate() {
+    try {
+      this.dir ??= mkdtemp(path.join(this.tmpDir, "orpc-upload-"));
+      return path.join(await this.dir, String(this.count++));
+    } catch (cause) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", { cause });
+    }
+  }
+  async append(tmpPath, chunk) {
+    try {
+      await appendFile(tmpPath, chunk);
+    } catch (cause) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", { cause });
+    }
+  }
+  async seal(tmpPath, name, type) {
+    try {
+      await appendFile(tmpPath, EMPTY_CHUNK);
+      return new TmpFile(await openAsBlob(tmpPath), tmpPath, name, { type });
+    } catch (cause) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", { cause });
+    }
+  }
+  async cleanup() {
+    if (this.dir !== void 0) {
+      try {
+        await rm(await this.dir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+
+export { StaticFileHandlerPlugin, TmpFile, TmpFileUploadHandlerPlugin };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/node",
   "type": "module",
-  "version": "2.0.0-beta.27",
+  "version": "2.0.0-beta.28",
   "license": "MIT",
   "funding": "https://github.com/sponsors/dinwwwh",
   "homepage": "https://orpc.dev",
@@ -27,13 +27,15 @@
     "dist"
   ],
   "dependencies": {
-    "@standardserver/core": "^0.7.1",
+    "@standardserver/core": "^0.8.0",
+    "@standardserver/fetch": "^0.8.0",
     "mime": "^4.1.0",
-    "@orpc/server": "2.0.0-beta.27",
-    "@orpc/shared": "2.0.0-beta.27"
+    "@orpc/server": "2.0.0-beta.28",
+    "@orpc/shared": "2.0.0-beta.28"
   },
   "devDependencies": {
-    "supertest": "^7.2.2"
+    "supertest": "^7.2.2",
+    "@orpc/client": "2.0.0-beta.28"
   },
   "scripts": {
     "build": "unbuild",