RUST-1748 Convert unsigned serde helpers to use serde_conv

Cargo.toml

@@ -48,7 +48,6 @@ serde_path_to_error = ["dep:serde_path_to_error"]
 # should be used in conjunction with chrono-0_4 or uuid-0_8.
 serde_with-3 = ["dep:serde_with", "dep:serde"]
 serde = ["dep:serde"]
-serde_json-1 = ["dep:serde_json"]
 
 [lib]
 name = "bson"
@@ -58,7 +57,7 @@ ahash = "0.8.0"
 chrono = { version = "0.4.15", features = ["std"], default-features = false, optional = true }
 rand = "0.9"
 serde = { version = "1.0", features = ["derive"], optional = true }
-serde_json = { version = "1.0", features = ["preserve_order"], optional = true }
+serde_json = { version = "1.0", features = ["preserve_order"] }
 indexmap = "2.1.0"
 hex = "0.4.2"
 base64 = "0.22.1"
@@ -85,7 +84,6 @@ pretty_assertions = "0.6.1"
 proptest = "1.0.0"
 serde_bytes = "0.11"
 serde_path_to_error = "0.1.16"
-serde_json = "1"
 chrono = { version = "0.4", features = ["serde", "clock", "std"], default-features = false }
 
 [package.metadata.docs.rs]

README.md

@@ -50,11 +50,10 @@ Note that if you are using `bson` through the `mongodb` crate, you do not need t
 | `chrono-0_4` | Enable support for v0.4 of the [`chrono`](https://docs.rs/chrono/0.4) crate in the public API.              | n/a                | no      |
 | `uuid-1`     | Enable support for v1.x of the [`uuid`](https://docs.rs/uuid/1.0) crate in the public API.                  | n/a                | no      |
 | `time-0_3`   | Enable support for v0.3 of the [`time`](https://docs.rs/time/0.3) crate in the public API.                  | n/a                | no      |
-| `serde_with-3` | Enable [`serde_with`](https://docs.rs/serde_with/3.x) 3.x integrations for `bson::DateTime` and `bson::Uuid`.| `serde_with`         | no      |
-| `serde_path_to_error` | Enable support for error paths via integration with [`serde_path_to_error`](https://docs.rs/serde_path_to_err/latest).  This is an unstable feature and any breaking changes to `serde_path_to_error` may affect usage of it via this feature.  | `serde_path_to_error`  | no |
+| `serde_with-3` | Enable [`serde_with`](https://docs.rs/serde_with/3.x) 3.x integrations for `bson::DateTime` and `bson::Uuid`.| serde_with         | no      |
+| `serde_path_to_error` | Enable support for error paths via integration with [`serde_path_to_error`](https://docs.rs/serde_path_to_err/latest).  This is an unstable feature and any breaking changes to `serde_path_to_error` may affect usage of it via this feature.  | serde_path_to_error  | no |
 | `compat-3-0-0` | Required for future compatibility if default features are disabled. | n/a | no |
 | `large_dates` | Increase the supported year range for some `bson::DateTime` utilities from +/-9,999 (inclusive) to +/-999,999 (inclusive). Note that enabling this feature can impact performance and introduce parsing ambiguities. | n/a | no |
-| `serde_json-1` | Enable support for v1.x of the [`serde_json`](https://docs.rs/serde_json/1.x) crate in the public API. | `serde_json` | no |
 
 ## Overview of the BSON Format
 

serde-tests/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2018"
 default = []
 
 [dependencies]
-bson = { path = "..", features = ["uuid-1", "chrono-0_4", "serde", "serde_with-3", "serde_json-1"] }
+bson = { path = "..", features = ["uuid-1", "chrono-0_4", "serde", "serde_with-3"] }
 serde = { version = "1.0", features = ["derive"] }
 pretty_assertions = "0.6.1"
 hex = "0.4.2"

src/bson.rs

@@ -28,8 +28,10 @@ use std::{
     ops::Index,
 };
 
+use serde_json::{json, Value};
+
 pub use crate::document::Document;
-use crate::{oid, raw::CString, spec::ElementType, Binary, Decimal128};
+use crate::{base64, oid, raw::CString, spec::ElementType, Binary, Decimal128};
 
 /// Possible BSON value types.
 #[derive(Clone, Default, PartialEq)]
@@ -448,7 +450,143 @@ where
     }
 }
 
+/// This will create the [relaxed Extended JSON v2](https://www.mongodb.com/docs/manual/reference/mongodb-extended-json/) representation of the provided [`Bson`](../enum.Bson.html).
+impl From<Bson> for Value {
+    fn from(bson: Bson) -> Self {
+        bson.into_relaxed_extjson()
+    }
+}
+
 impl Bson {
+    /// Converts the Bson value into its [relaxed extended JSON representation](https://www.mongodb.com/docs/manual/reference/mongodb-extended-json/).
+    pub fn into_relaxed_extjson(self) -> Value {
+        match self {
+            Bson::Double(v) if v.is_nan() => {
+                let s = if v.is_sign_negative() { "-NaN" } else { "NaN" };
+
+                json!({ "$numberDouble": s })
+            }
+            Bson::Double(v) if v.is_infinite() => {
+                let s = if v.is_sign_negative() {
+                    "-Infinity"
+                } else {
+                    "Infinity"
+                };
+
+                json!({ "$numberDouble": s })
+            }
+            Bson::Double(v) => json!(v),
+            Bson::String(v) => json!(v),
+            Bson::Array(v) => Value::Array(v.into_iter().map(Bson::into_relaxed_extjson).collect()),
+            Bson::Document(v) => Value::Object(
+                v.into_iter()
+                    .map(|(k, v)| (k, v.into_relaxed_extjson()))
+                    .collect(),
+            ),
+            Bson::Boolean(v) => json!(v),
+            Bson::Null => Value::Null,
+            Bson::RegularExpression(Regex { pattern, options }) => {
+                let mut chars: Vec<_> = options.as_str().chars().collect();
+                chars.sort_unstable();
+
+                let options: String = chars.into_iter().collect();
+
+                json!({
+                    "$regularExpression": {
+                        "pattern": pattern.into_string(),
+                        "options": options,
+                    }
+                })
+            }
+            Bson::JavaScriptCode(code) => json!({ "$code": code }),
+            Bson::JavaScriptCodeWithScope(JavaScriptCodeWithScope { code, scope }) => json!({
+                "$code": code,
+                "$scope": Bson::Document(scope).into_relaxed_extjson(),
+            }),
+            Bson::Int32(v) => v.into(),
+            Bson::Int64(v) => v.into(),
+            Bson::Timestamp(Timestamp { time, increment }) => json!({
+                "$timestamp": {
+                    "t": time,
+                    "i": increment,
+                }
+            }),
+            Bson::Binary(Binary { subtype, ref bytes }) => {
+                let tval: u8 = From::from(subtype);
+                json!({
+                    "$binary": {
+                        "base64": base64::encode(bytes),
+                        "subType": hex::encode([tval]),
+                    }
+                })
+            }
+            Bson::ObjectId(v) => json!({"$oid": v.to_hex()}),
+            Bson::DateTime(v) if v.timestamp_millis() >= 0 && v.to_time_0_3().year() <= 9999 => {
+                json!({
+                    // Unwrap safety: timestamps in the guarded range can always be formatted.
+                    "$date": v.try_to_rfc3339_string().unwrap(),
+                })
+            }
+            Bson::DateTime(v) => json!({
+                "$date": { "$numberLong": v.timestamp_millis().to_string() },
+            }),
+            Bson::Symbol(v) => json!({ "$symbol": v }),
+            Bson::Decimal128(v) => json!({ "$numberDecimal": v.to_string() }),
+            Bson::Undefined => json!({ "$undefined": true }),
+            Bson::MinKey => json!({ "$minKey": 1 }),
+            Bson::MaxKey => json!({ "$maxKey": 1 }),
+            Bson::DbPointer(DbPointer {
+                ref namespace,
+                ref id,
+            }) => json!({
+                "$dbPointer": {
+                    "$ref": namespace,
+                    "$id": {
+                        "$oid": id.to_hex()
+                    }
+                }
+            }),
+        }
+    }
+
+    /// Converts the Bson value into its [canonical extended JSON representation](https://www.mongodb.com/docs/manual/reference/mongodb-extended-json/).
+    pub fn into_canonical_extjson(self) -> Value {
+        match self {
+            Bson::Int32(i) => json!({ "$numberInt": i.to_string() }),
+            Bson::Int64(i) => json!({ "$numberLong": i.to_string() }),
+            Bson::Double(f) if f.is_normal() => {
+                let mut s = f.to_string();
+                if f.fract() == 0.0 {
+                    s.push_str(".0");
+                }
+
+                json!({ "$numberDouble": s })
+            }
+            Bson::Double(f) if f == 0.0 => {
+                let s = if f.is_sign_negative() { "-0.0" } else { "0.0" };
+
+                json!({ "$numberDouble": s })
+            }
+            Bson::DateTime(date) => {
+                json!({ "$date": { "$numberLong": date.timestamp_millis().to_string() } })
+            }
+            Bson::Array(arr) => {
+                Value::Array(arr.into_iter().map(Bson::into_canonical_extjson).collect())
+            }
+            Bson::Document(arr) => Value::Object(
+                arr.into_iter()
+                    .map(|(k, v)| (k, v.into_canonical_extjson()))
+                    .collect(),
+            ),
+            Bson::JavaScriptCodeWithScope(JavaScriptCodeWithScope { code, scope }) => json!({
+                "$code": code,
+                "$scope": Bson::Document(scope).into_canonical_extjson(),
+            }),
+
+            other => other.into_relaxed_extjson(),
+        }
+    }
+
     /// Get the [`ElementType`] of this value.
     pub fn element_type(&self) -> ElementType {
         match *self {
@@ -530,7 +668,7 @@ impl Bson {
                 } else {
                     doc! {
                         "$binary": {
-                            "base64": crate::base64::encode(bytes),
+                            "base64": base64::encode(bytes),
                             "subType": hex::encode([tval]),
                         }
                     }

src/datetime.rs

@@ -108,21 +108,16 @@ use crate::error::{Error, Result};
 ///
 /// ### `serde_helpers`
 /// The `bson` crate provides a number of useful helpers for serializing and deserializing
-/// various datetime types to and from different formats using the [`serde_with`](https://docs.rs/serde_with/1.11.0/serde_with/)
-/// crate.
-///
-/// > **Note:** All helpers in this module require use of the [`#[serde_as]`](https://docs.rs/serde_with/latest/serde_with/attr.serde_as.html)
-/// > attribute on the struct. This enables the enhanced serialization behavior provided by
-/// > `serde_with-3`.
-///
-/// For example, to serialize a [`chrono::DateTime`] as a BSON datetime, you can use
+/// various datetime types to and from different formats. For example, to serialize a
+/// [`chrono::DateTime`] as a BSON datetime, you can use
 /// [`crate::serde_helpers::datetime::FromChrono04DateTime`].
 /// Similarly, to serialize a BSON [`DateTime`] to a string, you can use
 /// [`crate::serde_helpers::datetime::AsRfc3339String`]. Check out the
-/// [`crate::serde_helpers`] module documentation for a list of all of the helpers
-/// offered by the crate.
+/// [`crate::serde_helpers`] module documentation for a list of all of the helpers offered by the
+/// crate.
+///
 /// ```rust
-/// # #[cfg(all(feature = "chrono-0_4", feature = "serde_with-3"))]
+/// # #[cfg(feature = "chrono-0_4")]
 /// # {
 /// use serde::{Serialize, Deserialize};
 /// use serde_with::serde_as;
@@ -143,26 +138,29 @@ use crate::error::{Error, Result};
 ///     chrono_as_bson: chrono::DateTime<chrono::Utc>,
 ///
 ///     // serializes as an RFC 3339 / ISO-8601 string.
-///     // this requires the "serde_with-3" feature flag
 ///     #[serde_as(as = "datetime::AsRfc3339String")]
 ///     bson_as_string: bson::DateTime,
 /// }
 /// # }
 /// ```
-/// The main benefit of using the [`serde_with`](https://docs.rs/serde_with/1.11.0/serde_with/) crate
-/// is that it can handle nested [`chrono::DateTime`] values (e.g. in [`Option`] or [`Vec`]).
+/// ### The `serde_with-3` feature flag
+///
+/// The `serde_with-3` feature can be enabled to support more ergonomic serde attributes for
+/// (de)serializing [`chrono::DateTime`] from/to BSON via the [`serde_with`](https://docs.rs/serde_with/1.11.0/serde_with/)
+/// crate. The main benefit of this compared to the regular `serde_helpers` is that `serde_with-3`
+/// can handle nested [`chrono::DateTime`] values (e.g. in [`Option`]), whereas the former only
+/// works on fields that are exactly [`chrono::DateTime`].
 /// ```
 /// # #[cfg(all(feature = "chrono-0_4", feature = "serde_with-3"))]
 /// # {
 /// use serde::{Deserialize, Serialize};
-/// use serde_with::serde_as;
-/// use bson::{doc, serde_helpers::datetime};
+/// use bson::doc;
 ///
-/// #[serde_as]
+/// #[serde_with::serde_as]
 /// #[derive(Deserialize, Serialize, PartialEq, Debug)]
 /// struct Foo {
-///   /// serializes as a BSON datetime rather than using [`chrono::DateTime`]'s serialization
-///   #[serde_as(as = "Option<datetime::FromChrono04DateTime>")]
+///   /// Serializes as a BSON datetime rather than using [`chrono::DateTime`]'s serialization
+///   #[serde_as(as = "Option<bson::DateTime>")]
 ///   as_bson: Option<chrono::DateTime<chrono::Utc>>,
 /// }
 ///

src/de/raw.rs

@@ -363,7 +363,7 @@ impl<'de> serde::de::MapAccess<'de> for DocumentAccess<'de> {
         match &self.elem {
             None => Ok(None),
             Some(elem) => seed
-                .deserialize(BorrowedStrDeserializer::new(elem.key().as_str()))
+                .deserialize(BorrowedStrDeserializer::new(elem.key()))
                 .map(Some),
         }
     }
@@ -421,8 +421,7 @@ impl<'de> serde::de::EnumAccess<'de> for DocumentAccess<'de> {
             Some(e) => e,
             None => return Err(Error::end_of_stream()),
         };
-        let de: BorrowedStrDeserializer<'_, Error> =
-            BorrowedStrDeserializer::new(elem.key().as_str());
+        let de: BorrowedStrDeserializer<'_, Error> = BorrowedStrDeserializer::new(elem.key());
         let key = seed.deserialize(de)?;
         Ok((key, self))
     }

src/decimal128.rs

@@ -356,9 +356,7 @@ impl std::str::FromStr for ParsedDecimal128 {
                         exp_str = post;
                     }
                 }
-                // Initially parse the exponent as an i128 to handle corner cases with zero
-                // coefficients and very large exponents.
-                let mut wide_exp = exp_str.parse::<i128>().map_err(|e| {
+                let mut exp = exp_str.parse::<i16>().map_err(|e| {
                     Error::decimal128(Decimal128ErrorKind::InvalidExponent {}).with_message(e)
                 })?;
 
@@ -369,7 +367,7 @@ impl std::str::FromStr for ParsedDecimal128 {
                         .len()
                         .try_into()
                         .map_err(|_| Error::decimal128(Decimal128ErrorKind::Underflow {}))?;
-                    wide_exp = wide_exp
+                    exp = exp
                         .checked_sub(exp_adj)
                         .ok_or_else(|| Error::decimal128(Decimal128ErrorKind::Underflow {}))?;
                     joined_str = format!("{}{}", pre, post);
@@ -388,17 +386,16 @@ impl std::str::FromStr for ParsedDecimal128 {
                         let exp_adj = (len - decimal_str.len())
                             .try_into()
                             .map_err(|_| Error::decimal128(Decimal128ErrorKind::Overflow {}))?;
-                        wide_exp = wide_exp
+                        exp = exp
                             .checked_add(exp_adj)
                             .ok_or_else(|| Error::decimal128(Decimal128ErrorKind::Overflow {}))?;
                     }
                 }
 
                 // Check exponent limits
-                const TINY: i128 = Exponent::TINY as i128;
-                if wide_exp < TINY {
+                if exp < Exponent::TINY {
                     if decimal_str != "0" {
-                        let delta = (TINY - wide_exp)
+                        let delta = (Exponent::TINY - exp)
                             .try_into()
                             .map_err(|_| Error::decimal128(Decimal128ErrorKind::Overflow {}))?;
                         let new_precision = decimal_str
@@ -407,13 +404,12 @@ impl std::str::FromStr for ParsedDecimal128 {
                             .ok_or_else(|| Error::decimal128(Decimal128ErrorKind::Overflow {}))?;
                         decimal_str = round_decimal_str(decimal_str, new_precision)?;
                     }
-                    wide_exp = Exponent::TINY.into();
+                    exp = Exponent::TINY;
                 }
                 let padded_str;
-                const MAX: i128 = Exponent::MAX as i128;
-                if wide_exp > MAX {
+                if exp > Exponent::MAX {
                     if decimal_str != "0" {
-                        let delta = (wide_exp - MAX)
+                        let delta = (exp - Exponent::MAX)
                             .try_into()
                             .map_err(|_| Error::decimal128(Decimal128ErrorKind::Overflow {}))?;
                         if decimal_str
@@ -427,13 +423,10 @@ impl std::str::FromStr for ParsedDecimal128 {
                         padded_str = format!("{}{}", decimal_str, "0".repeat(delta));
                         decimal_str = &padded_str;
                     }
-                    wide_exp = Exponent::MAX.into();
+                    exp = Exponent::MAX;
                 }
 
                 // Assemble the final value
-                let exp: i16 = wide_exp
-                    .try_into()
-                    .map_err(|_| Error::decimal128(Decimal128ErrorKind::Overflow {}))?;
                 let exponent = Exponent::from_native(exp);
                 let coeff: u128 = decimal_str.parse().map_err(|e: ParseIntError| {
                     Error::decimal128(Decimal128ErrorKind::InvalidCoefficient {}).with_message(e)

src/error.rs

@@ -1,5 +1,3 @@
-//! Contains the error-related types for the `bson` crate.
-
 mod decimal128;
 mod oid;
 mod uuid;