5 шокирующих фактов о том, почему Firefox отстаёт в поддержке `request.body` и как это решить уже сегодня

Вступление

Веб‑разработчики часто сталкиваются с тем, что «один браузер делает‑то, а другой — нет». На первый взгляд такие различия могут показаться мелочью, но в реальном проекте они способны превратить простую задачу в часы отладки и костыльных решений. Одним из самых раздражающих примеров стал вопрос о чтении request.body в API Fetch. Оказалось, что единственный крупный браузер, который до сих пор не поддерживает эту возможность, – это Firefox. Проблема существует уже более восьми лет, а её корни уходят в архитектурные решения движка Gecko и в то, как сообщество воспринимает стандарты.

Почему это важно? Потому что request.body позволяет получать «сырые» данные тела запроса, что критично для серверных прокси, аналитических сервисов и, конечно, для разработки современных одностраничных приложений. Если один из популярных браузеров отстаёт, разработчики вынуждены писать отдельный код‑обход для Firefox, что увеличивает размер проекта и снижает надёжность.

В конце вступления – небольшое японское хокку, которое, как ни странно, отлично отражает суть проблемы:

# Японское хокку (перевод):
# Тихий ветер —
# браузер ждёт, пока
# поток вернётся.

Пересказ Reddit‑поста своими словами

Автор оригинального поста в Reddit заметил, что в то время как почти все современные JavaScript‑окружения (включая новейшие Bun и Deno) позволяют получить доступ к request.body, Firefox остаётся единственным исключением. Он привёл ссылки на баг‑трекер Bugzilla (ID 1387483), где указано, что проблема фиксируется уже восемь лет, а также на страницу совместимости MDN, где явно указано отсутствие поддержки в Firefox.

В комментариях к посту пользователи высказали разные мнения: от критики «монокультуры» Chromium‑браузеров до технического объяснения, что Gecko (движок Firefox) требует «перезапускаемости» (rewindable) потоков, что усложняет реализацию.

Суть проблемы, хакерский подход и основные тенденции

• Техническая причина: Gecko ожидает, что поток запроса можно «перемотать» назад, чтобы прочитать его несколько раз. Реализация такой возможности требует значительных изменений в ядре движка.
• Стандартный статус: В спецификации WHATWG Fetch request.body уже давно объявлен частью API, но реализация в Firefox отстаёт.
• Тенденция монокультуры: Большинство современных браузеров базируются на Chromium, где данная функция реализована давно. Это создает давление на остальные движки, заставляя их «догонять».
• Хакерский обход: Разработчики используют полифиллы, промежуточные прокси‑серверы или просто отказываются от чтения тела в клиентском коде, перемещая логику на сервер.

Детальный разбор проблемы с разных сторон

1. Архитектурные ограничения Gecko

Gecko изначально проектировался как потоковый движок, где запросы обрабатывались «на лету». Чтобы добавить возможность «перемотки», необходимо хранить копию тела в памяти или во временном файле, что повышает нагрузку и усложняет управление ресурсами. Некоторые разработчики из Mozilla считают, что такие изменения могут нарушить производительность и безопасность.

2. Влияние на кросс‑браузерную совместимость

Если ваш проект использует fetch(request).then(r => r.body) без проверок, пользователи Firefox получат ошибку TypeError: r.body is undefined. Это приводит к падениям, особенно в SPA‑приложениях, где запросы к API часто отправляются из клиентского кода.

3. Экономический аспект

Большие компании (Google, Microsoft) вкладывают миллиарды в развитие Chromium, а Mozilla, будучи некоммерческой организацией, ограничена в ресурсах. Поэтому поддержка новых функций часто откладывается.

4. Социальный фактор – «монокультура»

Как отметил пользователь LessChen, многие разработчики ориентируются только на Chromium‑браузеры, игнорируя остальные. Это приводит к тому, что даже не стандартизованные функции становятся «де‑факто» стандартом.

Практические примеры и кейсы

Рассмотрим два типичных сценария, где отсутствие request.body в Firefox может стать проблемой.

Сценарий 1: Прокси‑сервер для логирования запросов

Вы пишете клиентское приложение, которое отправляет JSON‑payload на ваш сервер, а сервер, в свою очередь, проксирует запрос к стороннему API, одновременно записывая тело в лог. Если клиент использует request.clone().body, то в Firefox запрос не будет клонирован, и логирование сломается.

Сценарий 2: Валидация формы на клиенте

В некоторых проектах валидацию проводят дважды: сначала в браузере, затем на сервере. При отправке формы через fetch с method: "POST" и body: formData разработчик может захотеть прочитать request.body для предварительного анализа. В Firefox такой код бросит исключение.

Экспертные мнения из комментариев

«You mean that the mono‑culture around Chromium based browsers means that they implemented something [that isn’t even part of a standard] and now the rest of the world needs to follow suit? I wish for you 1000 users tomorrow using Internet Explorer 6.» — LessChen

LessChen указывает на опасность «доминирования» Chromium, когда даже экспериментальные функции становятся обязательными для остальных браузеров.

«Iirc this is because gecko expects request streams to be rewindable so it’s a sizable implementation lift.» — Somepotato

Somepotato даёт техническое объяснение: Gecko требует «перезапускаемости» потоков, что делает задачу сложной.

«I get your point but there’s Web Standards for a reason. Even if it is logical in this case, it’s kind of opening a Pandora’s box.» — mal73

mal73 подчёркивает важность соблюдения веб‑стандартов и предостерегает от «открытия Пандориной коробки», когда делаются «логические», но не стандартизованные решения.

Возможные решения и рекомендации

1. Проверка поддержки на раннем этапе. Используйте условный код:

   
   if ('body' in Request.prototype):
       # безопасно использовать request.body
   else:
       # fallback‑логика
   

2. Полифиллы. Существует небольшая библиотека fetch-body-polyfill, которая имитирует request.body через Response.clone(). Работает в большинстве браузеров, включая Firefox, но требует дополнительного кода.
3. Перенос логики на сервер. Вместо чтения тела в клиенте, отправляйте запросы без анализа, а делайте всё на сервере. Это устраняет проблему полностью.
4. Использование промежуточного прокси. Прокси‑сервер может «перехватывать» запрос, сохранять тело и передавать дальше, позволяя клиенту не зависеть от request.body.
5. Обратная связь в Mozilla. Открывайте баг‑репорты, добавляйте лайки и комментарии в Bugzilla. Чем больше голосов, тем быстрее будет рассмотрена проблема.

Прогноз развития

С учётом текущих тенденций можно ожидать следующее:

• К 2026 году Firefox, вероятно, реализует поддержку request.body, поскольку давление со стороны разработчиков и компаний‑клиентов будет расти.
• Появятся более надёжные полифиллы, которые станут частью стандартных библиотек (например, в whatwg-fetch).
• Веб‑сообщества начнут более активно отстаивать соблюдение стандартов, а не «доминирование» одной экосистемы.

Практический пример (моделирующий ситуацию)

Ниже представлен пример кода на Python, который имитирует работу клиентского скрипта, проверяющего наличие request.body, и в случае отсутствия – отправляет запрос через прокси‑сервер, где тело сохраняется в файл. Этот пример демонстрирует один из подходов к решению проблемы без изменения кода браузера.

import http.server
import socketserver
import urllib.parse
import json
import os

# Порт, на котором будет работать локальный прокси
PROXY_PORT = 8080
# Папка для сохранения тел запросов
LOG_DIR = "request_logs"
os.makedirs(LOG_DIR, exist_ok=True)

class ProxyHandler(http.server.BaseHTTPRequestHandler):
    """Обработчик запросов прокси‑сервера.
    
    Сохраняет тело POST‑запроса в файл и перенаправляет запрос
    к целевому URL, указав оригинальный путь.
    """
    def do_POST(self):
        # Читаем длину тела из заголовка
        content_length = int(self.headers.get('Content-Length', 0))
        body = self.rfile.read(content_length) if content_length else b''

        # Сохраняем тело в файл с уникальным именем
        log_path = os.path.join(LOG_DIR, f"{self.path.strip('/')}_log.json")
        with open(log_path, "wb") as f:
            f.write(body)

        # Перенаправляем запрос к оригинальному серверу
        target_url = self.headers.get('X-Target-URL')
        if not target_url:
            self.send_response(400)
            self.end_headers()
            self.wfile.write(b"Missing X-Target-URL header")
            return

        # Формируем запрос к целевому серверу
        parsed = urllib.parse.urlparse(target_url)
        conn = http.client.HTTPConnection(parsed.netloc)
        conn.request("POST", parsed.path, body, dict(self.headers))
        resp = conn.getresponse()

        # Возвращаем ответ клиенту
        self.send_response(resp.status)
        for header, value in resp.getheaders():
            self.send_header(header, value)
        self.end_headers()
        self.wfile.write(resp.read())

# Запускаем простой HTTP‑прокси
with socketserver.TCPServer(("", PROXY_PORT), ProxyHandler) as httpd:
    print(f"Proxy server listening on port {PROXY_PORT}")
    httpd.serve_forever()

В этом примере:

• Создаётся локальный HTTP‑прокси, который принимает POST‑запросы.
• Тело запроса сохраняется в каталог request_logs (это имитация доступа к request.body).
• Затем запрос перенаправляется к целевому серверу, указанному в заголовке X-Target-URL.
• Клиент получает оригинальный ответ, не замечая, что тело было «перехвачено».

Такой подход позволяет обойти отсутствие request.body в Firefox, переместив работу с телом на серверную часть.

Заключение

Отсутствие поддержки request.body в Firefox – яркий пример того, как технические решения, стандарты и рыночные силы взаимодействуют между собой. С одной стороны, архитектурные ограничения Gecko делают внедрение функции сложным; с другой – давление со стороны разработчиков и доминирование Chromium заставляют Mozilla «догонять». Пока проблема не решена, разработчикам придётся использовать полифиллы, прокси‑серверы или просто отказываться от чтения тела в клиентском коде.

Тем не менее, тенденция к унификации API и рост требований к кросс‑браузерной совместимости обещают, что в ближайшие годы Firefox наверстает упущенное. А пока каждый проект должен самостоятельно выбирать стратегию обхода, учитывая свои ресурсы и целевую аудиторию.