fix: add streaming DMMF binary command to bypass V8 and WASM limits

Add a `get-dmmf` subcommand to the prisma-fmt CLI that streams DMMF JSON
directly to stdout via serde_json::to_writer(). This approach has no
memory ceiling — unlike WASM (limited to ~4GB linear memory), the native
binary can stream arbitrarily large DMMF with only 1x peak memory
(the in-memory DMMF struct, no serialized buffer).

Changes:
- dmmf crate: add dmmf_json_to_writer() using serde_json::to_writer()
- prisma-fmt: add get_dmmf_to_writer() that validates + streams
- prisma-fmt: export get_dmmf_to_writer() from lib.rs
- prisma-fmt: add GetDmmf CLI variant, reads stdin params, streams to stdout

Alternative approach to the buffered WASM API in prisma#5757.
Fixes: prisma/prisma#29111

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: chris-tophers

prisma-fmt/src/get_dmmf.rs

@@ -21,6 +21,21 @@ 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)
 }
 
+/// Stream DMMF JSON directly to a writer. No intermediate String/Vec allocation.
+/// This enables the CLI binary to pipe DMMF to stdout without hitting any memory limit.
+/// See: https://github.com/prisma/prisma/issues/29111
+pub(crate) fn get_dmmf_to_writer<W: std::io::Write>(params: &str, writer: W) -> Result<(), 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)
+        .and_then(|schema| dmmf::dmmf_json_to_writer(schema, writer).map_err(|e| e.to_string()))
+}
+
 #[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)
 }
 
+/// Stream DMMF JSON directly to a writer. No intermediate allocation.
+/// See: https://github.com/prisma/prisma/issues/29111
+pub fn get_dmmf_to_writer<W: std::io::Write>(get_dmmf_params: &str, writer: W) -> Result<(), String> {
+    get_dmmf::get_dmmf_to_writer(get_dmmf_params, writer)
+}
+
 pub fn get_datamodel(get_datamodel_params: String) -> Result<String, String> {
     get_datamodel::get_datamodel(&get_datamodel_params)
 }

prisma-fmt/src/main.rs

@@ -41,6 +41,11 @@ pub enum FmtOpts {
     PreviewFeatures,
     /// Artificially panic (for testing the CLI)
     DebugPanic,
+    /// Generate DMMF JSON from schema, streaming to stdout.
+    /// Reads JSON params from stdin, streams DMMF to stdout via serde_json::to_writer().
+    /// This has no memory ceiling — unlike WASM, the binary can stream arbitrarily large DMMF.
+    /// See: https://github.com/prisma/prisma/issues/29111
+    GetDmmf,
 }
 
 fn main() {
@@ -51,6 +56,18 @@ fn main() {
         FmtOpts::NativeTypes => plug(native::run),
         FmtOpts::ReferentialActions => plug(actions::run),
         FmtOpts::PreviewFeatures => plug(|_s| preview::run()),
+        FmtOpts::GetDmmf => {
+            let mut input = String::new();
+            io::stdin()
+                .read_to_string(&mut input)
+                .expect("Unable to read from stdin.");
+            let stdout = io::stdout();
+            let writer = io::BufWriter::new(stdout.lock());
+            if let Err(e) = prisma_fmt::get_dmmf_to_writer(&input, writer) {
+                eprintln!("{e}");
+                std::process::exit(1);
+            }
+        }
     }
 }
 

query-compiler/dmmf/src/lib.rs

@@ -21,6 +21,15 @@ pub fn dmmf_json_from_validated_schema(schema: ValidatedSchema) -> String {
     serde_json::to_string(&dmmf).unwrap()
 }
 
+/// Serialize DMMF JSON directly to a writer without building an intermediate String or Vec.
+/// Uses serde_json::to_writer() which streams JSON tokens incrementally.
+/// This avoids both V8's string limit and WASM memory limits.
+/// See: https://github.com/prisma/prisma/issues/29111
+pub fn dmmf_json_to_writer<W: std::io::Write>(schema: ValidatedSchema, writer: W) -> serde_json::Result<()> {
+    let dmmf = from_precomputed_parts(&schema::build(Arc::new(schema), true));
+    serde_json::to_writer(writer, &dmmf)
+}
+
 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))