const Busboy = require('busboy');
const { storeFile } = require('./storage');
function parseMultipart(req, { maxFileSize = 20 * 1024 * 1024 } = {}) {
return new Promise((resolve, reject) => {
const busboy = Busboy({
headers: req.headers,
limits: { fileSize: maxFileSize, files: 10 },
});
const fields = {};
const files = [];
const pending = [];
busboy.on('field', (name, value) => {
fields[name] = value;
});
busboy.on('file', (name, stream, info) => {
const { sink, meta } = storeFile(info);
let truncated = false;
stream.on('limit', () => {
truncated = true;
stream.resume(); // drain remaining bytes so parsing can complete
});
const done = new Promise((res, rej) => {
sink.on('finish', () => res({ ...meta, field: name, truncated }));
sink.on('error', rej);
stream.on('error', rej);
});
pending.push(done);
stream.pipe(sink);
});
busboy.on('error', reject);
busboy.on('close', () => {
Promise.all(pending)
.then((stored) => resolve({ fields, files: stored }))
.catch(reject);
});
req.pipe(busboy);
});
}
module.exports = { parseMultipart };
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const UPLOAD_DIR = path.join(__dirname, 'uploads');
fs.mkdirSync(UPLOAD_DIR, { recursive: true });
function storeFile(info) {
const id = crypto.randomUUID();
const ext = path.extname(info.filename || '').slice(0, 12);
const storedName = `${id}${ext}`;
const target = path.join(UPLOAD_DIR, storedName);
const sink = fs.createWriteStream(target);
const meta = {
id,
storedName,
originalName: info.filename,
mimeType: info.mimeType,
path: target,
};
return { sink, meta };
}
module.exports = { storeFile, UPLOAD_DIR };
const express = require('express');
const { parseMultipart } = require('./multipartParser');
const router = express.Router();
router.post('/uploads', async (req, res) => {
const contentType = req.headers['content-type'] || '';
if (!contentType.startsWith('multipart/form-data')) {
return res.status(415).json({ error: 'expected multipart/form-data' });
}
try {
const { fields, files } = await parseMultipart(req, {
maxFileSize: 25 * 1024 * 1024,
});
const rejected = files.filter((f) => f.truncated);
if (rejected.length) {
return res.status(400).json({
error: 'one or more files exceeded the size limit',
files: rejected.map((f) => f.originalName),
});
}
res.status(201).json({
fields,
files: files.map(({ path, ...rest }) => rest),
});
} catch (err) {
res.status(400).json({ error: 'malformed upload', detail: err.message });
}
});
module.exports = router;
This snippet shows how to accept file uploads without buffering the entire request into memory by consuming the incoming request stream in chunks and parsing it on the fly. Multipart bodies interleave form fields and file bytes separated by a boundary token declared in the Content-Type header. Naively collecting the whole body into a Buffer scales poorly and lets a client exhaust memory with a large upload, so the parser reads the socket incrementally instead.
In multipartParser.js, parseMultipart wraps the callback-driven busboy library in a Promise. Busboy is itself a Writable stream, so the request is piped into it and it emits a file event per file part and a field event per scalar field. Rather than accumulating file bytes, each file stream is piped straight into a sink returned by storeFile, preserving backpressure end to end: if storage is slow, the pipe pauses reading from the socket automatically. The limits option enforces a fileSize cap; when exceeded busboy emits limit on the file stream, and the code marks the upload truncated and resumes the stream so parsing can finish cleanly instead of hanging. The close event resolves once every part has drained, and any stream error rejects the promise.
In storage.js, storeFile creates a crypto.randomUUID()-named write target under an uploads directory and returns both the WritableStream and the eventual metadata. Using createWriteStream keeps bytes flowing to disk in chunks that mirror what arrives on the wire.
In uploadRoute.js, an Express handler validates the content-type up front, delegates to parseMultipart, and responds with the collected field values and stored file descriptors. Errors from oversized or malformed uploads surface as a 400.
The key trade-off is complexity for safety: event-driven streaming code is harder to reason about than reading req.body, but it bounds memory regardless of upload size and applies natural backpressure. A common pitfall is forgetting to consume or resume a file stream that hit its limit, which stalls the whole parse; the handler here always drains. This pattern is the right choice whenever uploads may be large, concurrent, or untrusted.
Related snips
export interface RetryOptions {
retries: number;
baseMs: number;
maxMs: number;
signal?: AbortSignal;
onRetry?: (attempt: number, delay: number, err: unknown) => void;Exponential backoff with jitter for retries
package dbutil
import (
"context"
"github.com/jackc/pgconn"Retry Postgres serialization failures with bounded attempts
require "csv"
class PeopleCsvStream
include Enumerable
HEADERS = %w[id full_name email signed_up_at plan].freezeResilient CSV Export as a Streamed Response
export type Settled<R> =
| { status: 'fulfilled'; value: R }
| { status: 'rejected'; reason: unknown };
export interface ConcurrencyOptions {
limit: number;Simple concurrency limiter for batch operations
package deps
import (
"net"
"net/http"
"time"HTTP client tuned for production: timeouts, transport, and connection reuse
# Installation
# rails active_storage:install
# rails db:migrate
# config/storage.yml
local:ActiveStorage for file uploads and attachments
Share this code
Here's the card — post it anywhere.
