Code generation incorrectly assumes ConstraintViolation exists for unnamed enums, causing compilation errors.

[drganjoo]

Issue Summary

The code generation process for structures containing a member shape that targets an unnamed enum mistakenly assumes that the generated enum structure enforces constraints on deserializable values, treating it as if a corresponding ConstraintViolation structure exists. However, unnamed enums inherently support infallible conversion from strings, allowing any string value to be converted to the enum without restriction.

As a result, the generated code cannot be compiled due to missing ConstraintViolation definitions.

Example Model:

$version: "2"
namespace com.aws.example
use aws.protocols#restJson1
use smithy.framework#ValidationException

@restJson1
service PokemonService {
    operations: [SampleOp]
}

@http(uri: "/dailySummary", method: "POST")
operation SampleOp {
    input := {
        day: WeeklySummary
    }
    errors: [ValidationException]
}

structure WeeklySummary {
    day: DayOfWeek,
}

@enum([
    { value: "MONDAY" },
    { value: "TUESDAY" }
])
string DayOfWeek

Generated Code

For DayOfWeek:

pub struct DayOfWeek(String);

impl DayOfWeek {
    pub fn as_str(&self) -> &str {
        &self.0
    }
    pub const fn values() -> &'static [&'static str] {
        &["MONDAY", "TUESDAY"]
    }
}

impl ::std::str::FromStr for DayOfWeek {
    type Err = ::std::convert::Infallible;

    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
        ::std::result::Result::Ok(DayOfWeek::from(s))
    }
}

impl crate::constrained::Constrained for DayOfWeek {
    type Unconstrained = ::std::string::String;
}

impl ::std::convert::From<::std::string::String>
    for crate::constrained::MaybeConstrained<crate::model::DayOfWeek>
{
    fn from(value: ::std::string::String) -> Self {
        Self::Unconstrained(value)
    }
}

However, the generated code for WeeklySummary incorrectly includes a ConstraintViolation enum with a Day variant, expecting an associated ConstraintViolation field of type crate::model::day_of_week::ConstraintViolation, which does not exist. This results in a compilation error.

pub mod weekly_summary {

    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
    /// Holds one variant for each way the builder can fail.
    #[non_exhaustive]
    #[allow(clippy::enum_variant_names)]
    pub enum ConstraintViolation {
        /// Constraint violation occurred building member `day` when building `WeeklySummary`.
        #[doc(hidden)]
        Day(crate::model::day_of_week::ConstraintViolation),
    }
    impl ::std::fmt::Display for ConstraintViolation {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            match self {
                ConstraintViolation::Day(_) => write!(f, "constraint violation occurred building member `day` when building `WeeklySummary"),
            }
        }
    }
    impl ::std::error::Error for ConstraintViolation {}
    impl ConstraintViolation {
        pub(crate) fn as_validation_exception_field(
            self,
            path: ::std::string::String,
        ) -> crate::model::ValidationExceptionField {
            match self {
                ConstraintViolation::Day(inner) => {
                    inner.as_validation_exception_field(path + "/day")
                }
            }
        }
    }

This issue arises because the unnamed enum (DayOfWeek) does not include constraint enforcement, but the generated code for WeeklySummary assumes a ConstraintViolation structure exists for DayOfWeek.

[drganjoo]

The current implementation assumes that unnamed enum variants don't require validation, but this assumption is incorrect. Even for unnamed enum variants, server-side validation of the input string against the possible enum values is crucial for maintaining data integrity and preventing unexpected behavior.

To address this, we should implement validation for unnamed enum types as well. Something like:

impl TryFrom<&str> for DayOfWeek {
    type Error = crate::model::day_of_week::ConstraintViolation;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        if matches!(s, "MONDAY" | "TUESDAY") {
            Ok(Self::from(s))
        } else {
            Err(Self::Error(s.to_owned()))
        }
    }
}