1mod impossible;
2mod map_key;
3
4use bytes::{BufMut, Bytes, BytesMut};
5use futures::stream::Stream;
6use map_key::MapKeySerializer;
7use serde::de::DeserializeOwned;
8use serde::ser::{self, Serialize, SerializeSeq};
9use serde_json::Value;
10
11fn to_camel_case(s: &str) -> String {
12 let mut result = String::with_capacity(s.len());
13 let mut capitalize_next = false;
14
15 for ch in s.chars() {
16 if ch == '_' {
17 capitalize_next = true;
18 } else if capitalize_next {
19 result.push(ch.to_ascii_uppercase());
20 capitalize_next = false;
21 } else {
22 result.push(ch);
23 }
24 }
25
26 result
27}
28
29fn to_snake_case(s: &str) -> String {
30 let mut result = String::with_capacity(s.len() + 4);
31
32 for (i, ch) in s.chars().enumerate() {
33 if ch.is_ascii_uppercase() {
34 if i > 0 {
35 result.push('_');
36 }
37 result.push(ch.to_ascii_lowercase());
38 } else {
39 result.push(ch);
40 }
41 }
42
43 result
44}
45
46fn transform_keys_to_snake_case(value: Value) -> Value {
47 match value {
48 Value::Object(map) => {
49 if map.len() == 1
50 && let Some(variant) = map.get("t").and_then(|v| v.as_str())
51 {
52 return Value::String(to_snake_case(variant));
53 }
54 let new_map = map
55 .into_iter()
56 .map(|(k, v)| (to_snake_case(&k), transform_keys_to_snake_case(v)))
57 .collect();
58 Value::Object(new_map)
59 }
60 Value::Array(arr) => {
61 Value::Array(arr.into_iter().map(transform_keys_to_snake_case).collect())
62 }
63 other => other,
64 }
65}
66
67pub fn from_slice<T: DeserializeOwned>(slice: &[u8]) -> Result<T, serde_json::Error> {
68 let value: Value = serde_json::from_slice(slice)?;
69 let transformed = transform_keys_to_snake_case(value);
70 serde_json::from_value(transformed)
71}
72
73pub fn from_str<T: DeserializeOwned>(s: &str) -> Result<T, serde_json::Error> {
74 let value: Value = serde_json::from_str(s)?;
75 let transformed = transform_keys_to_snake_case(value);
76 serde_json::from_value(transformed)
77}
78
79pub fn to_stream<T: Serialize + ?Sized>(value: &T) -> impl Stream<Item = Bytes> + use<T> {
80 let mut ser = Serializer::new();
81 value.serialize(&mut ser).unwrap();
82 ser.into_stream()
83}
84
85pub fn to_vec<T: Serialize + ?Sized>(value: &T) -> Vec<u8> {
86 let mut ser = Serializer::new();
87 value.serialize(&mut ser).unwrap();
88 ser.into_vec()
89}
90
91const CHUNK_SIZE: usize = 8192;
92
93struct Serializer {
94 completed_chunks: Vec<Bytes>,
95 current_buffer: BytesMut,
96}
97
98impl Default for Serializer {
99 fn default() -> Self {
100 Self::new()
101 }
102}
103
104impl Serializer {
105 fn new() -> Self {
106 Serializer {
107 completed_chunks: Vec::new(),
108 current_buffer: BytesMut::with_capacity(CHUNK_SIZE),
109 }
110 }
111
112 fn write_bytes(&mut self, mut bytes: &[u8]) {
113 while !bytes.is_empty() {
114 let remaining = CHUNK_SIZE - self.current_buffer.len();
115 let write_len = remaining.min(bytes.len());
116 self.current_buffer.put(&bytes[..write_len]);
117 bytes = &bytes[write_len..];
118 if self.current_buffer.len() == CHUNK_SIZE {
119 let chunk = self.current_buffer.split().freeze();
120 self.current_buffer.reserve(CHUNK_SIZE);
121 self.completed_chunks.push(chunk);
122 }
123 }
124 }
125
126 fn write_string_value(&mut self, value: &str) {
127 self.write_bytes(b"\"");
128 let bytes = value.as_bytes();
129 let mut start = 0;
130
131 for (i, &byte) in bytes.iter().enumerate() {
132 let escape = match byte {
133 b'"' => Some("\\\""),
134 b'\\' => Some("\\\\"),
135 b'/' => Some("\\/"),
136 b'\x08' => Some("\\b"),
137 b'\x0c' => Some("\\f"),
138 b'\n' => Some("\\n"),
139 b'\r' => Some("\\r"),
140 b'\t' => Some("\\t"),
141 b @ 0..=0x1f => {
142 if start < i {
143 self.write_bytes(&bytes[start..i]);
144 }
145 static CONTROL: &[u8] = b"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\u000c\\r\\u000e\\u000f\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f";
146 let ctrl_start = (b as usize) * 6;
147 self.write_bytes(&CONTROL[ctrl_start..ctrl_start + 6]);
148 start = i + 1;
149 None
150 }
151 _ => None,
152 };
153
154 if let Some(esc) = escape {
155 if start < i {
156 self.write_bytes(&bytes[start..i]);
157 }
158 self.write_bytes(esc.as_bytes());
159 start = i + 1;
160 }
161 }
162
163 if start != bytes.len() {
164 self.write_bytes(&bytes[start..]);
165 }
166
167 self.write_bytes(b"\"");
168 }
169
170 fn write(&mut self, value: impl ToString) {
171 self.write_bytes(value.to_string().as_bytes());
172 }
173
174 fn into_stream(mut self) -> impl Stream<Item = Bytes> {
175 if !self.current_buffer.is_empty() {
176 self.completed_chunks.push(self.current_buffer.freeze());
177 }
178 futures::stream::iter(self.completed_chunks)
179 }
180
181 fn into_vec(mut self) -> Vec<u8> {
182 if !self.current_buffer.is_empty() {
183 self.completed_chunks.push(self.current_buffer.freeze());
184 }
185 self.completed_chunks
186 .into_iter()
187 .flat_map(|b| b.to_vec())
188 .collect()
189 }
190}
191
192#[derive(Debug)]
193enum State {
194 Empty,
195 First,
196 Rest,
197}
198
199enum Compound<'a> {
200 Seq {
201 ser: &'a mut Serializer,
202 state: State,
203 },
204 Tuple {
205 ser: &'a mut Serializer,
206 state: State,
207 },
208 TupleStruct {
209 ser: &'a mut Serializer,
210 state: State,
211 },
212 Map {
213 ser: &'a mut Serializer,
214 state: State,
215 },
216 Struct {
217 ser: &'a mut Serializer,
218 state: State,
219 },
220 TupleVariant {
221 ser: &'a mut Serializer,
222 state: State,
223 },
224 StructVariant {
225 ser: &'a mut Serializer,
226 state: State,
227 },
228}
229
230impl<'a> ser::SerializeSeq for Compound<'a> {
231 type Ok = ();
232 type Error = serde::de::value::Error;
233
234 fn serialize_element<T: Serialize + ?Sized>(
235 &mut self,
236 value: &T,
237 ) -> Result<Self::Ok, Self::Error> {
238 let state = match self {
239 Compound::Seq { state, .. } => state,
240 _ => unreachable!(),
241 };
242
243 match state {
244 State::Empty => {
245 *state = State::First;
246 }
247 State::First => {
248 *state = State::Rest;
249 }
250 State::Rest => {}
251 }
252
253 let (ser, state) = match self {
254 Compound::Seq { ser, state } => (ser, state),
255 _ => unreachable!(),
256 };
257
258 if !matches!(state, State::First) {
259 ser.write_bytes(b",");
260 }
261 value.serialize(&mut **ser)?;
262 Ok(())
263 }
264
265 fn end(self) -> Result<Self::Ok, Self::Error> {
266 let Compound::Seq { ser, .. } = self else {
267 unreachable!()
268 };
269 ser.write_bytes(b"]");
270 Ok(())
271 }
272}
273
274impl<'a> ser::SerializeTuple for Compound<'a> {
275 type Ok = ();
276 type Error = serde::de::value::Error;
277
278 fn serialize_element<T: Serialize + ?Sized>(
279 &mut self,
280 value: &T,
281 ) -> Result<Self::Ok, Self::Error> {
282 let state = match self {
283 Compound::Tuple { state, .. } => state,
284 _ => unreachable!(),
285 };
286
287 match state {
288 State::Empty => {
289 *state = State::First;
290 }
291 State::First => {
292 *state = State::Rest;
293 }
294 State::Rest => {}
295 }
296
297 let (ser, state) = match self {
298 Compound::Tuple { ser, state } => (ser, state),
299 _ => unreachable!(),
300 };
301
302 if !matches!(state, State::First) {
303 ser.write_bytes(b",");
304 }
305 value.serialize(&mut **ser)?;
306 Ok(())
307 }
308
309 fn end(self) -> Result<Self::Ok, Self::Error> {
310 let Compound::Tuple { ser, .. } = self else {
311 unreachable!()
312 };
313 ser.write_bytes(b"]");
314 Ok(())
315 }
316}
317
318impl<'a> ser::SerializeTupleStruct for Compound<'a> {
319 type Ok = ();
320 type Error = serde::de::value::Error;
321
322 fn serialize_field<T: Serialize + ?Sized>(
323 &mut self,
324 value: &T,
325 ) -> Result<Self::Ok, Self::Error> {
326 let state = match self {
327 Compound::TupleStruct { state, .. } => state,
328 _ => unreachable!(),
329 };
330
331 match state {
332 State::Empty => {
333 *state = State::First;
334 }
335 State::First => {
336 *state = State::Rest;
337 }
338 State::Rest => {}
339 }
340
341 let (ser, state) = match self {
342 Compound::TupleStruct { ser, state } => (ser, state),
343 _ => unreachable!(),
344 };
345
346 if !matches!(state, State::First) {
347 ser.write_bytes(b",");
348 }
349 value.serialize(&mut **ser)?;
350 Ok(())
351 }
352
353 fn end(self) -> Result<Self::Ok, Self::Error> {
354 let Compound::TupleStruct { ser, .. } = self else {
355 unreachable!()
356 };
357 ser.write_bytes(b"]");
358 Ok(())
359 }
360}
361
362impl<'a> ser::SerializeTupleVariant for Compound<'a> {
363 type Ok = ();
364 type Error = serde::de::value::Error;
365
366 fn serialize_field<T: Serialize + ?Sized>(
367 &mut self,
368 value: &T,
369 ) -> Result<Self::Ok, Self::Error> {
370 let state = match self {
371 Compound::TupleVariant { state, .. } => state,
372 _ => unreachable!(),
373 };
374
375 match state {
376 State::Empty => {
377 *state = State::First;
378 }
379 State::First => {
380 *state = State::Rest;
381 }
382 State::Rest => {}
383 }
384
385 let (ser, state) = match self {
386 Compound::TupleVariant { ser, state } => (ser, state),
387 _ => unreachable!(),
388 };
389
390 if !matches!(state, State::First) {
391 ser.write_bytes(b",");
392 }
393 value.serialize(&mut **ser)?;
394 Ok(())
395 }
396
397 fn end(self) -> Result<Self::Ok, Self::Error> {
398 let Compound::TupleVariant { ser, .. } = self else {
399 unreachable!()
400 };
401 ser.write_bytes(b"]");
402 ser.write_bytes(b"}");
403 Ok(())
404 }
405}
406
407impl<'a> ser::SerializeMap for Compound<'a> {
408 type Ok = ();
409 type Error = serde::de::value::Error;
410
411 fn serialize_key<T: Serialize + ?Sized>(&mut self, key: &T) -> Result<Self::Ok, Self::Error> {
412 let state = match self {
413 Compound::Map { state, .. } => state,
414 _ => unreachable!(),
415 };
416
417 match state {
418 State::Empty => {
419 *state = State::First;
420 }
421 State::First => {
422 *state = State::Rest;
423 }
424 State::Rest => {}
425 }
426
427 let (ser, state) = match self {
428 Compound::Map { ser, state } => (ser, state),
429 _ => unreachable!(),
430 };
431
432 if !matches!(state, State::First) {
433 ser.write_bytes(b",");
434 }
435 key.serialize(MapKeySerializer { ser })?;
436 ser.write_bytes(b":");
437 Ok(())
438 }
439
440 fn serialize_value<T: Serialize + ?Sized>(
441 &mut self,
442 value: &T,
443 ) -> Result<Self::Ok, Self::Error> {
444 let (ser,) = match self {
445 Compound::Map { ser, .. } => (ser,),
446 _ => unreachable!(),
447 };
448
449 value.serialize(&mut **ser)?;
450 Ok(())
451 }
452
453 fn end(self) -> Result<Self::Ok, Self::Error> {
454 let Compound::Map { ser, .. } = self else {
455 unreachable!()
456 };
457 ser.write_bytes(b"}");
458 Ok(())
459 }
460}
461
462impl<'a> ser::SerializeStruct for Compound<'a> {
463 type Ok = ();
464 type Error = serde::de::value::Error;
465
466 fn serialize_field<T: Serialize + ?Sized>(
467 &mut self,
468 key: &'static str,
469 value: &T,
470 ) -> Result<Self::Ok, Self::Error> {
471 let mut temp = Serializer::new();
472 value.serialize(&mut temp)?;
473 let value_bytes = temp.into_vec();
474 if value_bytes == b"null" {
475 return Ok(());
476 }
477
478 let state = match self {
479 Compound::Struct { state, .. } => state,
480 _ => unreachable!(),
481 };
482
483 match state {
484 State::Empty => {
485 *state = State::First;
486 }
487 State::First => {
488 *state = State::Rest;
489 }
490 State::Rest => {}
491 }
492
493 let (ser, state) = match self {
494 Compound::Struct { ser, state } => (ser, state),
495 _ => unreachable!(),
496 };
497
498 if !matches!(state, State::First) {
499 ser.write_bytes(b",");
500 }
501 let camel_key = to_camel_case(key);
502 ser.write_string_value(&camel_key);
503 ser.write_bytes(b":");
504 ser.write_bytes(&value_bytes);
505 Ok(())
506 }
507
508 fn end(self) -> Result<Self::Ok, Self::Error> {
509 let Compound::Struct { ser, .. } = self else {
510 unreachable!()
511 };
512 ser.write_bytes(b"}");
513 Ok(())
514 }
515}
516
517impl<'a> ser::SerializeStructVariant for Compound<'a> {
518 type Ok = ();
519 type Error = serde::de::value::Error;
520
521 fn serialize_field<T: Serialize + ?Sized>(
522 &mut self,
523 key: &'static str,
524 value: &T,
525 ) -> Result<Self::Ok, Self::Error> {
526 let mut temp = Serializer::new();
527 value.serialize(&mut temp)?;
528 let value_bytes = temp.into_vec();
529 if value_bytes == b"null" {
530 return Ok(());
531 }
532
533 let state = match self {
534 Compound::StructVariant { state, .. } => state,
535 _ => unreachable!(),
536 };
537
538 match state {
539 State::Empty => {
540 *state = State::First;
541 }
542 State::First => {
543 *state = State::Rest;
544 }
545 State::Rest => {}
546 }
547
548 let (ser, state) = match self {
549 Compound::StructVariant { ser, state } => (ser, state),
550 _ => unreachable!(),
551 };
552
553 if !matches!(state, State::First) {
554 ser.write_bytes(b",");
555 }
556 let camel_key = to_camel_case(key);
557 ser.write_string_value(&camel_key);
558 ser.write_bytes(b":");
559 ser.write_bytes(&value_bytes);
560 Ok(())
561 }
562
563 fn end(self) -> Result<Self::Ok, Self::Error> {
564 let Compound::StructVariant { ser, .. } = self else {
565 unreachable!()
566 };
567 ser.write_bytes(b"}");
568 Ok(())
569 }
570}
571
572impl<'a> ser::Serializer for &'a mut Serializer {
573 type Ok = ();
574 type Error = serde::de::value::Error;
575
576 type SerializeSeq = Compound<'a>;
577 type SerializeTuple = Compound<'a>;
578 type SerializeTupleStruct = Compound<'a>;
579 type SerializeTupleVariant = Compound<'a>;
580 type SerializeMap = Compound<'a>;
581 type SerializeStruct = Compound<'a>;
582 type SerializeStructVariant = Compound<'a>;
583
584 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
585 self.write_bytes(if v { b"true" } else { b"false" });
586 Ok(())
587 }
588
589 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
590 self.write(v);
591 Ok(())
592 }
593
594 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
595 self.write(v);
596 Ok(())
597 }
598
599 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
600 self.write(v);
601 Ok(())
602 }
603
604 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
605 self.write(v);
606 Ok(())
607 }
608
609 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
610 self.write(v);
611 Ok(())
612 }
613
614 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
615 self.write(v);
616 Ok(())
617 }
618
619 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
620 self.write(v);
621 Ok(())
622 }
623
624 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
625 self.write(v);
626 Ok(())
627 }
628
629 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
630 self.write(v);
631 Ok(())
632 }
633
634 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
635 self.write(v);
636 Ok(())
637 }
638
639 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
640 self.write_string_value(&v.to_string());
641 Ok(())
642 }
643
644 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
645 self.write_string_value(v);
646 Ok(())
647 }
648
649 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
650 let mut seq = self.serialize_seq(Some(v.len()))?;
651 for b in v {
652 seq.serialize_element(b)?;
653 }
654 seq.end()?;
655 Ok(())
656 }
657
658 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
659 self.write_bytes(b"null");
660 Ok(())
661 }
662
663 fn serialize_some<T: Serialize + ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> {
664 value.serialize(self)
665 }
666
667 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
668 self.write_bytes(b"null");
669 Ok(())
670 }
671
672 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
673 self.write_bytes(b"null");
674 Ok(())
675 }
676
677 fn serialize_unit_variant(
678 self,
679 _name: &'static str,
680 _variant_index: u32,
681 variant: &'static str,
682 ) -> Result<Self::Ok, Self::Error> {
683 self.write_bytes(b"{");
684 self.write_bytes(b"\"t\":");
685 self.write_string_value(variant);
686 self.write_bytes(b"}");
687 Ok(())
688 }
689
690 fn serialize_newtype_struct<T: Serialize + ?Sized>(
691 self,
692 _name: &'static str,
693 value: &T,
694 ) -> Result<Self::Ok, Self::Error> {
695 value.serialize(self)
696 }
697
698 fn serialize_newtype_variant<T: Serialize + ?Sized>(
699 self,
700 _name: &'static str,
701 _variant_index: u32,
702 variant: &'static str,
703 value: &T,
704 ) -> Result<Self::Ok, Self::Error> {
705 self.write_bytes(b"{");
706 self.write_bytes(b"\"t\":");
707 self.write_string_value(variant);
708 self.write_bytes(b",\"v\":");
709 value.serialize(&mut *self)?;
710 self.write_bytes(b"}");
711 Ok(())
712 }
713
714 fn serialize_seq(self, _len: Option<usize>) -> Result<Compound<'a>, Self::Error> {
715 self.write_bytes(b"[");
716 Ok(Compound::Seq {
717 ser: self,
718 state: State::Empty,
719 })
720 }
721
722 fn serialize_tuple(self, _len: usize) -> Result<Compound<'a>, Self::Error> {
723 self.write_bytes(b"[");
724 Ok(Compound::Tuple {
725 ser: self,
726 state: State::Empty,
727 })
728 }
729
730 fn serialize_tuple_struct(
731 self,
732 _name: &'static str,
733 _len: usize,
734 ) -> Result<Compound<'a>, Self::Error> {
735 self.write_bytes(b"[");
736 Ok(Compound::TupleStruct {
737 ser: self,
738 state: State::Empty,
739 })
740 }
741
742 fn serialize_tuple_variant(
743 self,
744 _name: &'static str,
745 _variant_index: u32,
746 variant: &'static str,
747 _len: usize,
748 ) -> Result<Compound<'a>, Self::Error> {
749 self.write_bytes(b"{");
750 self.write_bytes(b"\"t\":");
751 self.write_string_value(variant);
752 self.write_bytes(b",\"v\":[");
753 Ok(Compound::TupleVariant {
754 ser: self,
755 state: State::Empty,
756 })
757 }
758
759 fn serialize_map(self, _len: Option<usize>) -> Result<Compound<'a>, Self::Error> {
760 self.write_bytes(b"{");
761 Ok(Compound::Map {
762 ser: self,
763 state: State::Empty,
764 })
765 }
766
767 fn serialize_struct(
768 self,
769 _name: &'static str,
770 _len: usize,
771 ) -> Result<Compound<'a>, Self::Error> {
772 self.write_bytes(b"{");
773 Ok(Compound::Struct {
774 ser: self,
775 state: State::Empty,
776 })
777 }
778
779 fn serialize_struct_variant(
780 self,
781 _name: &'static str,
782 _variant_index: u32,
783 variant: &'static str,
784 _len: usize,
785 ) -> Result<Compound<'a>, Self::Error> {
786 self.write_bytes(b"{");
787 self.write_bytes(b"\"t\":");
788 self.write_string_value(variant);
789 Ok(Compound::StructVariant {
790 ser: self,
791 state: State::Rest,
792 })
793 }
794}