Cannot deserialize struct variant using sequence

[szymek156]

Hello I've encounter following problem,

Having enum like this:

#[derive(Deserialize)]
enum Filter {
    EQ { property: String, value: String },
}

I cannot deserialize it using sequence:

#[derive(Deserialize)]
struct Req {
    filter: Filter,
}

let req: Req = serde_json::from_value(json!({
    "filter": {
        "EQ" : ["a", "b"]
    }
}).unwrap()

Error:

invalid type: sequence, expected struct variant

However extracting variant body to a struct, works well:

#[derive(Deserialize)]
struct EQ {
    property: String, value: String
}
#[derive(Deserialize)]
enum Filter {
    EQ(EQ),
}

// this doesn't panic:
let a: Req = serde_json::from_value(json!({
            "filter" : {
                "EQ": ["a", "b"]
            }
        }))
        .unwrap();

Used crates:

serde = { version = "1.0.130" }
serde_json = {version = "1.0.72" , features = ["preserve_order"]}

Full test for reproduction:

  #[test]
  fn deserialize_enum() {
      #[derive(Deserialize)]
      struct EQ {
          property: String,
          value: String,
      }
      #[derive(Deserialize)]
      enum FilterTuple {
          EQ(EQ),
      }

      #[derive(Deserialize)]
      enum FilterStruct {
          EQ { property: String, value: String },
      }

      #[derive(Deserialize)]
      struct Req {
          filter_tuple: FilterTuple,
          filter_struct: FilterStruct,
      }

      let _: Req = serde_json::from_value(json!({
          "filter_tuple" : {
              "EQ": {
                  "property": "a",
                  "value": "b"
              }
          },
          "filter_struct" : {
              "EQ": {
                  "property": "a",
                  "value": "b"
              }
          }
      }))
      .unwrap();

      let _: Req = serde_json::from_value(json!({
          "filter_tuple" : {
              "EQ": ["a", "b"]
          },
          "filter_struct" : {
              "EQ": ["a", "b"]
          }
      }))
      .unwrap();
  }

[Mingun]

This would be fixed by serde-rs/serde#2465

[dtolnay]

This is a serde_json issue.

Deserializing the same data structure using from_str (instead of from_value) succeeds.

This is unrelated to serde-rs/serde#2465 which involves untagged and adjacently tagged enums. The code above does not use untagged or adjacently tagged enums.

[jaques-sam]

Deserializing the same data structure using from_str (instead of from_value) succeeds.

I encountered the same issue. What I need to do to circumvent this issue is by converting the Value back to a string (using to_string() and pass it back to from_str. Which eventually makes my code deserialize my object twice :(
Like so:

let deserialized: Value = serde_json::from_str(raw_json).unwrap();
... // do some validation
let object: MyType = serde_json::from_value(deserialized).unwrap();