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

Add get_dmmf_buffered(), read_dmmf_chunk(), and free_dmmf_buffer() to
prisma-schema-wasm. These allow the DMMF JSON to be returned as chunked
Uint8Array data instead of a single JS string, bypassing V8's hard limit
of ~536MB (0x1fffffe8 characters).

For schemas generating DMMF larger than ~536MB, the existing get_dmmf()
throws 'Cannot create a string longer than 0x1fffffe8 characters' because
wasm-bindgen converts the Rust String to a JS string. The new buffered API
keeps the JSON as bytes in WASM linear memory and lets JS read chunks as
Uint8Array (which has no such limit).

Changes:
- query-compiler/dmmf/src/lib.rs: add dmmf_json_bytes_from_validated_schema()
  using serde_json::to_vec() instead of to_string()
- 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 wasm_bindgen exports:
  - get_dmmf_buffered(params) -> byte count
  - read_dmmf_chunk(offset, length) -> Uint8Array
  - free_dmmf_buffer()

Tested with a 1,600+ model schema producing 571MB DMMF:
- Original get_dmmf: FAILS (V8 string limit)
- Buffered API: PASSES (35 chunks x 16MB, streamed successfully)

Fixes: prisma/prisma#29111

Author: chris-tophers

prisma-fmt/src/get_dmmf.rs

@@ -21,6 +21,19 @@ pub(crate) fn get_dmmf(params: &str) -> Result<String, String> {
     validate::run(params.prisma_schema, params.no_color).map(dmmf::dmmf_json_from_validated_schema)
 }
 
+/// Returns DMMF JSON as bytes instead of String to avoid V8 string length limit.
+/// See: https://github.com/prisma/prisma/issues/29111
+pub(crate) fn get_dmmf_bytes(params: &str) -> Result<Vec<u8>, String> {
+    let params: GetDmmfParams = match serde_json::from_str(params) {
+        Ok(params) => params,
+        Err(serde_err) => {
+            panic!("Failed to deserialize GetDmmfParams: {serde_err}");
+        }
+    };
+
+    validate::run(params.prisma_schema, params.no_color).map(dmmf::dmmf_json_bytes_from_validated_schema)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

prisma-fmt/src/lib.rs

@@ -303,6 +303,12 @@ pub fn get_dmmf(get_dmmf_params: String) -> Result<String, String> {
     get_dmmf::get_dmmf(&get_dmmf_params)
 }
 
+/// Returns DMMF JSON as bytes instead of String to avoid V8 string length limit.
+/// See: https://github.com/prisma/prisma/issues/29111
+pub fn get_dmmf_bytes(get_dmmf_params: String) -> Result<Vec<u8>, String> {
+    get_dmmf::get_dmmf_bytes(&get_dmmf_params)
+}
+
 pub fn get_datamodel(get_datamodel_params: String) -> Result<String, String> {
     get_datamodel::get_datamodel(&get_datamodel_params)
 }

prisma-schema-wasm/src/lib.rs

@@ -1,6 +1,13 @@
 use std::panic;
+use std::sync::Mutex;
 use wasm_bindgen::prelude::*;
 
+/// Global buffer for storing DMMF bytes when using the buffered API.
+/// This allows JS to read the DMMF in chunks via Uint8Array, bypassing
+/// V8's string length limit of ~536MB.
+/// See: https://github.com/prisma/prisma/issues/29111
+static DMMF_BUFFER: Mutex<Vec<u8>> = Mutex::new(Vec::new());
+
 #[wasm_bindgen]
 extern "C" {
     /// This function registers the reason for a Wasm panic via the
@@ -132,6 +139,46 @@ pub fn hover(schema_files: String, params: String) -> String {
     prisma_fmt::hover(schema_files, &params)
 }
 
+/// Serialize DMMF to an internal buffer and return the total byte count.
+/// Use `read_dmmf_chunk()` to read portions as Uint8Array, then `free_dmmf_buffer()` to release.
+///
+/// This bypasses V8's string length limit (~536MB / 0x1fffffe8 chars) by keeping the
+/// serialized JSON as bytes in WASM linear memory. The JS side reads chunks as Uint8Array
+/// (which has no V8 string limit) and can use a streaming JSON parser.
+///
+/// See: https://github.com/prisma/prisma/issues/29111
+#[wasm_bindgen]
+pub fn get_dmmf_buffered(params: String) -> Result<usize, JsError> {
+    register_panic_hook();
+    let bytes = prisma_fmt::get_dmmf_bytes(params).map_err(|e| JsError::new(&e))?;
+    let len = bytes.len();
+    let mut buf = DMMF_BUFFER.lock().unwrap();
+    *buf = bytes;
+    Ok(len)
+}
+
+/// Read a chunk of the DMMF buffer as Uint8Array.
+/// `offset` is the byte offset, `length` is the number of bytes to read.
+/// Returns a Vec<u8> which wasm-bindgen converts to Uint8Array on the JS side.
+#[wasm_bindgen]
+pub fn read_dmmf_chunk(offset: usize, length: usize) -> Result<Vec<u8>, JsError> {
+    register_panic_hook();
+    let buf = DMMF_BUFFER.lock().unwrap();
+    if offset >= buf.len() {
+        return Err(JsError::new("Offset beyond buffer length"));
+    }
+    let end = std::cmp::min(offset + length, buf.len());
+    Ok(buf[offset..end].to_vec())
+}
+
+/// Free the internal DMMF buffer. Call this after reading all chunks.
+#[wasm_bindgen]
+pub fn free_dmmf_buffer() {
+    register_panic_hook();
+    let mut buf = DMMF_BUFFER.lock().unwrap();
+    *buf = Vec::new();
+}
+
 /// Trigger a panic inside the wasm module. This is only useful in development for testing panic
 /// handling.
 #[wasm_bindgen]

query-compiler/dmmf/src/lib.rs

@@ -21,6 +21,16 @@ pub fn dmmf_json_from_validated_schema(schema: ValidatedSchema) -> String {
     serde_json::to_string(&dmmf).unwrap()
 }
 
+/// Returns DMMF JSON as bytes (Vec<u8>) instead of String.
+/// This avoids V8's string length limit (~536MB) when the DMMF is returned
+/// across the WASM-to-JS FFI boundary, since wasm-bindgen converts Vec<u8>
+/// to Uint8Array (which has no such limit).
+/// See: https://github.com/prisma/prisma/issues/29111
+pub fn dmmf_json_bytes_from_validated_schema(schema: ValidatedSchema) -> Vec<u8> {
+    let dmmf = from_precomputed_parts(&schema::build(Arc::new(schema), true));
+    serde_json::to_vec(&dmmf).unwrap()
+}
+
 pub fn dmmf_from_schema(schema: &str) -> DataModelMetaFormat {
     let schema = Arc::new(psl::parse_schema_without_extensions(schema).unwrap());
     from_precomputed_parts(&schema::build(schema, true))