use super::{emit_line, to_compact, to_document, Formatter, END_OF_STREAM_KEY, ROW_COUNT_KEY};
use crate::error::Result;
use crate::output::envelope::{Envelope, Row};
use serde_json::Value;
use std::io::Write;
#[derive(Debug, Clone, Copy)]
pub struct Ndjson;
impl Formatter for Ndjson {
fn name(&self) -> &'static str {
"ndjson"
}
fn write_envelope(&mut self, writer: &mut dyn Write, envelope: &Envelope) -> Result<()> {
let Some(key) = envelope.payload_array_key() else {
return emit_line(writer, &to_compact(envelope)?);
};
let mut emitted: u64 = 0;
if let Some(rows) = envelope.data.get(key).and_then(Value::as_array) {
for row in rows {
emit_line(writer, &to_compact(row)?)?;
emitted += 1;
}
}
let mut closing = envelope.clone();
if let Some(payload) = closing.data.as_object_mut() {
payload.remove(key);
}
emit_line(writer, &closing_record(&closing, emitted)?)
}
fn begin_stream(
&mut self,
_writer: &mut dyn Write,
_head: &Envelope,
_columns: &[String],
) -> Result<()> {
Ok(())
}
fn write_row(&mut self, writer: &mut dyn Write, row: &Row, line: &mut String) -> Result<()> {
line.clear();
line.push_str(&to_compact(row)?);
emit_line(writer, line)
}
fn end_stream(
&mut self,
writer: &mut dyn Write,
tail: &Envelope,
emitted: u64,
gaps: &[crate::output::envelope::Gap],
applied: Option<&crate::output::envelope::Applied>,
) -> Result<()> {
if applied.is_some_and(|applied| applied.output_truncated) {
return Ok(());
}
let mut closing = tail.clone();
closing.gaps = gaps.to_vec();
emit_line(writer, &closing_record(&closing, emitted)?)
}
}
fn closing_record(closing: &Envelope, emitted: u64) -> Result<String> {
let mut document = to_document(closing)?;
document.insert(END_OF_STREAM_KEY.to_owned(), Value::Bool(true));
document.insert(ROW_COUNT_KEY.to_owned(), Value::from(emitted));
to_compact(&document)
}
#[cfg(test)]
mod tests {
use super::super::tests::{
bare_tail, sample_row, stream_through, stream_through_from, tail_from_a_destination,
};
use super::*;
#[test]
fn the_closing_record_names_the_command_and_the_destination() {
let rows = vec![sample_row("alpha", 1)];
let text = stream_through_from(&mut Ndjson, &rows, &tail_from_a_destination());
let last = text.lines().next_back().expect("a last line");
let parsed: serde_json::Value = serde_json::from_str(last).expect("parses");
assert_eq!(parsed["command"], "query run");
assert_eq!(parsed["target_resolved"]["host"], "192.0.2.10");
assert_eq!(parsed["target_resolved"]["database"], "loja");
assert_eq!(parsed[END_OF_STREAM_KEY], true);
assert_eq!(parsed[ROW_COUNT_KEY], 1);
}
#[test]
fn every_row_is_a_document_of_its_own() {
let rows = vec![sample_row("alpha", 1), sample_row("beta", 2)];
let text = stream_through(&mut Ndjson, &rows);
let lines: Vec<&str> = text.lines().collect();
assert_eq!(lines.len(), 3, "two rows and the closing record");
for line in &lines {
let _: serde_json::Value = serde_json::from_str(line).expect("each line parses alone");
}
}
#[test]
fn the_last_line_declares_the_count() {
let rows = vec![
sample_row("alpha", 1),
sample_row("beta", 2),
sample_row("gamma", 3),
];
let text = stream_through(&mut Ndjson, &rows);
let last = text.lines().next_back().expect("a last line");
let parsed: serde_json::Value = serde_json::from_str(last).expect("parses");
assert_eq!(parsed[END_OF_STREAM_KEY], true);
assert_eq!(parsed[ROW_COUNT_KEY], 3);
}
#[test]
fn a_flow_that_was_cut_carries_no_closing_record() {
let mut out = Vec::new();
let mut formatter = Ndjson;
formatter
.begin_stream(&mut out, &bare_tail(), &[])
.expect("opens");
let mut line = String::new();
formatter
.write_row(&mut out, &sample_row("alpha", 1), &mut line)
.expect("writes");
let text = String::from_utf8(out).expect("utf8");
assert!(
!text.contains(END_OF_STREAM_KEY),
"a cut flow must not look whole"
);
}
#[test]
fn every_line_ends_with_a_single_line_feed() {
let text = stream_through(&mut Ndjson, &[sample_row("alpha", 1)]);
assert!(!text.contains('\r'), "no platform convention may leak in");
assert!(text.ends_with('\n'));
}
}