Re-export serde_json::Value from core (#3296)

heaths · web-flow · commit 7f2ccaf63b25 · 2025-11-06T18:48:24.000Z
Resolves #1687. As long as we use `Value` from core, should `serde_json::Value` ever make a breaking change to `Value` we can effectively vendor just that while continuing to pick up changes to the de/serializers.
diff --git a/sdk/core/azure_core/CHANGELOG.md b/sdk/core/azure_core/CHANGELOG.md
@@ -8,6 +8,7 @@
 - Added `Response::to_raw_response()` function to create a `RawResponse` from cloned data.
 - Added `UrlExt::append_path()`.
 - Implemented `IntoFuture` for a `Poller`. Call `await` on a Poller to get the final model, or `into_stream()` to get a `futures::Stream` to poll the operation manually.
+- Re-exported `serde_json::Value` as `azure_core::Value` ([#1687](https://github.com/Azure/azure-sdk-for-rust/issues/1687))
 
 ### Breaking Changes
 
diff --git a/sdk/core/azure_core/benches/deserialization.rs b/sdk/core/azure_core/benches/deserialization.rs
@@ -79,15 +79,15 @@ criterion_main!(benchmarks);
 mod models {
     //! Copied from `azure_storage_blob::models`.
     //!
-    //! Model definitions remain intact but some unused fields are replaced with `serde_json::Value`
+    //! Model definitions remain intact but some unused fields are replaced with `azure_core::Value`
     //! because we still want to retain the same behavior and performance of the deserialization visitor.
 
     use azure_core::{
         error::{Error, ErrorKind},
         time::OffsetDateTime,
+        Value,
     };
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
-    use serde_json::Value;
     use std::{convert::Infallible, str::FromStr};
 
     /// An enumeration of blobs.
diff --git a/sdk/core/azure_core/src/error/error_response.rs b/sdk/core/azure_core/src/error/error_response.rs
@@ -78,7 +78,7 @@ pub struct ErrorDetail {
 
     /// Additional properties that may be returned with the error.
     #[serde(flatten)]
-    pub additional_properties: HashMap<String, serde_json::Value>,
+    pub additional_properties: HashMap<String, crate::Value>,
 }
 
 /// Inner error information about an error returned from a service.
diff --git a/sdk/core/azure_core/src/lib.rs b/sdk/core/azure_core/src/lib.rs
@@ -20,7 +20,7 @@ pub mod test;
 
 // Re-export modules in typespec_client_core such that azure_core-based crates don't need to reference it directly.
 pub use typespec_client_core::{
-    async_runtime, base64, fmt, json, sleep, stream, time, Bytes, Error, Result, Uuid,
+    async_runtime, base64, fmt, json, sleep, stream, time, Bytes, Error, Result, Uuid, Value,
 };
 
 /// Abstractions for distributed tracing and telemetry.
diff --git a/sdk/core/typespec/Cargo.toml b/sdk/core/typespec/Cargo.toml
@@ -27,7 +27,7 @@ thiserror.workspace = true
 default = ["http", "json"]
 http = []
 json = ["dep:serde", "dep:serde_json"]
-xml = ["dep:quick-xml"]
+xml = ["dep:serde", "dep:quick-xml"]
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/sdk/core/typespec_client_core/CHANGELOG.md b/sdk/core/typespec_client_core/CHANGELOG.md
@@ -7,6 +7,7 @@
 - Added `PipelineOptions::retry_status_codes` for configuring which status codes should trigger a retry.
 - Added `UrlExt::append_path()`.
 - Added module `fmt::empty_as_null` containing some serde helpers for empty/null string values.
+- Re-exported `serde_json::Value` as `typespec_client_core::Value` ([#1687](https://github.com/Azure/azure-sdk-for-rust/issues/1687))
 
 ### Breaking Changes
 
diff --git a/sdk/core/typespec_client_core/Cargo.toml b/sdk/core/typespec_client_core/Cargo.toml
@@ -21,7 +21,7 @@ rand.workspace = true
 reqwest = { workspace = true, optional = true }
 rust_decimal = { workspace = true, optional = true }
 serde.workspace = true
-serde_json.workspace = true
+serde_json = { workspace = true, optional = true }
 time.workspace = true
 tokio = { workspace = true, optional = true }
 tracing.workspace = true
@@ -65,15 +65,15 @@ debug = ["typespec_macros?/debug"]
 decimal = ["dep:rust_decimal"]
 derive = ["dep:typespec_macros"]
 http = ["typespec/http"]
-json = ["typespec/json"]
+json = ["dep:serde_json", "typespec/json"]
 reqwest = ["dep:reqwest"]
 reqwest_deflate = ["reqwest", "reqwest/deflate"]
 reqwest_gzip = ["reqwest", "reqwest/gzip"]
 reqwest_native_tls = ["reqwest", "reqwest/native-tls"]
 test = [] # Enables extra tracing including error bodies that may contain PII.
 tokio = ["tokio/sync", "tokio/time"]
 wasm_bindgen = ["dep:wasm-bindgen-futures", "gloo-timers/futures"]
-xml = ["typespec/xml"]
+xml = ["dep:serde_json", "typespec/xml"] # Uses serde_json::Value for `unknown` TypeSpec scalar.
 
 [[example]]
 name = "core_binary_data_request"
diff --git a/sdk/core/typespec_client_core/src/base64.rs b/sdk/core/typespec_client_core/src/base64.rs
@@ -335,10 +335,10 @@ pub mod option {
 
 #[cfg(test)]
 mod tests {
-    use super::{
-        decode, decode_url_safe, deserialize, deserialize_url_safe, encode, encode_url_safe,
-        option, serialize, serialize_url_safe,
-    };
+    use super::{decode, decode_url_safe, encode, encode_url_safe};
+    #[cfg(feature = "json")]
+    use super::{deserialize, deserialize_url_safe, option, serialize, serialize_url_safe};
+    #[cfg(feature = "json")]
     use serde::{Deserialize, Serialize};
 
     #[test]
@@ -397,12 +397,14 @@ mod tests {
         assert_eq!(decode_url_safe(encode_url_safe(data)).unwrap(), data);
     }
 
+    #[cfg(feature = "json")]
     #[derive(Serialize, Deserialize)]
     struct TestStruct {
         #[serde(serialize_with = "serialize", deserialize_with = "deserialize")]
         data: Vec<u8>,
     }
 
+    #[cfg(feature = "json")]
     #[test]
     fn serde_standard() {
         let original = TestStruct {
@@ -414,6 +416,7 @@ mod tests {
         assert_eq!(deserialized.data, original.data);
     }
 
+    #[cfg(feature = "json")]
     #[derive(Serialize, Deserialize)]
     struct TestStructUrlSafe {
         #[serde(
@@ -423,6 +426,7 @@ mod tests {
         data: Vec<u8>,
     }
 
+    #[cfg(feature = "json")]
     #[test]
     fn serde_url_safe() {
         let original = TestStructUrlSafe {
@@ -434,6 +438,7 @@ mod tests {
         assert_eq!(deserialized.data, original.data);
     }
 
+    #[cfg(feature = "json")]
     #[derive(Serialize, Deserialize)]
     struct TestOptionalStruct {
         #[serde(
@@ -443,6 +448,7 @@ mod tests {
         data: Option<Vec<u8>>,
     }
 
+    #[cfg(feature = "json")]
     #[test]
     fn serde_option_some() {
         let original = TestOptionalStruct {
@@ -454,6 +460,7 @@ mod tests {
         assert_eq!(deserialized.data, original.data);
     }
 
+    #[cfg(feature = "json")]
     #[test]
     fn serde_option_none() {
         let original = TestOptionalStruct { data: None };
@@ -463,6 +470,7 @@ mod tests {
         assert_eq!(deserialized.data, None);
     }
 
+    #[cfg(feature = "json")]
     #[derive(Serialize, Deserialize)]
     struct TestOptionalStructUrlSafe {
         #[serde(
@@ -472,6 +480,7 @@ mod tests {
         data: Option<Vec<u8>>,
     }
 
+    #[cfg(feature = "json")]
     #[test]
     fn serde_option_url_safe_some() {
         let original = TestOptionalStructUrlSafe {
@@ -483,6 +492,7 @@ mod tests {
         assert_eq!(deserialized.data, original.data);
     }
 
+    #[cfg(feature = "json")]
     #[test]
     fn serde_option_url_safe_none() {
         let original = TestOptionalStructUrlSafe { data: None };
diff --git a/sdk/core/typespec_client_core/src/http/format.rs b/sdk/core/typespec_client_core/src/http/format.rs
@@ -43,6 +43,7 @@ pub trait DeserializeWith<F: Format>: Sized {
 
 /// Implements [`DeserializeWith<JsonFormat>`] for an arbitrary type `D`
 /// that implements [`serde::de::DeserializeOwned`] by deserializing the response body to the specified type using [`serde_json`].
+#[cfg(feature = "json")]
 impl<D: DeserializeOwned> DeserializeWith<JsonFormat> for D {
     fn deserialize_with(body: ResponseBody) -> typespec::Result<Self> {
         body.json()
@@ -55,9 +56,11 @@ impl<D: DeserializeOwned> DeserializeWith<JsonFormat> for D {
 /// This format supports deserializing response bodies to:
 /// * [`ResponseBody`] - The raw response body, without any deserialization.
 /// * Any value implementing [`serde::de::DeserializeOwned`] - Deserializes the response body to the specified type using JSON deserialization.
+#[cfg(feature = "json")]
 #[derive(Debug, Clone)]
 pub struct JsonFormat;
 
+#[cfg(feature = "json")]
 impl Format for JsonFormat {
     fn deserialize<T: DeserializeOwned, S: AsRef<[u8]>>(body: S) -> crate::Result<T> {
         crate::json::from_json(body)
diff --git a/sdk/core/typespec_client_core/src/http/method.rs b/sdk/core/typespec_client_core/src/http/method.rs
@@ -30,8 +30,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-#[cfg(any(feature = "json", feature = "xml"))]
-use std::fmt::{self, Display};
+use std::fmt;
 use std::str::FromStr;
 
 /// HTTP request methods.
@@ -172,7 +171,7 @@ mod serde {
     }
 }
 
-impl Display for Method {
+impl fmt::Display for Method {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(AsRef::<str>::as_ref(self))
     }
diff --git a/sdk/core/typespec_client_core/src/http/request/mod.rs b/sdk/core/typespec_client_core/src/http/request/mod.rs
@@ -7,18 +7,23 @@ pub mod options;
 
 #[cfg(not(target_arch = "wasm32"))]
 use crate::stream::SeekableStream;
+#[cfg(feature = "json")]
+use crate::{http::JsonFormat, json::to_json};
 use crate::{
     http::{
         headers::{AsHeaders, Header, HeaderName, HeaderValue, Headers},
-        JsonFormat, Method, Sanitizer, Url, DEFAULT_ALLOWED_QUERY_PARAMETERS,
+        Method, Sanitizer, Url, DEFAULT_ALLOWED_QUERY_PARAMETERS,
     },
-    json::to_json,
-    time::OffsetDateTime,
     Bytes,
 };
+#[cfg(any(feature = "json", feature = "xml"))]
+use crate::{time::OffsetDateTime, Value};
+#[cfg(any(feature = "json", feature = "xml"))]
 use serde::Serialize;
-use serde_json::Value;
-use std::{collections::HashMap, fmt, marker::PhantomData};
+#[cfg(any(feature = "json", feature = "xml"))]
+use std::collections::HashMap;
+use std::{fmt, marker::PhantomData};
+#[cfg(any(feature = "json", feature = "xml"))]
 use time::format_description::well_known::Rfc3339;
 
 /// An HTTP Body.
@@ -204,6 +209,7 @@ impl Request {
     }
 
     /// Sets request body JSON.
+    #[cfg(feature = "json")]
     pub fn set_json<T>(&mut self, data: &T) -> crate::Result<()>
     where
         T: ?Sized + Serialize,
@@ -252,13 +258,25 @@ impl fmt::Debug for Request {
 }
 
 /// The body content of a service client request.
+///
 /// This allows callers to pass a model to serialize or raw content to client methods.
+#[cfg(feature = "json")]
 #[derive(Clone, Debug)]
 pub struct RequestContent<T, F = JsonFormat> {
     body: Body,
     phantom: PhantomData<(T, F)>,
 }
 
+/// The body content of a service client request.
+///
+/// This allows callers to pass a model to serialize or raw content to client methods.
+#[cfg(not(feature = "json"))]
+#[derive(Clone, Debug)]
+pub struct RequestContent<T, F> {
+    body: Body,
+    phantom: PhantomData<(T, F)>,
+}
+
 impl<T, F> RequestContent<T, F> {
     /// Gets the body of the request.
     pub fn body(&self) -> &Body {
@@ -447,6 +465,7 @@ mod json {
     impl_try_from!(&str, String);
     impl_try_from!(i32, i64);
     impl_try_from!(f32, f64);
+    #[cfg(any(feature = "json", feature = "xml"))]
     impl_try_from!(Value);
 
     impl<T, F> TryFrom<Vec<OffsetDateTime>> for RequestContent<T, F> {
@@ -534,6 +553,7 @@ mod json {
         assert_eq!(actual.body(), &Body::from_static(br#"["hello",""]"#));
     }
 
+    #[cfg(any(feature = "json", feature = "xml"))]
     #[test]
     fn spector_vec_value() {
         let actual: RequestContent<Vec<Value>> = vec![
@@ -619,6 +639,7 @@ mod json {
         );
     }
 
+    #[cfg(any(feature = "json", feature = "xml"))]
     #[test]
     fn spector_dictionary_value() {
         let actual: RequestContent<BTreeMap<String, Value>> = BTreeMap::from_iter(vec![
diff --git a/sdk/core/typespec_client_core/src/http/response.rs b/sdk/core/typespec_client_core/src/http/response.rs
@@ -3,9 +3,11 @@
 
 //! HTTP responses.
 
+#[cfg(feature = "json")]
+use crate::http::JsonFormat;
 use crate::{
     error::ErrorKind,
-    http::{headers::Headers, DeserializeWith, Format, JsonFormat, StatusCode},
+    http::{headers::Headers, DeserializeWith, Format, StatusCode},
     Bytes,
 };
 use futures::{Stream, StreamExt};
@@ -93,11 +95,29 @@ impl BufResponse {
 ///
 /// Given a `Response<T, F>`, a user can deserialize the body formatted as type `F` into the intended body type `T` by calling [`Response::into_body`].
 /// However, because the type `T` is just a marker type, you can also access the raw [`ResponseBody`] using [`Response::into_raw_body`].
+#[cfg(feature = "json")]
 pub struct Response<T, F = JsonFormat> {
     raw: RawResponse,
     phantom: PhantomData<(T, F)>,
 }
 
+/// A typed fully-buffered HTTP response.
+///
+/// The type parameter `T` is a marker type that indicates what the caller should expect to be able to deserialize the body into.
+/// Service client methods should return a `Response<SomeModel>` where `SomeModel` is the service-specific response type.
+/// For example, a service client method that returns a list of secrets should return `Response<ListSecretsResponse>`.
+///
+/// The type parameter `F` is a marker type that indicates the format of the data.
+/// JSON and XML is supported, and `NoFormat` indicates a binary body or no body expected e.g., for HTTP 204.
+///
+/// Given a `Response<T, F>`, a user can deserialize the body formatted as type `F` into the intended body type `T` by calling [`Response::into_body`].
+/// However, because the type `T` is just a marker type, you can also access the raw [`ResponseBody`] using [`Response::into_raw_body`].
+#[cfg(not(feature = "json"))]
+pub struct Response<T, F> {
+    raw: RawResponse,
+    phantom: PhantomData<(T, F)>,
+}
+
 impl<T, F> Response<T, F> {
     /// Get the status code from the response.
     pub fn status(&self) -> StatusCode {
diff --git a/sdk/core/typespec_client_core/src/lib.rs b/sdk/core/typespec_client_core/src/lib.rs
@@ -25,9 +25,14 @@ pub use crate::error::{Error, Result};
 pub use typespec::Bytes;
 pub use uuid::Uuid;
 
+#[cfg(any(feature = "json", feature = "xml"))]
+pub use serde_json::Value;
+
 pub use sleep::sleep;
 
 mod private {
+    #[allow(dead_code)]
     pub trait Sealed {}
+    #[cfg(feature = "http")]
     impl Sealed for crate::http::Url {}
 }

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ pub struct ErrorDetail {`
`78`	`78`
`79`	`79`	`/// Additional properties that may be returned with the error.`
`80`	`80`	`#[serde(flatten)]`
`81`		`- pub additional_properties: HashMap<String, serde_json::Value>,`
	`81`	`+ pub additional_properties: HashMap<String, crate::Value>,`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`/// Inner error information about an error returned from a service.`
Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,7 @@`
`30`	`30`	`// Copyright (c) Microsoft Corporation. All rights reserved.`
`31`	`31`	`// Licensed under the MIT License.`
`32`	`32`
`33`		`-#[cfg(any(feature = "json", feature = "xml"))]`
`34`		`-use std::fmt::{self, Display};`
	`33`	`+use std::fmt;`
`35`	`34`	`use std::str::FromStr;`
`36`	`35`
`37`	`36`	`/// HTTP request methods.`
`@@ -172,7 +171,7 @@ mod serde {`
`172`	`171`	`}`
`173`	`172`	`}`
`174`	`173`
`175`		`-impl Display for Method {`
	`174`	`+impl fmt::Display for Method {`
`176`	`175`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`177`	`176`	`f.write_str(AsRef::<str>::as_ref(self))`
`178`	`177`	`}`