Annotating OneOrMany errors?

[wez]

I just ran into an issue where I have:

#[serde_as(deserialize_as = "OneOrMany<_, PreferOne>")]
pub action: Vec<Action>,

and a user tried to set:

{
  "action": [
   [ "Suspend" ]
 ] 
}

which is invalid because they are trying to assign an array of arrays of Action instead of just an array of Action.

The resulting error message looks like:

 OneOrMany could not deserialize any variant:
  One: invalid type: sequence, expected string or map
  Many: invalid type: sequence, expected string or map at line 263 column 1

line 263 is the end of the input json document.

In the interest of trying to improve the error message, I tried to apply serde_path_to_error to this, but it cannot see the path.

I think it would be nice if I could specialize or newtype-wrap that OneOrMany in some way and provide an override for the expecting method of the underlying visitor, so that I could have it say either a single Action or an array of Action.

I've tried to apply DeserializeAsWrap without success:

fn one_or_many<'de, T, D>(deserializer: D, expecting: &'static str) -> Result<Vec<T>, D::Error>
where
    T: Deserialize<'de> ,
    D: Deserializer<'de>,
{

    let result = serde_with::de::DeserializeAsWrap::<
        Vec<T>,
        OneOrMany<T, PreferOne>  // I'm unsure if I need T or Vec<T> here, but neither compile
    >::deserialize(deserializer)?; // the intent is to map_err here and do some editorializing with `expecting`

    Ok(result.into_inner())
}

fn one_or_many_action<'de, D>(deserializer: D) -> Result<Vec<Action>, D::Error>
where
    D: Deserializer<'de>,
{
    one_or_many(deserializer, "either a single Action or an array of Action, for field action")
}

#[serde_as]
#[derive(Deserialize, Serialize, Debug, Hash, Clone)]
struct Rule {
  #[serde(deserialize_with = "one_or_many_action")]
  pub action: Vec<Action>,
}

but I think I'm having a similar naming/resolution issue as is mentioned in #649

I'm looking for a suggestion (or ideally, a solution!) for how to achieve an annotated/expanded error message for this sort of situation!

[jonasbb]

The error message you see is part of the DeserializeAs implementation of OneOrMany. As such it is not really possible to change it, as this would require modifying the DeserializeAs code. In the future maybe it might be possible to refer to a const generic static string, but that is impossible right now too.

serde_with/serde_with/src/de/impls.rs

Lines 1527 to 1557 in aede9d5

	#[cfg(feature = "alloc")]
	impl<'de, T, TAs, FORMAT> DeserializeAs<'de, Vec<T>> for OneOrMany<TAs, FORMAT>
	where
	TAs: DeserializeAs<'de, T>,
	FORMAT: Format,
	{
	fn deserialize_as<D>(deserializer: D) -> Result<Vec<T>, D::Error>
	where
	D: Deserializer<'de>,
	{
	let is_hr = deserializer.is_human_readable();
	let content: content::de::Content<'de> = Deserialize::deserialize(deserializer)?;
	let one_err: D::Error = match <DeserializeAsWrap<T, TAs>>::deserialize(
	content::de::ContentRefDeserializer::new(&content, is_hr),
	) {
	Ok(one) => return Ok(alloc::vec![one.into_inner()]),
	Err(err) => err,
	};
	let many_err: D::Error = match <DeserializeAsWrap<Vec<T>, Vec<TAs>>>::deserialize(
	content::de::ContentDeserializer::new(content, is_hr),
	) {
	Ok(many) => return Ok(many.into_inner()),
	Err(err) => err,
	};
	Err(DeError::custom(format_args!(
	"OneOrMany could not deserialize any variant:\n One: {}\n Many: {}",
	one_err, many_err
	)))
	}
	}

I think this matches what you are trying to do in the code snippet. It does not replace the error message of OneOrMany. Instead if any error that pops up is replaced with the custom error message. This might hide some errors that are coming from the original deserializer.

fn one_or_many<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
where
    T: Deserialize<'de>,
    D: Deserializer<'de>,
{
    let result: Result<Vec<T>, _> = OneOrMany::<Same, formats::PreferOne>::deserialize_as(deserializer);
    match result {
        Ok(r) => Ok(r),
        Err(err) => Err(serde::de::Error::custom("My Custom Error Message"))
    }
}

[wez]

Thank you!

This is what I ended up with:

fn one_or_many<'de, T, D>(deserializer: D, expecting: &str) -> Result<Vec<T>, D::Error>
where
    T: Deserialize<'de>,
    D: Deserializer<'de>,
{
    let result: Result<Vec<T>, _> =
        OneOrMany::<serde_with::Same, PreferOne>::deserialize_as(deserializer);
    match result {
        Ok(r) => Ok(r),
        Err(err) => Err(serde::de::Error::custom(format!(
            "{expecting}.\nThe underlying error message is:\n{err:#}"
        ))),
    }
}

fn one_or_many_action<'de, D>(deserializer: D) -> Result<Vec<Action>, D::Error>
where
    D: Deserializer<'de>,
{
    one_or_many(
        deserializer,
        "\"action\" field expected either a single Action or an array of Actions",
    )
}

Then in my struct:

#[serde(deserialize_with = "one_or_many_action")]
pub action: Vec<Action>,

Produces an error like this, which still isn't perfect, but at least points to the action field:

"action" field expected either a single Action or an array of Actions.
The underlying error message is:
OneOrMany could not deserialize any variant:
  One: invalid type: sequence, expected string or map
  Many: invalid type: sequence, expected string or map at line 263 column 1