Move aws_smithy_http::operation::error::BuildError into aws-smithy-types

rust-runtime/aws-smithy-http/src/endpoint.rs

@@ -6,7 +6,6 @@
 //! Code for resolving an endpoint (URI) that a request should be sent to
 
 use crate::endpoint::error::InvalidEndpointError;
-use crate::operation::error::BuildError;
 use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use http::uri::{Authority, Uri};
 use std::borrow::Cow;
@@ -105,15 +104,13 @@ impl<T> ResolveEndpoint<T> for Endpoint {
 pub struct EndpointPrefix(String);
 impl EndpointPrefix {
     /// Create a new endpoint prefix from an `impl Into<String>`. If the prefix argument is invalid,
-    /// a [`BuildError`] will be returned.
-    pub fn new(prefix: impl Into<String>) -> StdResult<Self, BuildError> {
+    /// a [`InvalidEndpointError`] will be returned.
+    pub fn new(prefix: impl Into<String>) -> StdResult<Self, InvalidEndpointError> {
         let prefix = prefix.into();
         match Authority::from_str(&prefix) {
             Ok(_) => Ok(EndpointPrefix(prefix)),
-            Err(err) => Err(BuildError::invalid_uri(
-                prefix,
-                "invalid prefix".into(),
-                err,
+            Err(err) => Err(InvalidEndpointError::failed_to_construct_authority(
+                prefix, err,
             )),
         }
     }
@@ -143,11 +140,13 @@ pub fn apply_endpoint(
         .map(|auth| auth.as_str())
         .unwrap_or("");
     let authority = if !prefix.is_empty() {
-        Authority::from_str(&format!("{}{}", prefix, authority))
+        Cow::Owned(format!("{}{}", prefix, authority))
     } else {
-        Authority::from_str(authority)
-    }
-    .map_err(InvalidEndpointError::failed_to_construct_authority)?;
+        Cow::Borrowed(authority)
+    };
+    let authority = Authority::from_str(&authority).map_err(|err| {
+        InvalidEndpointError::failed_to_construct_authority(authority.into_owned(), err)
+    })?;
     let scheme = *endpoint
         .scheme()
         .as_ref()

rust-runtime/aws-smithy-http/src/endpoint/error.rs

@@ -54,6 +54,7 @@ impl Error for ResolveEndpointError {
 pub(super) enum InvalidEndpointErrorKind {
     EndpointMustHaveScheme,
     FailedToConstructAuthority {
+        authority: String,
         source: Box<dyn Error + Send + Sync + 'static>,
     },
     FailedToConstructUri {
@@ -76,10 +77,12 @@ impl InvalidEndpointError {
     }
 
     pub(super) fn failed_to_construct_authority(
+        authority: String,
         source: impl Into<Box<dyn Error + Send + Sync + 'static>>,
     ) -> Self {
         Self {
             kind: InvalidEndpointErrorKind::FailedToConstructAuthority {
+                authority,
                 source: source.into(),
             },
         }
@@ -105,11 +108,11 @@ impl From<InvalidEndpointErrorKind> for InvalidEndpointError {
 impl fmt::Display for InvalidEndpointError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use InvalidEndpointErrorKind as ErrorKind;
-        match self.kind {
+        match &self.kind {
             ErrorKind::EndpointMustHaveScheme => write!(f, "endpoint must contain a valid scheme"),
-            ErrorKind::FailedToConstructAuthority { .. } => write!(
+            ErrorKind::FailedToConstructAuthority { authority, source: _ } => write!(
                 f,
-                "endpoint must contain a valid authority when combined with endpoint prefix"
+                "endpoint must contain a valid authority when combined with endpoint prefix: {authority}"
             ),
             ErrorKind::FailedToConstructUri { .. } => write!(f, "failed to construct URI"),
         }
@@ -120,8 +123,11 @@ impl Error for InvalidEndpointError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         use InvalidEndpointErrorKind as ErrorKind;
         match &self.kind {
-            ErrorKind::FailedToConstructUri { source }
-            | ErrorKind::FailedToConstructAuthority { source } => Some(source.as_ref()),
+            ErrorKind::FailedToConstructUri { source } => Some(source.as_ref()),
+            ErrorKind::FailedToConstructAuthority {
+                authority: _,
+                source,
+            } => Some(source.as_ref()),
             ErrorKind::EndpointMustHaveScheme => None,
         }
     }

rust-runtime/aws-smithy-http/src/operation.rs

@@ -13,7 +13,10 @@ use aws_smithy_types::config_bag::{Storable, StoreReplace};
 use std::borrow::Cow;
 use std::ops::{Deref, DerefMut};
 
-pub mod error;
+/// Errors for operations
+pub mod error {
+    pub use aws_smithy_types::operation::error::{BuildError, SerializationError};
+}
 
 /// Metadata attached to an [`Operation`] that identifies the API being called.
 #[derive(Clone, Debug)]

rust-runtime/aws-smithy-types/src/lib.rs

@@ -19,6 +19,7 @@ pub mod config_bag;
 pub mod date_time;
 pub mod endpoint;
 pub mod error;
+pub mod operation;
 pub mod primitive;
 pub mod retry;
 pub mod timeout;