fix: add buffered DMMF API to bypass V8 string length limit

[chris-tophers]

Summary

Adds three new wasm_bindgen exports to prisma-schema-wasm that allow DMMF JSON to be returned as chunked Uint8Array data instead of a single JS string, bypassing V8's hard string length limit of 0x1fffffe8 characters (~536MB).

• get_dmmf_buffered(params) -> usize — serializes DMMF to an internal buffer using serde_json::to_vec(), returns total byte count
• read_dmmf_chunk(offset, length) -> Vec<u8> — returns a chunk as Uint8Array (no V8 string limit)
• free_dmmf_buffer() — releases the internal buffer

The existing get_dmmf() is unchanged for backward compatibility.

Root Cause

dmmf_json_from_validated_schema() in query-compiler/dmmf/src/lib.rs uses serde_json::to_string(), producing a single Rust String. When wasm-bindgen converts this to a JS string across the WASM FFI boundary, V8 rejects it if the string exceeds 0x1fffffe8 characters. No Node.js flags can change this limit — it's a V8 engine constant.

Changes

File	Change
query-compiler/dmmf/src/lib.rs	Add dmmf_json_bytes_from_validated_schema() using serde_json::to_vec()
prisma-fmt/src/get_dmmf.rs	Add get_dmmf_bytes() returning Vec<u8>
prisma-fmt/src/lib.rs	Export get_dmmf_bytes()
prisma-schema-wasm/src/lib.rs	Add 3 new wasm_bindgen exports with Mutex<Vec<u8>> buffer

+76 lines, 4 files changed. No existing behavior modified.

Test Results

Tested with a production schema (1,600+ models, 1,100+ enums, 111K lines):

Test	Result	Details
Original get_dmmf()	FAILS	Cannot create a string longer than 0x1fffffe8 characters
get_dmmf_buffered() + chunked read	PASSES	571MB DMMF, 35 chunks x 16MB each
Streaming JSON parse of chunks	PASSES	Full parse completed in ~21s

Limitations

This fix addresses the V8 string length limit but has an upper bound: WASM32 linear memory is capped at ~4GB. For schemas producing DMMF larger than ~4GB, the buffered approach would
also fail. An alternative for extreme cases would be using the native schema engine binary path (which streams over stdio with no memory limit), but the buffered API should cover schemas
well into the tens of thousands of models.

Companion Change Required

The TypeScript side (prisma/prisma — getDmmfWasm in packages/internals) needs to detect the V8 string limit error and fall back to the buffered API with a streaming JSON parser.
Both this PR and the companion TypeScript PR are required for a complete fix. We will submit the companion PR to prisma/prisma as well.

Fixes: prisma/prisma#29111

Summary by CodeRabbit

• New Features
  • Added new DMMF API supporting chunked data reading from JavaScript applications
  • Implemented buffer-based retrieval mechanism enabling efficient access to schema metadata
  • New functionality includes size checking methods and safe bounds-checked reading operations
  • Improved memory efficiency for large schema operations

[CLAassistant]

All committers have signed the CLA.

[chris-tophers]

Alternative approach submitted: #5761

I've also submitted a companion binary streaming approach as an alternative to this WASM buffered API. The key difference:

Aspect	WASM Buffered (this PR)	Binary Streaming (#5761)
Memory ceiling	~1.5-2GB (WASM32 limit)	Unlimited
Peak memory	2x DMMF (struct + buffer)	1x (streams, no buffer)
New binary	No	Yes (prisma-fmt)
Rust complexity	Medium (Mutex, chunks)	Low (to_writer + CLI cmd)

The binary approach uses serde_json::to_writer() to stream DMMF JSON directly to stdout from a native prisma-fmt get-dmmf subcommand — no intermediate String or Vec<u8> allocation. The TypeScript side spawns the binary and stream-parses stdout via @streamparser/json.

Both approaches solve the immediate V8 string limit issue. The Prisma team can choose whichever fits best, or combine both (WASM buffered as primary fallback, binary streaming as secondary for schemas that exceed WASM32's ~4GB limit).

Companion TypeScript PRs:

• WASM buffered: fix: fall back to buffered DMMF API when V8 string limit is hit prisma#29137
• Binary streaming: fix: add binary streaming fallback for DMMF exceeding V8 string limit prisma#29149

[jacek-prisma]

Thanks for submitting the PR! I think we can merge this change (along with the prisma part), conditional on my comment getting resolved

[codspeed-hq]

Merging this PR will not alter performance

✅ 11 untouched benchmarks
⏩ 11 skipped benchmarks¹

---

_{Comparing chris-tophers:fix/dmmf-v8-string-limit (ee8c8a0) with main (280c870)}

Footnotes

1. 11 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

[coderabbitai]

Walkthrough

Added a byte-returning DMMF function in prisma-fmt and introduced a DmmfBuffer struct in prisma-schema-wasm that enables chunked reading of DMMF data from WASM memory, avoiding V8 string length constraints for large schemas.

Changes

Cohort / File(s)	Summary
DMMF Byte Conversion prisma-fmt/src/lib.rs	Added get_dmmf_bytes() function that converts the existing DMMF string result into a Vec<u8> for efficient byte-level handling.
WASM Buffered DMMF API prisma-schema-wasm/src/lib.rs	Introduced DmmfBuffer struct with len(), is_empty(), and read_chunk(offset, length) methods for streaming DMMF reads from WASM memory. Added get_dmmf_buffered() function that delegates to prisma-fmt's byte conversion and exposes the buffer for chunked access by JavaScript, with panic hook registration.

Possibly related issues

No additional issues to link. The changes directly implement the WASM buffered approach proposed in the linked issue #29111 for handling V8 string length limits on large schema DMMF generation.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'fix: add buffered DMMF API to bypass V8 string length limit' directly and clearly describes the main change—adding a buffered API to resolve V8 string limits.
Linked Issues check	✅ Passed	The PR fully addresses issue #29111 objectives: prevents DMMF failures by adding a buffered API with chunked reads to bypass V8's JS string length limit, enabling large schema handling.
Out of Scope Changes check	✅ Passed	All changes directly support the buffered DMMF API implementation: get_dmmf_bytes() in prisma-fmt and the handle-based DmmfBuffer with read_chunk() in prisma-schema-wasm are narrowly scoped.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment

📝 Coding Plan

• Generate coding plan for human review comments

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

Tip

CodeRabbit can use OpenGrep to find security vulnerabilities and bugs across 17+ programming languages.

OpenGrep is compatible with Semgrep configurations. Add an opengrep.yml or semgrep.yml configuration file to your project to enable OpenGrep analysis.

[coderabbitai]

Actionable comments posted: 1

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: ASSERTIVE

Plan: Pro

Run ID: b363e07b-5485-4d0c-985d-6eece4c370c4

📥 Commits

Reviewing files that changed from the base of the PR and between abbfa42 and 0ff6e01.

📒 Files selected for processing (2)

• prisma-fmt/src/lib.rs
• prisma-schema-wasm/src/lib.rs