diff --git a/Cargo.lock b/Cargo.lock index 0317b77037a..d24d0a9c9ed 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10860,6 +10860,18 @@ dependencies = [ "syn 2.0.118", ] +[[package]] +name = "problematic" +version = "0.0.0" +dependencies = [ + "http 1.4.2", + "insta", + "schemars 1.2.1", + "serde", + "serde_core", + "serde_json", +] + [[package]] name = "proc-macro-crate" version = "3.5.0" diff --git a/Cargo.toml b/Cargo.toml index 99d1307bd39..5c7020db71b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -47,6 +47,7 @@ members = [ "libs/darwin-kperf/sys", "libs/error-stack", "libs/error-stack/macros", + "libs/problematic/rust", "tests/graph/benches", "tests/graph/integration", "tests/graph/test-data/rust", @@ -106,6 +107,7 @@ hashql-hir.path = "libs/@local/hashql/hir" hashql-macros.path = "libs/@local/hashql/macros" hashql-mir.path = "libs/@local/hashql/mir" hashql-syntax-jexpr.path = "libs/@local/hashql/syntax-jexpr" +problematic.path = "libs/problematic/rust" type-system.path = "libs/@blockprotocol/type-system/rust" # External dependencies @@ -185,7 +187,7 @@ hifijson = { version = "0.4.0", default-features = fal hkdf = { version = "0.13.0", default-features = false } hmac = { version = "0.13.0", default-features = false } hostname = { version = "0.4.2", default-features = false } -http = { version = "1.3.1", default-features = false } +http = { version = "1.3.1", default-features = false, features = ["std"] } humansize = { version = "2.1.3", default-features = false } hyper = { version = "1.7.0", default-features = false } include_dir = { version = "0.7.4", default-features = false } diff --git a/libs/@local/graph/authentication/Cargo.toml b/libs/@local/graph/authentication/Cargo.toml index 31a24439a9c..4d41287fee5 100644 --- a/libs/@local/graph/authentication/Cargo.toml +++ b/libs/@local/graph/authentication/Cargo.toml @@ -15,7 +15,7 @@ hash-middleware = { workspace = true, public = true } type-system = { workspace = true, public = true } # Public third-party dependencies -http = { workspace = true, public = true, features = ["std"] } +http = { workspace = true, public = true } jsonwebtoken = { workspace = true, public = true, features = ["aws_lc_rs"] } opentelemetry = { workspace = true, public = true, features = ["metrics"] } reqwest = { workspace = true, public = true } diff --git a/libs/@local/middleware/Cargo.toml b/libs/@local/middleware/Cargo.toml index c1c9e2939cc..f0e76571b3b 100644 --- a/libs/@local/middleware/Cargo.toml +++ b/libs/@local/middleware/Cargo.toml @@ -14,7 +14,7 @@ type-system = { workspace = true, public = true } # Public third-party dependencies axum = { workspace = true, public = true } axum-core = { workspace = true, public = true } -http = { workspace = true, public = true, features = ["std"] } +http = { workspace = true, public = true } opentelemetry = { workspace = true, public = true, features = ["metrics"] } tower-layer = { workspace = true, public = true } tower-service = { workspace = true, public = true } diff --git a/libs/problematic/rust/CHANGELOG.md b/libs/problematic/rust/CHANGELOG.md new file mode 100644 index 00000000000..06730371150 --- /dev/null +++ b/libs/problematic/rust/CHANGELOG.md @@ -0,0 +1,5 @@ +# Change Log + +## 0.1.0 - Unreleased + +- Initial release diff --git a/libs/problematic/rust/Cargo.toml b/libs/problematic/rust/Cargo.toml new file mode 100644 index 00000000000..f1c8f048506 --- /dev/null +++ b/libs/problematic/rust/Cargo.toml @@ -0,0 +1,53 @@ +[package] +name = "problematic" +version = "0.0.0" +authors.workspace = true +edition.workspace = true +description = "HTTP Problem Details with typed extensions and JSON Schema support" +license = "MIT OR Apache-2.0" +documentation = "https://docs.rs/problematic" +repository = "https://github.com/hashintel/hash/tree/main/libs/problematic/rust" +exclude = ["package.json", "turbo.json", "docs/task-dependencies.json"] + +[dependencies] +# Public workspace dependencies + +# Public third-party dependencies +http = { workspace = true, public = true } + +# Public third-party dependencies (optional) +schemars = { workspace = true, public = true, optional = true } +serde_core = { workspace = true, public = true, optional = true } + +# Private workspace dependencies + +# Private third-party dependencies +serde = { workspace = true, optional = true, features = ["alloc", "derive"] } + +[dev-dependencies] +insta = { workspace = true, features = ["json"] } +serde_json = { workspace = true, features = ["arbitrary_precision"] } + +[[test]] +name = "extensions" +required-features = ["serde"] + +[[test]] +name = "problem_details" +required-features = ["serde"] + +[[test]] +name = "schema" +required-features = ["schemars"] + +[features] +schemars = ["dep:schemars"] +serde = ["dep:serde_core", "dep:serde"] + +[lints] +workspace = true + +[package.metadata.docs.rs] +all-features = true +cargo-args = ["-Z", "unstable-options", "-Z", "rustdoc-scrape-examples"] +targets = ["x86_64-unknown-linux-gnu"] diff --git a/libs/problematic/rust/LICENSE-APACHE.md b/libs/problematic/rust/LICENSE-APACHE.md new file mode 100644 index 00000000000..1d1b6f8da4d --- /dev/null +++ b/libs/problematic/rust/LICENSE-APACHE.md @@ -0,0 +1,189 @@ +# Apache License + +_Version 2.0, January 2004_ +_<>_ + +### Terms and Conditions for use, reproduction, and distribution + +#### 1. Definitions + +“License” shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +“Licensor” shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +“Legal Entity” shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, “control” means **(i)** the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the +outstanding shares, or **(iii)** beneficial ownership of such entity. + +“You” (or “Your”) shall mean an individual or Legal Entity exercising +permissions granted by this License. + +“Source” form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +“Object” form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +“Work” shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +“Derivative Works” shall mean any work, whether in Source or Object form, that +is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +“Contribution” shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work +by the copyright owner or by an individual or Legal Entity authorized to submit +on behalf of the copyright owner. For the purposes of this definition, +“submitted” means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor for +the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as “Not a Contribution.” + +“Contributor” shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently +incorporated within the Work. + +#### 2. Grant of Copyright License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the Work and such +Derivative Works in Source or Object form. + +#### 3. Grant of Patent License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable (except as stated in this section) patent license to make, have +made, use, offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such Contributor +that are necessarily infringed by their Contribution(s) alone or by combination +of their Contribution(s) with the Work to which such Contribution(s) was +submitted. If You institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work or a +Contribution incorporated within the Work constitutes direct or contributory +patent infringement, then any patent licenses granted to You under this License +for that Work shall terminate as of the date such litigation is filed. + +#### 4. Redistribution + +You may reproduce and distribute copies of the Work or Derivative Works thereof +in any medium, with or without modifications, and in Source or Object form, +provided that You meet the following conditions: + +- **(a)** You must give any other recipients of the Work or Derivative Works a copy of + this License; and +- **(b)** You must cause any modified files to carry prominent notices stating that You + changed the files; and +- **(c)** You must retain, in the Source form of any Derivative Works that You distribute, + all copyright, patent, trademark, and attribution notices from the Source form + of the Work, excluding those notices that do not pertain to any part of the + Derivative Works; and +- **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any + Derivative Works that You distribute must include a readable copy of the + attribution notices contained within such NOTICE file, excluding those notices + that do not pertain to any part of the Derivative Works, in at least one of the + following places: within a NOTICE text file distributed as part of the + Derivative Works; within the Source form or documentation, if provided along + with the Derivative Works; or, within a display generated by the Derivative + Works, if and wherever such third-party notices normally appear. The contents of + the NOTICE file are for informational purposes only and do not modify the + License. You may add Your own attribution notices within Derivative Works that + You distribute, alongside or as an addendum to the NOTICE text from the Work, + provided that such additional attribution notices cannot be construed as + modifying the License. + +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +#### 5. Submission of Contributions + +Unless You explicitly state otherwise, any Contribution intentionally submitted +for inclusion in the Work by You to the Licensor shall be under the terms and +conditions of this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify the terms of +any separate license agreement you may have executed with Licensor regarding +such Contributions. + +#### 6. Trademarks + +This License does not grant permission to use the trade names, trademarks, +service marks, or product names of the Licensor, except as required for +reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +#### 7. Disclaimer of Warranty + +Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an “AS IS” BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, +including, without limitation, any warranties or conditions of TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are +solely responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your exercise of +permissions under this License. + +#### 8. Limitation of Liability + +In no event and under no legal theory, whether in tort (including negligence), +contract, or otherwise, unless required by applicable law (such as deliberate +and grossly negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, incidental, +or consequential damages of any character arising as a result of this License or +out of the use or inability to use the Work (including but not limited to +damages for loss of goodwill, work stoppage, computer failure or malfunction, or +any and all other commercial damages or losses), even if such Contributor has +been advised of the possibility of such damages. + +#### 9. Accepting Warranty or Additional Liability + +While redistributing the Work or Derivative Works thereof, You may choose to +offer, and charge a fee for, acceptance of support, warranty, indemnity, or +other liability obligations and/or rights consistent with this License. However, +in accepting such obligations, You may act only on Your own behalf and on Your +sole responsibility, not on behalf of any other Contributor, and only if You +agree to indemnify, defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason of your +accepting any such warranty or additional liability. + +_END OF TERMS AND CONDITIONS_ + +### APPENDIX: Apply the Apache License to a specific file + +To apply the Apache License to an individual file, attach the following notice. +The text should be enclosed in the appropriate comment syntax for the file +format. + + Copyright © 2022–, HASH + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/libs/problematic/rust/LICENSE-MIT.md b/libs/problematic/rust/LICENSE-MIT.md new file mode 100644 index 00000000000..e33c1d34b0e --- /dev/null +++ b/libs/problematic/rust/LICENSE-MIT.md @@ -0,0 +1,21 @@ +# MIT License + +Copyright © 2022–, HASH + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/libs/problematic/rust/LICENSE.md b/libs/problematic/rust/LICENSE.md new file mode 100644 index 00000000000..8b31346dd55 --- /dev/null +++ b/libs/problematic/rust/LICENSE.md @@ -0,0 +1,5 @@ +# License + +Licensed under either of the [Apache License, Version 2.0](LICENSE-APACHE.md) or [MIT license](LICENSE-MIT.md) at your option. + +For more information about contributing to this crate, see our top-level [CONTRIBUTING](https://github.com/hashintel/hash/blob/main/.github/CONTRIBUTING.md) policy. diff --git a/libs/problematic/rust/README.md b/libs/problematic/rust/README.md new file mode 100644 index 00000000000..bac9a0b80ef --- /dev/null +++ b/libs/problematic/rust/README.md @@ -0,0 +1,22 @@ +# problematic + +HTTP Problem Details with typed extension members. + +## Features + +- `serde` enables serialization and deserialization, including borrowing strings from the input. +- `schemars` enables JSON Schema generation independently of `serde`. + +No features are enabled by default. + +## Contributors + +[HASH](https://hash.dev/) created and maintains `problematic`. Contributions are welcome. Follow the [contributing guide](https://github.com/hashintel/hash/blob/main/.github/CONTRIBUTING.md) to contribute. Ask questions in [GitHub Discussions](https://github.com/orgs/hashintel/discussions). + +## License + +`problematic` is available under either of the [Apache License, Version 2.0] or [MIT license] at your option. Please see the [LICENSE] file for more information. + +[Apache License, Version 2.0]: LICENSE-APACHE.md +[MIT license]: LICENSE-MIT.md +[LICENSE]: LICENSE.md diff --git a/libs/problematic/rust/docs/task-dependencies.json b/libs/problematic/rust/docs/task-dependencies.json new file mode 100644 index 00000000000..df0316a8f2c --- /dev/null +++ b/libs/problematic/rust/docs/task-dependencies.json @@ -0,0 +1,18 @@ +{ + "package": "@rust/problematic", + "dependencies": [], + "tasks": { + "lint:clippy": { + "dependsOn": [], + "env": [ + "GITHUB_EVENT_NAME" + ] + }, + "test:unit": { + "dependsOn": [], + "env": [ + "TEST_COVERAGE" + ] + } + } +} diff --git a/libs/problematic/rust/package.json b/libs/problematic/rust/package.json new file mode 100644 index 00000000000..718c1913083 --- /dev/null +++ b/libs/problematic/rust/package.json @@ -0,0 +1,11 @@ +{ + "name": "@rust/problematic", + "version": "0.0.0", + "private": true, + "description": "HTTP Problem Details with typed extensions and JSON Schema support", + "license": "MIT OR Apache-2.0", + "scripts": { + "lint:clippy": "just clippy", + "test:unit": "mise run test:unit @rust/problematic" + } +} diff --git a/libs/problematic/rust/src/lib.rs b/libs/problematic/rust/src/lib.rs new file mode 100644 index 00000000000..add395312c3 --- /dev/null +++ b/libs/problematic/rust/src/lib.rs @@ -0,0 +1,23 @@ +//! HTTP Problem Details with typed extension members. +//! +//! [`ProblemType`] describes a problem's shared metadata. [`ProblemDetails`] represents an +//! occurrence as a JSON object, with extension members alongside the standard fields. +//! +//! The optional `serde` feature enables serialization and deserialization. The `schemars` feature +//! independently adds JSON Schema support to [`ProblemDetails`] and [`NoExtensions`]. + +#![cfg_attr(doc, feature(doc_cfg))] + +extern crate alloc; + +mod problem_details; +mod problem_type; +#[cfg(feature = "serde")] +mod serde; + +pub use http::StatusCode; + +pub use self::{ + problem_details::{NoExtensions, ProblemDetails}, + problem_type::ProblemType, +}; diff --git a/libs/problematic/rust/src/problem_details.rs b/libs/problematic/rust/src/problem_details.rs new file mode 100644 index 00000000000..872b2e16877 --- /dev/null +++ b/libs/problematic/rust/src/problem_details.rs @@ -0,0 +1,118 @@ +use alloc::borrow::Cow; + +#[cfg(feature = "serde")] +use ::serde::{Deserialize, Serialize}; + +#[cfg(feature = "serde")] +use crate::serde::{deserialize_optional_cow, serialize_extensions}; + +/// An empty object for problem types without extensions. +#[derive(Debug, Clone, Copy)] +#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +#[expect( + clippy::empty_structs_with_brackets, + reason = "The empty struct must serialize as an object." +)] +pub struct NoExtensions {} + +#[cfg(any(feature = "serde", feature = "schemars"))] +const fn default_type_uri() -> Cow<'static, str> { + Cow::Borrowed("about:blank") +} + +/// An RFC 9457 problem details object with problem-specific extension members. +/// +/// Serialization includes `type`, `title`, and `status`, plus `detail` and `instance` when +/// supplied. +#[derive(Debug, Clone)] +#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr( + feature = "schemars", + derive(schemars::JsonSchema), + schemars(title = "Problem Details") +)] +pub struct ProblemDetails<'a, E> { + /// A URI reference identifying the problem type. Use `about:blank` when the HTTP status code + /// fully describes the problem type. If `type` is omitted during deserialization, it defaults + /// to `about:blank`. + #[cfg_attr( + any(feature = "serde", feature = "schemars"), + serde(rename = "type", borrow, default = "default_type_uri") + )] + #[cfg_attr( + feature = "schemars", + schemars( + extend("format" = "uri-reference"), + example = "https://example.com/problems/wrong-actor-type" + ) + )] + pub type_uri: Cow<'a, str>, + + /// A short, human-readable summary of the problem type. Keep it the same across occurrences, + /// except for localization. + #[cfg_attr(any(feature = "serde", feature = "schemars"), serde(borrow))] + #[cfg_attr(feature = "schemars", schemars(example = "Wrong actor type"))] + pub title: Cow<'a, str>, + + /// The HTTP status code sent with this occurrence. + #[cfg_attr( + feature = "schemars", + schemars(range(min = 100, max = 599), example = 403) + )] + pub status: u16, + + /// A human-readable explanation of this occurrence that helps the client correct the problem. + /// Use extension members for structured information. + #[cfg_attr( + any(feature = "serde", feature = "schemars"), + serde( + borrow, + default, + skip_serializing_if = "Option::is_none", + deserialize_with = "deserialize_optional_cow" + ) + )] + #[cfg_attr( + feature = "schemars", + schemars(required, example = "This operation requires a machine actor.") + )] + pub detail: Option>, + + /// A URI reference identifying this occurrence. It may identify the occurrence without + /// resolving to further information. + #[cfg_attr( + any(feature = "serde", feature = "schemars"), + serde( + borrow, + default, + skip_serializing_if = "Option::is_none", + deserialize_with = "deserialize_optional_cow" + ) + )] + #[cfg_attr( + feature = "schemars", + schemars( + required, + extend("format" = "uri-reference"), + example = "https://example.com/problem-occurrences/42" + ) + )] + pub instance: Option>, + + /// Problem-specific members included alongside the standard fields. + /// + /// Serialization fails for non-object values or top-level members named `type`, `title`, + /// `status`, `detail`, or `instance`. Nested members may use these names. Errors from the + /// extension serializer propagate. The extension type must support Serde flattening for + /// deserialization. + #[cfg_attr( + any(feature = "serde", feature = "schemars"), + serde( + flatten, + serialize_with = "serialize_extensions", + bound(serialize = "E: Serialize") + ) + )] + pub extensions: E, +} diff --git a/libs/problematic/rust/src/problem_type.rs b/libs/problematic/rust/src/problem_type.rs new file mode 100644 index 00000000000..a4a405a37d0 --- /dev/null +++ b/libs/problematic/rust/src/problem_type.rs @@ -0,0 +1,26 @@ +use alloc::borrow::Cow; + +use crate::StatusCode; + +/// Metadata shared by occurrences of a problem type. +/// +/// ``` +/// use std::borrow::Cow; +/// +/// use problematic::{ProblemType, StatusCode}; +/// +/// const WRONG_ACTOR_TYPE: ProblemType = ProblemType { +/// type_uri: Cow::Borrowed("https://example.com/problems/wrong-actor-type"), +/// title: Cow::Borrowed("Wrong actor type"), +/// status: StatusCode::FORBIDDEN, +/// }; +/// ``` +#[derive(Debug)] +pub struct ProblemType { + /// The stable URI identifying this problem type. + pub type_uri: Cow<'static, str>, + /// The title shared by occurrences of this problem type. + pub title: Cow<'static, str>, + /// The HTTP status code for occurrences of this problem type. + pub status: StatusCode, +} diff --git a/libs/problematic/rust/src/serde/mod.rs b/libs/problematic/rust/src/serde/mod.rs new file mode 100644 index 00000000000..0e75fd9b3b1 --- /dev/null +++ b/libs/problematic/rust/src/serde/mod.rs @@ -0,0 +1,23 @@ +use alloc::borrow::Cow; + +use serde::{Deserialize, Deserializer}; + +mod serialization; + +pub(crate) use self::serialization::serialize_extensions; + +// Serde enables borrowing for a direct Cow field, but not for Cow nested inside Option. +#[derive(Deserialize)] +#[serde(transparent)] +struct BorrowCow<'a>(#[serde(borrow)] Cow<'a, str>); + +/// Borrows optional strings when the deserializer can lend them. +/// +/// # Errors +/// +/// Returns the deserializer's error if the value is neither a string nor null. +pub(crate) fn deserialize_optional_cow<'de: 'a, 'a, D: Deserializer<'de>>( + deserializer: D, +) -> Result>, D::Error> { + Option::>::deserialize(deserializer).map(|value| value.map(|value| value.0)) +} diff --git a/libs/problematic/rust/src/serde/serialization/key.rs b/libs/problematic/rust/src/serde/serialization/key.rs new file mode 100644 index 00000000000..8bac3e26535 --- /dev/null +++ b/libs/problematic/rust/src/serde/serialization/key.rs @@ -0,0 +1,165 @@ +use alloc::string::String; +use core::fmt::{Display, Write as _}; + +use serde_core::{Serialize, Serializer, ser::Error as _}; + +use super::{ExtensionKey, check_member}; + +impl Serialize for ExtensionKey<'_, T> { + fn serialize(&self, serializer: S) -> Result { + self.0.serialize(KeySerializer(serializer)) + } +} + +struct KeySerializer(S); + +macro_rules! forward_scalar { + ($($method:ident($type:ty)),* $(,)?) => { + $( + fn $method(self, value: $type) -> Result { + self.0.$method(value) + } + )* + }; +} + +impl Serializer for KeySerializer { + type Error = S::Error; + type Ok = S::Ok; + type SerializeMap = S::SerializeMap; + type SerializeSeq = S::SerializeSeq; + type SerializeStruct = S::SerializeStruct; + type SerializeStructVariant = S::SerializeStructVariant; + type SerializeTuple = S::SerializeTuple; + type SerializeTupleStruct = S::SerializeTupleStruct; + type SerializeTupleVariant = S::SerializeTupleVariant; + + forward_scalar! { + serialize_bool(bool), + serialize_i8(i8), + serialize_i16(i16), + serialize_i32(i32), + serialize_i64(i64), + serialize_i128(i128), + serialize_u8(u8), + serialize_u16(u16), + serialize_u32(u32), + serialize_u64(u64), + serialize_u128(u128), + serialize_f32(f32), + serialize_f64(f64), + serialize_char(char), + serialize_bytes(&[u8]), + } + + fn serialize_str(self, v: &str) -> Result { + check_member::(v)?; + self.0.serialize_str(v) + } + + fn serialize_none(self) -> Result { + self.0.serialize_none() + } + + fn serialize_some(self, value: &T) -> Result { + self.0.serialize_some(&ExtensionKey(value)) + } + + fn serialize_unit(self) -> Result { + self.0.serialize_unit() + } + + fn serialize_unit_struct(self, name: &'static str) -> Result { + self.0.serialize_unit_struct(name) + } + + fn serialize_unit_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + ) -> Result { + check_member::(variant)?; + self.0.serialize_unit_variant(name, variant_index, variant) + } + + fn serialize_newtype_struct( + self, + name: &'static str, + value: &T, + ) -> Result { + self.0.serialize_newtype_struct(name, &ExtensionKey(value)) + } + + fn serialize_newtype_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + value: &T, + ) -> Result { + self.0 + .serialize_newtype_variant(name, variant_index, variant, value) + } + + fn serialize_seq(self, len: Option) -> Result { + self.0.serialize_seq(len) + } + + fn serialize_tuple(self, len: usize) -> Result { + self.0.serialize_tuple(len) + } + + fn serialize_tuple_struct( + self, + name: &'static str, + len: usize, + ) -> Result { + self.0.serialize_tuple_struct(name, len) + } + + fn serialize_tuple_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result { + self.0 + .serialize_tuple_variant(name, variant_index, variant, len) + } + + fn serialize_map(self, len: Option) -> Result { + self.0.serialize_map(len) + } + + fn serialize_struct( + self, + name: &'static str, + len: usize, + ) -> Result { + self.0.serialize_struct(name, len) + } + + fn serialize_struct_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result { + self.0 + .serialize_struct_variant(name, variant_index, variant, len) + } + + fn collect_str(self, value: &T) -> Result { + // Format once so that validation checks the exact key passed to the serializer. + let mut key = String::new(); + write!(&mut key, "{value}").map_err(Self::Error::custom)?; + self.serialize_str(&key) + } + + fn is_human_readable(&self) -> bool { + self.0.is_human_readable() + } +} diff --git a/libs/problematic/rust/src/serde/serialization/mod.rs b/libs/problematic/rust/src/serde/serialization/mod.rs new file mode 100644 index 00000000000..286cd7cb366 --- /dev/null +++ b/libs/problematic/rust/src/serde/serialization/mod.rs @@ -0,0 +1,238 @@ +use core::fmt::Display; + +use serde_core::{ + Serialize, Serializer, + ser::{Error, Impossible, SerializeMap, SerializeStruct}, +}; + +mod key; + +struct ExtensionKey<'a, T: ?Sized>(&'a T); + +/// Checks extension member names while serializing an object. +/// +/// # Errors +/// +/// Returns an error for non-object extensions, reserved member names, or serializer failures. +pub(crate) fn serialize_extensions( + extensions: &E, + serializer: S, +) -> Result { + extensions.serialize(ExtensionSerializer(serializer)) +} + +fn check_member(name: &str) -> Result<(), E> { + if matches!(name, "type" | "title" | "status" | "detail" | "instance") { + return Err(E::custom(format_args!( + "problem extension `{name}` conflicts with a standard member" + ))); + } + Ok(()) +} + +#[inline] +fn non_object_error() -> E { + E::custom("problem extensions must serialize as an object") +} + +struct ExtensionSerializer(S); + +macro_rules! reject_scalar { + ($($method:ident($type:ty)),* $(,)?) => { + $( + fn $method(self, _: $type) -> Result { + Err(non_object_error()) + } + )* + }; +} + +impl Serializer for ExtensionSerializer { + type Error = S::Error; + type Ok = S::Ok; + type SerializeMap = ExtensionMembers; + type SerializeSeq = Impossible; + type SerializeStruct = ExtensionMembers; + type SerializeStructVariant = S::SerializeStructVariant; + type SerializeTuple = Impossible; + type SerializeTupleStruct = Impossible; + type SerializeTupleVariant = S::SerializeTupleVariant; + + reject_scalar! { + serialize_bool(bool), + serialize_i8(i8), + serialize_i16(i16), + serialize_i32(i32), + serialize_i64(i64), + serialize_i128(i128), + serialize_u8(u8), + serialize_u16(u16), + serialize_u32(u32), + serialize_u64(u64), + serialize_u128(u128), + serialize_f32(f32), + serialize_f64(f64), + serialize_char(char), + serialize_bytes(&[u8]), + serialize_str(&str), + } + + fn serialize_none(self) -> Result { + Err(non_object_error()) + } + + fn serialize_some(self, value: &T) -> Result { + value.serialize(self) + } + + fn serialize_unit(self) -> Result { + Err(non_object_error()) + } + + fn serialize_unit_struct(self, _: &'static str) -> Result { + Err(non_object_error()) + } + + fn serialize_unit_variant( + self, + _: &'static str, + _: u32, + _: &'static str, + ) -> Result { + Err(non_object_error()) + } + + fn serialize_newtype_struct( + self, + _: &'static str, + value: &T, + ) -> Result { + value.serialize(self) + } + + fn serialize_newtype_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + value: &T, + ) -> Result { + check_member::(variant)?; + self.0 + .serialize_newtype_variant(name, variant_index, variant, value) + } + + fn serialize_seq(self, _: Option) -> Result { + Err(non_object_error()) + } + + fn serialize_tuple(self, _: usize) -> Result { + Err(non_object_error()) + } + + fn serialize_tuple_struct( + self, + _: &'static str, + _: usize, + ) -> Result { + Err(non_object_error()) + } + + fn serialize_tuple_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result { + check_member::(variant)?; + self.0 + .serialize_tuple_variant(name, variant_index, variant, len) + } + + fn serialize_map(self, len: Option) -> Result { + self.0.serialize_map(len).map(ExtensionMembers) + } + + fn serialize_struct( + self, + name: &'static str, + len: usize, + ) -> Result { + // With arbitrary_precision, serde_json represents numbers as private structs. + // Flattening would emit the marker field instead of rejecting the number. + if name == "$serde_json::private::Number" { + return Err(non_object_error()); + } + self.0.serialize_struct(name, len).map(ExtensionMembers) + } + + fn serialize_struct_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result { + check_member::(variant)?; + self.0 + .serialize_struct_variant(name, variant_index, variant, len) + } + + fn collect_str(self, _: &T) -> Result { + Err(non_object_error()) + } + + fn is_human_readable(&self) -> bool { + self.0.is_human_readable() + } +} + +struct ExtensionMembers(S); + +impl SerializeStruct for ExtensionMembers { + type Error = S::Error; + type Ok = S::Ok; + + fn serialize_field( + &mut self, + key: &'static str, + value: &T, + ) -> Result<(), Self::Error> { + check_member::(key)?; + self.0.serialize_field(key, value) + } + + fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> { + self.0.skip_field(key) + } + + fn end(self) -> Result { + self.0.end() + } +} + +impl SerializeMap for ExtensionMembers { + type Error = S::Error; + type Ok = S::Ok; + + fn serialize_key(&mut self, key: &T) -> Result<(), Self::Error> { + self.0.serialize_key(&ExtensionKey(key)) + } + + fn serialize_value(&mut self, value: &T) -> Result<(), Self::Error> { + self.0.serialize_value(value) + } + + fn serialize_entry( + &mut self, + key: &K, + value: &V, + ) -> Result<(), Self::Error> { + self.0.serialize_entry(&ExtensionKey(key), value) + } + + fn end(self) -> Result { + self.0.end() + } +} diff --git a/libs/problematic/rust/tests/extensions.rs b/libs/problematic/rust/tests/extensions.rs new file mode 100644 index 00000000000..e0d3bd41160 --- /dev/null +++ b/libs/problematic/rust/tests/extensions.rs @@ -0,0 +1,344 @@ +extern crate alloc; + +use alloc::{borrow::Cow, format}; +use core::{cell::Cell, fmt}; + +use problematic::ProblemDetails; +use serde::{ + Serialize, Serializer, + ser::{Error as _, SerializeMap as _}, +}; +use serde_json::{Number, Value, json}; + +const fn details(extensions: E) -> ProblemDetails<'static, E> { + ProblemDetails { + type_uri: Cow::Borrowed("about:blank"), + title: Cow::Borrowed("Bad Request"), + status: 400, + detail: None, + instance: None, + extensions, + } +} + +fn assert_serialization_error(extensions: E, expected: &str) { + let details = details(extensions); + let string_error = serde_json::to_string(&details) + .expect_err("the invalid extensions should fail to serialize to a string"); + let value_error = serde_json::to_value(&details) + .expect_err("the invalid extensions should fail to serialize to a value"); + assert_eq!( + string_error.to_string(), + expected, + "the string error should explain the failure" + ); + assert_eq!( + value_error.to_string(), + expected, + "the value error should explain the failure" + ); +} + +fn assert_serialization(extensions: E, expected: &Value) { + let details = details(extensions); + let encoded = + serde_json::to_string(&details).expect("the extensions should serialize to a string"); + assert_eq!( + serde_json::from_str::(&encoded).expect("the document should be valid JSON"), + *expected, + "the string should contain the expected problem document" + ); + assert_eq!( + serde_json::to_value(&details).expect("the extensions should serialize to a value"), + *expected, + "the value should contain the expected problem document" + ); +} + +#[test] +fn extensions_reserved_map_members() { + for name in ["type", "title", "status", "detail", "instance"] { + assert_serialization_error( + json!({name: "invalid"}), + &format!("problem extension `{name}` conflicts with a standard member"), + ); + } +} + +#[test] +fn extensions_reserved_struct_members() { + #[derive(Serialize)] + struct Extensions { + #[serde(rename = "status", skip_serializing_if = "Option::is_none")] + code: Option, + } + + assert_serialization_error( + Extensions { code: Some(499) }, + "problem extension `status` conflicts with a standard member", + ); + assert_serialization( + Extensions { code: None }, + &json!({"type": "about:blank", "title": "Bad Request", "status": 400}), + ); +} + +#[test] +fn extensions_nested_members() { + assert_serialization( + json!({"context": {"type": "context", "title": "Context", "status": 1, "detail": "nested", "instance": "nested"}}), + &json!({"type": "about:blank", "title": "Bad Request", "status": 400, + "context": {"type": "context", "title": "Context", "status": 1, "detail": "nested", "instance": "nested"}}), + ); +} + +#[test] +fn extensions_wrapped_objects() { + #[derive(Serialize)] + struct Wrapped(T); + + assert_serialization( + Some(Wrapped(json!({"parameter": "limit"}))), + &json!({"type": "about:blank", "title": "Bad Request", "status": 400, "parameter": "limit"}), + ); + assert_serialization_error( + Wrapped(json!({"title": "invalid"})), + "problem extension `title` conflicts with a standard member", + ); + assert_serialization_error( + Wrapped(42), + "problem extensions must serialize as an object", + ); +} + +#[test] +fn extensions_non_objects() { + for value in [ + json!(null), + json!(true), + json!(42), + json!(1.5), + json!("invalid"), + json!([]), + ] { + assert_serialization_error(value, "problem extensions must serialize as an object"); + } + assert_serialization_error(None::, "problem extensions must serialize as an object"); + assert_serialization_error((), "problem extensions must serialize as an object"); + assert_serialization_error((1, 2), "problem extensions must serialize as an object"); +} + +#[test] +fn extensions_number_members() { + #[derive(Serialize)] + struct Extensions { + count: Number, + } + + assert_serialization( + Extensions { + count: Number::from(42), + }, + &json!({"type": "about:blank", "title": "Bad Request", "status": 400, "count": 42}), + ); +} + +#[test] +fn extensions_enum_members() { + #[derive(Serialize)] + enum Extensions { + #[serde(rename = "context")] + Context { + status: u16, + }, + #[serde(rename = "type")] + Newtype(u16), + #[serde(rename = "detail")] + Tuple(u16, u16), + #[serde(rename = "instance")] + Struct { + value: u16, + }, + Unit, + } + + assert_serialization( + Extensions::Context { status: 42 }, + &json!({"type": "about:blank", "title": "Bad Request", "status": 400, "context": {"status": 42}}), + ); + for (extensions, name) in [ + (Extensions::Newtype(1), "type"), + (Extensions::Tuple(1, 2), "detail"), + (Extensions::Struct { value: 1 }, "instance"), + ] { + assert_serialization_error( + extensions, + &format!("problem extension `{name}` conflicts with a standard member"), + ); + } + assert_serialization_error( + Extensions::Unit, + "problem extensions must serialize as an object", + ); +} + +struct Entry { + key: K, + split: bool, +} + +impl Serialize for Entry { + fn serialize(&self, serializer: S) -> Result { + let mut map = serializer.serialize_map(Some(1))?; + if self.split { + map.serialize_key(&self.key)?; + map.serialize_value(&42)?; + } else { + map.serialize_entry(&self.key, &42)?; + } + map.end() + } +} + +struct FormattedKey<'a>(&'a str); + +impl Serialize for FormattedKey<'_> { + fn serialize(&self, serializer: S) -> Result { + serializer.collect_str(self.0) + } +} + +#[test] +fn extensions_map_key_representations() { + #[derive(Serialize)] + struct WrappedKey(&'static str); + + #[derive(Serialize)] + enum Key { + #[serde(rename = "status")] + Status, + } + + for split in [false, true] { + let expected = "problem extension `status` conflicts with a standard member"; + assert_serialization_error( + Entry { + key: "status", + split, + }, + expected, + ); + assert_serialization_error( + Entry { + key: WrappedKey("status"), + split, + }, + expected, + ); + assert_serialization_error( + Entry { + key: Key::Status, + split, + }, + expected, + ); + assert_serialization_error( + Entry { + key: FormattedKey("status"), + split, + }, + expected, + ); + assert_serialization( + Entry { + key: FormattedKey("parameter"), + split, + }, + &json!({"type": "about:blank", "title": "Bad Request", "status": 400, "parameter": 42}), + ); + } +} + +struct CountedKey<'a>(&'a Cell); + +impl Serialize for CountedKey<'_> { + fn serialize(&self, serializer: S) -> Result { + let previous = self.0.replace(self.0.get() + 1); + serializer.serialize_str(if previous == 0 { "parameter" } else { "status" }) + } +} + +#[test] +fn extensions_map_key_once() { + for split in [false, true] { + let calls = Cell::new(0); + let details = details(Entry { + key: CountedKey(&calls), + split, + }); + let encoded = serde_json::to_string(&details).expect("the key should serialize once"); + assert_eq!(calls.get(), 1, "the key should serialize exactly once"); + assert_eq!( + serde_json::from_str::(&encoded).expect("the document should be valid JSON") + ["parameter"], + 42, + "the emitted key should match the validated key" + ); + calls.set(0); + let value = serde_json::to_value(&details).expect("the key should serialize once"); + assert_eq!(calls.get(), 1, "the key should serialize exactly once"); + assert_eq!( + value["parameter"], 42, + "the emitted key should match the validated key" + ); + } +} + +struct BrokenExtensions; + +impl Serialize for BrokenExtensions { + fn serialize(&self, _: S) -> Result { + Err(S::Error::custom("extension serialization failed")) + } +} + +#[test] +fn extensions_serializer_failures() { + #[derive(Serialize)] + struct Nested { + context: BrokenExtensions, + } + + assert_serialization_error(BrokenExtensions, "extension serialization failed"); + assert_serialization_error( + Nested { + context: BrokenExtensions, + }, + "extension serialization failed", + ); +} + +struct BrokenFormat; + +impl fmt::Display for BrokenFormat { + fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result { + Err(fmt::Error) + } +} + +impl Serialize for BrokenFormat { + fn serialize(&self, serializer: S) -> Result { + serializer.collect_str(self) + } +} + +#[test] +fn extensions_key_format_failure() { + assert_serialization_error( + Entry { + key: BrokenFormat, + split: false, + }, + &fmt::Error.to_string(), + ); +} diff --git a/libs/problematic/rust/tests/problem_details.rs b/libs/problematic/rust/tests/problem_details.rs new file mode 100644 index 00000000000..6857addc5b8 --- /dev/null +++ b/libs/problematic/rust/tests/problem_details.rs @@ -0,0 +1,359 @@ +extern crate alloc; + +use alloc::{borrow::Cow, string::String, vec::Vec}; + +use problematic::{NoExtensions, ProblemDetails, ProblemType, StatusCode}; +use serde::{Deserialize, Serialize}; +use serde_json::json; + +#[derive(Serialize, Deserialize)] +struct InvalidParameters { + parameters: Vec, +} + +#[test] +fn details_typed_extensions() { + let body = json!({ + "type": "https://example.com/problems/invalid-parameters", + "title": "Invalid parameters", + "status": 400, + "detail": "The limit must be a positive integer.", + "instance": "https://example.com/problem-occurrences/42", + "parameters": ["limit"] + }); + let encoded = serde_json::to_string(&body).expect("the response should serialize"); + let details: ProblemDetails<'_, InvalidParameters> = serde_json::from_str(&encoded) + .expect("the response should deserialize with typed extensions"); + assert_eq!( + details.extensions.parameters, + ["limit"], + "the extension should retain its typed fields" + ); + assert_eq!( + serde_json::to_value(details).expect("the details should serialize"), + body, + "the roundtrip should preserve standard fields and flattened extensions" + ); +} + +#[test] +fn details_empty_extensions() { + let body = json!({"type": "about:blank", "title": "Internal Server Error", "status": 500}); + let encoded = serde_json::to_string(&body).expect("the response should serialize"); + let details: ProblemDetails<'_, NoExtensions> = + serde_json::from_str(&encoded).expect("the response should deserialize without extensions"); + assert_eq!( + serde_json::to_value(details).expect("the details should serialize"), + body, + "the roundtrip should preserve omitted occurrence fields" + ); +} + +#[test] +fn details_default_type() { + let encoded = r#"{"title":"Internal Server Error","status":500}"#; + let details: ProblemDetails<'_, NoExtensions> = + serde_json::from_str(encoded).expect("the response should deserialize without a type"); + + assert!(matches!(details.type_uri, Cow::Borrowed("about:blank"))); + assert_eq!( + serde_json::to_value(details).expect("the details should serialize"), + json!({"type": "about:blank", "title": "Internal Server Error", "status": 500}) + ); +} + +#[test] +fn details_invalid_type() { + for (type_uri, expected) in [ + (json!(null), "invalid type: null, expected a string"), + (json!(42), "invalid type: number, expected a string"), + ] { + let body = json!({"type": type_uri, "title": "Internal Server Error", "status": 500}); + let error = ProblemDetails::<'_, NoExtensions>::deserialize(body) + .expect_err("the non-string type should fail to deserialize"); + + assert_eq!(error.to_string(), expected); + } +} + +#[test] +fn details_borrowed_fields() { + let type_uri = String::from("https://example.com/problems/invalid-parameters"); + let title = String::from("Invalid parameters"); + let detail = String::from("The limit must be a positive integer."); + let instance = String::from("https://example.com/problem-occurrences/42"); + let details = ProblemDetails { + type_uri: Cow::Borrowed(&type_uri), + title: Cow::Borrowed(&title), + status: 400, + detail: Some(Cow::Borrowed(&detail)), + instance: Some(Cow::Borrowed(&instance)), + extensions: NoExtensions {}, + }; + + assert_eq!( + serde_json::to_value(&details).expect("the borrowed details should serialize"), + json!({ + "type": type_uri, + "title": title, + "status": 400, + "detail": detail, + "instance": instance + }), + "the borrowed fields should retain their contents" + ); +} + +#[test] +fn details_static_metadata() { + const INVALID_PARAMETERS: ProblemType = ProblemType { + type_uri: Cow::Borrowed("https://example.com/problems/invalid-parameters"), + title: Cow::Borrowed("Invalid parameters"), + status: StatusCode::BAD_REQUEST, + }; + + let detail = String::from("The limit must be a positive integer."); + let instance = String::from("https://example.com/problem-occurrences/42"); + let details = ProblemDetails { + type_uri: INVALID_PARAMETERS.type_uri.clone(), + title: INVALID_PARAMETERS.title.clone(), + status: INVALID_PARAMETERS.status.as_u16(), + detail: Some(Cow::Borrowed(&detail)), + instance: Some(Cow::Borrowed(&instance)), + extensions: NoExtensions {}, + }; + + assert_eq!( + serde_json::to_value(&details).expect("the mixed-lifetime details should serialize"), + json!({ + "type": "https://example.com/problems/invalid-parameters", + "title": "Invalid parameters", + "status": 400, + "detail": detail, + "instance": instance + }), + "the static and local fields should retain their contents" + ); +} + +#[test] +fn details_borrowed_deserialize() { + let body = json!({ + "type": "https://example.com/problems/invalid-parameters", + "title": "Invalid parameters", + "status": 400, + "detail": "The limit must be a positive integer.", + "instance": "https://example.com/problem-occurrences/42" + }); + let encoded = serde_json::to_string(&body).expect("the response should serialize"); + let from_string: ProblemDetails<'_, NoExtensions> = + serde_json::from_str(&encoded).expect("the response should deserialize from a string"); + let from_slice: ProblemDetails<'_, NoExtensions> = serde_json::from_slice(encoded.as_bytes()) + .expect("the response should deserialize from a byte slice"); + + for details in [from_string, from_slice] { + assert!( + matches!(details.type_uri, Cow::Borrowed(_)) + && matches!(details.title, Cow::Borrowed(_)) + && matches!(details.detail, Some(Cow::Borrowed(_))) + && matches!(details.instance, Some(Cow::Borrowed(_))), + "the strings should be borrowed from the input" + ); + for text in [ + details.type_uri.as_ref(), + details.title.as_ref(), + details + .detail + .as_deref() + .expect("the response should contain a detail"), + details + .instance + .as_deref() + .expect("the response should contain an instance"), + ] { + assert!( + encoded.as_bytes().as_ptr_range().contains(&text.as_ptr()), + "the borrowed string should point into the original JSON buffer" + ); + } + assert_eq!( + serde_json::to_value(details).expect("the borrowed details should serialize"), + body, + "the borrowed fields should retain their contents" + ); + } +} + +#[test] +fn details_escaped_deserialize() { + let encoded = r#"{ + "type": "https:\/\/example.com/problems/invalid-parameters", + "title": "Invalid \u0070arameters", + "status": 400, + "detail": "The limit must be a positive \u0069nteger.", + "instance": "https:\/\/example.com/problem-occurrences/42" + }"#; + let body = json!({ + "type": "https://example.com/problems/invalid-parameters", + "title": "Invalid parameters", + "status": 400, + "detail": "The limit must be a positive integer.", + "instance": "https://example.com/problem-occurrences/42" + }); + let details: ProblemDetails<'_, NoExtensions> = + serde_json::from_str(encoded).expect("the escaped response should deserialize"); + + assert!( + matches!(details.type_uri, Cow::Owned(_)) + && matches!(details.title, Cow::Owned(_)) + && matches!(details.detail, Some(Cow::Owned(_))) + && matches!(details.instance, Some(Cow::Owned(_))), + "the decoded strings should be owned" + ); + assert_eq!( + serde_json::to_value(details).expect("the decoded details should serialize"), + body, + "the decoded fields should retain their contents" + ); +} + +#[test] +fn details_owned_deserialize() { + let body = json!({ + "type": "https://example.com/problems/invalid-parameters", + "title": "Invalid parameters", + "status": 400, + "detail": "The limit must be a positive integer.", + "instance": "https://example.com/problem-occurrences/42" + }); + let encoded = serde_json::to_string(&body).expect("the response should serialize"); + let from_value: ProblemDetails<'static, NoExtensions> = + ProblemDetails::deserialize(body.clone()) + .expect("the response should deserialize from a value"); + let mut deserializer = serde_json::Deserializer::from_reader(encoded.as_bytes()); + let from_reader: ProblemDetails<'static, NoExtensions> = + ProblemDetails::deserialize(&mut deserializer) + .expect("the response should deserialize from a reader"); + deserializer + .end() + .expect("the reader should contain a single response"); + drop(encoded); + + for details in [from_value, from_reader] { + assert!( + matches!(details.type_uri, Cow::Owned(_)) + && matches!(details.title, Cow::Owned(_)) + && matches!(details.detail, Some(Cow::Owned(_))) + && matches!(details.instance, Some(Cow::Owned(_))), + "the deserialized strings should be owned" + ); + assert_eq!( + serde_json::to_value(details).expect("the owned details should serialize"), + body, + "the owned fields should retain their contents" + ); + } +} + +#[test] +fn details_null_occurrence_fields() { + let details: ProblemDetails<'_, NoExtensions> = ProblemDetails::deserialize(json!({ + "type": "about:blank", + "title": "Bad Request", + "status": 400, + "detail": null, + "instance": null + })) + .expect("the null occurrence fields should deserialize"); + + assert!( + details.detail.is_none() && details.instance.is_none(), + "the null occurrence fields should be absent" + ); + assert_eq!( + serde_json::to_value(details).expect("the details should serialize"), + json!({"type": "about:blank", "title": "Bad Request", "status": 400}), + "the absent occurrence fields should be omitted" + ); +} + +#[test] +fn details_invalid_occurrence_fields() { + for name in ["detail", "instance"] { + let error = ProblemDetails::<'_, NoExtensions>::deserialize(json!({ + "type": "about:blank", + "title": "Bad Request", + "status": 400, + name: 42 + })) + .expect_err("the non-string occurrence field should fail to deserialize"); + + assert_eq!( + error.to_string(), + "invalid type: number, expected a string", + "the error should identify the unsupported occurrence field type" + ); + } +} + +#[test] +fn details_extensions_missing() { + let body = json!({"type": "about:blank", "title": "Bad Request", "status": 400}); + let error = ProblemDetails::<'_, InvalidParameters>::deserialize(body) + .err() + .expect("the missing extension field should fail to deserialize"); + + assert_eq!(error.to_string(), "missing field `parameters`"); +} + +#[test] +fn details_extensions_invalid_types() { + for (parameters, expected) in [ + (json!(null), "invalid type: null, expected a sequence"), + (json!(42), "invalid type: integer `42`, expected a sequence"), + (json!([42]), "invalid type: integer `42`, expected a string"), + ] { + let body = json!({ + "type": "about:blank", + "title": "Bad Request", + "status": 400, + "parameters": parameters + }); + let error = ProblemDetails::<'_, InvalidParameters>::deserialize(body) + .err() + .expect("the invalid extension field should fail to deserialize"); + + assert_eq!(error.to_string(), expected); + } +} + +#[test] +fn details_extensions_non_object_serialize() { + for extensions in [json!(42), json!("invalid"), json!(["invalid"])] { + let details = ProblemDetails { + type_uri: Cow::Borrowed("about:blank"), + title: Cow::Borrowed("Bad Request"), + status: 400, + detail: None, + instance: None, + extensions, + }; + let error = serde_json::to_value(&details) + .expect_err("the non-object extensions should fail to serialize"); + + assert_eq!( + error.to_string(), + "problem extensions must serialize as an object", + "the error should identify the unsupported extension shape" + ); + } +} + +#[test] +fn details_extensions_non_object_deserialize() { + let body = json!({"type": "about:blank", "title": "Bad Request", "status": 400}); + let error = ProblemDetails::<'_, u32>::deserialize(body) + .expect_err("the scalar extension type should fail to deserialize"); + + assert_eq!(error.to_string(), "can only flatten structs and maps"); +} diff --git a/libs/problematic/rust/tests/schema.rs b/libs/problematic/rust/tests/schema.rs new file mode 100644 index 00000000000..fa18fb9ce16 --- /dev/null +++ b/libs/problematic/rust/tests/schema.rs @@ -0,0 +1,70 @@ +extern crate alloc; + +use alloc::{string::String, vec::Vec}; + +use problematic::{NoExtensions, ProblemDetails}; +#[cfg(feature = "serde")] +use schemars::generate::SchemaSettings; +#[cfg(feature = "serde")] +use serde::Deserialize as _; +#[cfg(feature = "serde")] +use serde_json::json; + +#[derive(schemars::JsonSchema)] +struct InvalidParameters { + #[expect(dead_code, reason = "The test only generates the extension's schema.")] + parameters: Vec, +} + +macro_rules! assert_schema_snapshot { + ($type:ty) => {{ + let schema = schemars::schema_for!($type); + insta::assert_binary_snapshot!( + ".json", + serde_json::to_vec_pretty(&schema).expect("the schema should serialize") + ); + }}; +} + +#[test] +fn schema_base() { + assert_schema_snapshot!(ProblemDetails<'_, NoExtensions>); +} + +#[test] +fn schema_typed_extensions() { + assert_schema_snapshot!(ProblemDetails<'_, InvalidParameters>); +} + +#[cfg(feature = "serde")] +#[test] +fn schema_occurrence_members() { + let input = json!({"title": "Internal Server Error", "status": 500}); + let details: ProblemDetails<'_, NoExtensions> = ProblemDetails::deserialize(input.clone()) + .expect("the minimal response should deserialize"); + let output = serde_json::to_value(details).expect("the details should serialize"); + for (settings, document) in [ + (SchemaSettings::default(), input), + (SchemaSettings::default().for_serialize(), output), + ] { + let schema = settings + .into_generator() + .into_root_schema_for::>() + .to_value(); + let required = schema["required"] + .as_array() + .expect("the response schema should declare required members"); + let members = document + .as_object() + .expect("the response should be an object"); + assert_eq!(required.len(), members.len()); + for name in members.keys() { + assert!(required.contains(&json!(name))); + } + + for name in ["detail", "instance"] { + assert!(!required.contains(&json!(name))); + assert_eq!(schema["properties"][name]["type"], "string"); + } + } +} diff --git a/libs/problematic/rust/tests/snapshots/schema__schema_base.snap b/libs/problematic/rust/tests/snapshots/schema__schema_base.snap new file mode 100644 index 00000000000..c66a98a643d --- /dev/null +++ b/libs/problematic/rust/tests/snapshots/schema__schema_base.snap @@ -0,0 +1,7 @@ +--- +source: libs/problematic/rust/tests/schema.rs +assertion_line: 31 +expression: "serde_json :: to_vec_pretty(& schema).expect(\"the schema should serialize\")" +extension: json +snapshot_kind: binary +--- diff --git a/libs/problematic/rust/tests/snapshots/schema__schema_base.snap.json b/libs/problematic/rust/tests/snapshots/schema__schema_base.snap.json new file mode 100644 index 00000000000..b7f99b808f3 --- /dev/null +++ b/libs/problematic/rust/tests/snapshots/schema__schema_base.snap.json @@ -0,0 +1,53 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Problem Details", + "description": "An RFC 9457 problem details object with problem-specific extension members.\n\nSerialization includes `type`, `title`, and `status`, plus `detail` and `instance` when\nsupplied.", + "type": "object", + "properties": { + "detail": { + "description": "A human-readable explanation of this occurrence that helps the client correct the problem.\nUse extension members for structured information.", + "type": "string", + "examples": [ + "This operation requires a machine actor." + ] + }, + "instance": { + "description": "A URI reference identifying this occurrence. It may identify the occurrence without\nresolving to further information.", + "type": "string", + "format": "uri-reference", + "examples": [ + "https://example.com/problem-occurrences/42" + ] + }, + "status": { + "description": "The HTTP status code sent with this occurrence.", + "type": "integer", + "format": "uint16", + "examples": [ + 403 + ], + "maximum": 599, + "minimum": 100 + }, + "title": { + "description": "A short, human-readable summary of the problem type. Keep it the same across occurrences,\nexcept for localization.", + "type": "string", + "examples": [ + "Wrong actor type" + ] + }, + "type": { + "description": "A URI reference identifying the problem type. Use `about:blank` when the HTTP status code\nfully describes the problem type. If `type` is omitted during deserialization, it defaults\nto `about:blank`.", + "type": "string", + "format": "uri-reference", + "default": "about:blank", + "examples": [ + "https://example.com/problems/wrong-actor-type" + ] + } + }, + "required": [ + "title", + "status" + ] +} \ No newline at end of file diff --git a/libs/problematic/rust/tests/snapshots/schema__schema_typed_extensions.snap b/libs/problematic/rust/tests/snapshots/schema__schema_typed_extensions.snap new file mode 100644 index 00000000000..be56bee1d91 --- /dev/null +++ b/libs/problematic/rust/tests/snapshots/schema__schema_typed_extensions.snap @@ -0,0 +1,7 @@ +--- +source: libs/problematic/rust/tests/schema.rs +assertion_line: 36 +expression: "serde_json :: to_vec_pretty(& schema).expect(\"the schema should serialize\")" +extension: json +snapshot_kind: binary +--- diff --git a/libs/problematic/rust/tests/snapshots/schema__schema_typed_extensions.snap.json b/libs/problematic/rust/tests/snapshots/schema__schema_typed_extensions.snap.json new file mode 100644 index 00000000000..ed57bf5249c --- /dev/null +++ b/libs/problematic/rust/tests/snapshots/schema__schema_typed_extensions.snap.json @@ -0,0 +1,60 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Problem Details", + "description": "An RFC 9457 problem details object with problem-specific extension members.\n\nSerialization includes `type`, `title`, and `status`, plus `detail` and `instance` when\nsupplied.", + "type": "object", + "properties": { + "detail": { + "description": "A human-readable explanation of this occurrence that helps the client correct the problem.\nUse extension members for structured information.", + "type": "string", + "examples": [ + "This operation requires a machine actor." + ] + }, + "instance": { + "description": "A URI reference identifying this occurrence. It may identify the occurrence without\nresolving to further information.", + "type": "string", + "format": "uri-reference", + "examples": [ + "https://example.com/problem-occurrences/42" + ] + }, + "parameters": { + "type": "array", + "items": { + "type": "string" + } + }, + "status": { + "description": "The HTTP status code sent with this occurrence.", + "type": "integer", + "format": "uint16", + "examples": [ + 403 + ], + "maximum": 599, + "minimum": 100 + }, + "title": { + "description": "A short, human-readable summary of the problem type. Keep it the same across occurrences,\nexcept for localization.", + "type": "string", + "examples": [ + "Wrong actor type" + ] + }, + "type": { + "description": "A URI reference identifying the problem type. Use `about:blank` when the HTTP status code\nfully describes the problem type. If `type` is omitted during deserialization, it defaults\nto `about:blank`.", + "type": "string", + "format": "uri-reference", + "default": "about:blank", + "examples": [ + "https://example.com/problems/wrong-actor-type" + ] + } + }, + "required": [ + "title", + "status", + "parameters" + ] +} \ No newline at end of file diff --git a/yarn.lock b/yarn.lock index aa4bc29c9b4..7863fa6a9f4 100644 --- a/yarn.lock +++ b/yarn.lock @@ -15577,6 +15577,12 @@ __metadata: languageName: unknown linkType: soft +"@rust/problematic@workspace:libs/problematic/rust": + version: 0.0.0-use.local + resolution: "@rust/problematic@workspace:libs/problematic/rust" + languageName: unknown + linkType: soft + "@sec-ant/readable-stream@npm:^0.4.1": version: 0.4.1 resolution: "@sec-ant/readable-stream@npm:0.4.1"