Can't parse JSON response exceeding 512 MB

[the-sun-will-rise-tomorrow]

Bug Description

When using fetch and .json() to fetch and parse a response whose body length exceeds 512 MB, Node throws "Cannot create a string longer than 0x1fffffe8 characters" (ERR_STRING_TOO_LONG).

Note that this happens even when no individual string inside the JSON value is long - the limit applies to the size of the entire response body.

Reproducible By

1. Create a 1GB JSON file:

   $ jq -nc '[range(1024 * 1024) | [[range(102) | "abcdefghij"] | add]] | add' > 1gb.json

2. Start an HTTP server serving the file:

   $ npx http-server

3. Try to fetch the file:

   fetch("http://127.0.0.1:8080/1gb.json")
       .then((response) => response.json())
       .then((data) => {
    	   console.log(data.length);
       })
       .catch((error) => {
    	   console.error(error);
       });

Expected Behavior

Ideally, the JSON response should be parsed as it is received, without being collected into a single buffer or string first, thus avoiding any Node string limits.

Logs & Screenshots

Above steps fail with:

Error: Cannot create a string longer than 0x1fffffe8 characters
    at TextDecoder.decode (node:internal/encoding:447:16)
    at utf8DecodeBytes (node:internal/deps/undici/undici:4863:34)
    at parseJSONFromBytes (node:internal/deps/undici/undici:5738:25)
    at successSteps (node:internal/deps/undici/undici:5719:27)
    at fullyReadBody (node:internal/deps/undici/undici:4609:9)
    at process.processTicksAndRejections (node:internal/process/task_queues:105:5)
    at async consumeBody (node:internal/deps/undici/undici:5728:7) {
  code: 'ERR_STRING_TOO_LONG'
}

Environment

Node v22.14.0 on NixOS (Linux)

Additional context

The error happens because the response is first collected into a buffer, then decoded into an UTF-8 string, and then parsed from this single string using JSON.parse:

undici/lib/web/fetch/body.js

Lines 493 to 499 in b1f45cf

	/**
	* @see https://infra.spec.whatwg.org/#parse-json-bytes-to-a-javascript-value
	* @param {Uint8Array} bytes
	*/
	function parseJSONFromBytes (bytes) {
	return JSON.parse(utf8DecodeBytes(bytes))
	}

Ideally, we would be using a streaming JSON parser, which can decode and parse the response body as it's being received. This should not only avoid any string length limitations, but also improve performance for large bodies, as parsing can happen in parallel to waiting for network traffic, thus avoiding a separate parsing step after the download finishes.

[metcoder95]

I'm unaware if the spec states wether or not to keep it in memory for a JSON representation (I imagine states the response.json should return a Promise that resolves into a JSON representation).

Nevertheless, you can already achieve that by using response.body which is a RedeableStream which allows you to hop a reader that you can use to parse per-chunk.

cc: @tsctx @KhafraDev

[the-sun-will-rise-tomorrow]

Nevertheless, you can already achieve that by using response.body which is a RedeableStream which allows you to hop a reader that you can use to parse per-chunk.

Thank you. The following seems to do the trick, for anyone looking for a work-around:

const { parser } = require("stream-json");
const Assembler = require("stream-json/Assembler.js");
const { Readable } = require("node:stream");

async function fetchStreamingJson(url) {
  const response = await fetch(url);

  if (!response.ok) {
    throw new Error(
      `HTTP error! status: ${response.status} ${response.statusText}`,
    );
  }

  if (!response.body) {
    throw new Error("Response body is null");
  }

  return new Promise((resolve, reject) => {
    const jsonParser = parser();
    const asm = Assembler.connectTo(jsonParser);

    asm.on("done", (assembler) => {
      // 'done' is emitted when the entire root JSON value has been assembled
      resolve(assembler.current);
    });

    // Convert fetch's web ReadableStream to Node Readable stream
    const body = Readable.fromWeb(response.body);

    // Pipe response body into the JSON token parser
    body.pipe(jsonParser);

    // Error handling for all parts of the pipeline
    body.on("error", (err) => {
      reject(err);
    });
    jsonParser.on("error", (err) => {
      // It's good practice to also destroy/unpipe the source stream if the parser fails
      body.unpipe(jsonParser); // or response.body.destroy();
      reject(err);
    });
    asm.on("error", (err) => {
      reject(err);
    });
  });
}

fetchStreamingJson("http://127.0.0.1:8080/1gb.json")
  .then((data) => {
    console.log(data.length);
  })
  .catch((error) => {
    console.error(error);
  });

[tsctx]

Streaming json parsing is beyond undici's scope. Users can readily use their own stream json parser via readablestream.
The specs state that the entire content should be loaded into memory, and JSON.parse should be called.

[the-sun-will-rise-tomorrow]

The specs state that the entire content should be loaded into memory, and JSON.parse should be called.

Thanks, then I think there's nothing that can be done here.

[Uzlopak]

I think this is valid.

[KhafraDev]

I think this is valid.

Why?

[mcollina]

@Uzlopak this is a limit of V8. There is literally nothing we can do in this project: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length.

[Uzlopak]

I created #4305 for further discussions.