add error codes models

Author: Handy-caT

src/libs/error_code.rs

@@ -1,4 +1,5 @@
 use serde::*;
+use std::str::FromStr;
 
 /// `ErrorCode` is a wrapper around `u32` that represents an error code.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -185,4 +186,81 @@ impl ErrorCode {
             _ => "CustomError",
         }
     }
+
+    pub fn from_name(name: &str) -> Option<Self> {
+        let normalized: String = name
+            .chars()
+            .filter(|c| c.is_ascii_alphanumeric())
+            .flat_map(char::to_uppercase)
+            .collect();
+
+        match normalized.as_str() {
+            "BADREQUEST" => Some(Self::BAD_REQUEST),
+            "UNAUTHORIZED" => Some(Self::UNAUTHORIZED),
+            "PAYMENTREQUIRED" => Some(Self::PAYMENT_REQUIRED),
+            "FORBIDDEN" => Some(Self::FORBIDDEN),
+            "NOTFOUND" => Some(Self::NOT_FOUND),
+            "METHODNOTALLOWED" => Some(Self::METHOD_NOT_ALLOWED),
+            "NOTACCEPTABLE" => Some(Self::NOT_ACCEPTABLE),
+            "PROXYAUTHENTICATIONREQUIRED" => Some(Self::PROXY_AUTHENTICATION_REQUIRED),
+            "REQUESTTIMEOUT" => Some(Self::REQUEST_TIMEOUT),
+            "CONFLICT" => Some(Self::CONFLICT),
+            "GONE" => Some(Self::GONE),
+            "LENGTHREQUIRED" => Some(Self::LENGTH_REQUIRED),
+            "PRECONDITIONFAILED" => Some(Self::PRECONDITION_FAILED),
+            "PAYLOADTOOLARGE" => Some(Self::PAYLOAD_TOO_LARGE),
+            "URITOOLONG" => Some(Self::URI_TOO_LONG),
+            "UNSUPPORTEDMEDIATYPE" => Some(Self::UNSUPPORTED_MEDIA_TYPE),
+            "RANGENOTSATISFIABLE" => Some(Self::RANGE_NOT_SATISFIABLE),
+            "EXPECTATIONFAILED" => Some(Self::EXPECTATION_FAILED),
+            "IMATEAPOT" => Some(Self::IM_A_TEAPOT),
+            "MISDIRECTEDREQUEST" => Some(Self::MISDIRECTED_REQUEST),
+            "UNPROCESSABLEENTITY" => Some(Self::UNPROCESSABLE_ENTITY),
+            "LOCKED" => Some(Self::LOCKED),
+            "FAILEDDEPENDENCY" => Some(Self::FAILED_DEPENDENCY),
+            "UPGRADEREQUIRED" => Some(Self::UPGRADE_REQUIRED),
+            "PRECONDITIONREQUIRED" => Some(Self::PRECONDITION_REQUIRED),
+            "TOOMANYREQUESTS" => Some(Self::TOO_MANY_REQUESTS),
+            "REQUESTHEADERFIELDSTOOLARGE" => Some(Self::REQUEST_HEADER_FIELDS_TOO_LARGE),
+            "UNAVAILABLEFORLEGALREASONS" => Some(Self::UNAVAILABLE_FOR_LEGAL_REASONS),
+            "INTERNALERROR" => Some(Self::INTERNAL_ERROR),
+            "NOTIMPLEMENTED" => Some(Self::NOT_IMPLEMENTED),
+            "BADGATEWAY" => Some(Self::BAD_GATEWAY),
+            "SERVICEUNAVAILABLE" => Some(Self::SERVICE_UNAVAILABLE),
+            "GATEWAYTIMEOUT" => Some(Self::GATEWAY_TIMEOUT),
+            "HTTPVERSIONNOTSUPPORTED" => Some(Self::HTTP_VERSION_NOT_SUPPORTED),
+            "VARIANTALSONEGOTIATES" => Some(Self::VARIANT_ALSO_NEGOTIATES),
+            "INSUFFICIENTSTORAGE" => Some(Self::INSUFFICIENT_STORAGE),
+            "LOOPDETECTED" => Some(Self::LOOP_DETECTED),
+            "NOTEXTENDED" => Some(Self::NOT_EXTENDED),
+            "NETWORKAUTHENTICATIONREQUIRED" => Some(Self::NETWORK_AUTHENTICATION_REQUIRED),
+            _ => None,
+        }
+    }
+}
+
+impl FromStr for ErrorCode {
+    type Err = ParseErrorCodeError;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        if let Some(code) = Self::from_name(value) {
+            return Ok(code);
+        }
+
+        value
+            .parse::<u32>()
+            .map(Self::new)
+            .map_err(|_| ParseErrorCodeError)
+    }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ParseErrorCodeError;
+
+impl std::fmt::Display for ParseErrorCodeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("invalid error code")
+    }
+}
+
+impl std::error::Error for ParseErrorCodeError {}

src/libs/ws/traits.rs

@@ -68,4 +68,4 @@ pub trait WsUpgrader: Send + Sync {
         config: &WsServerConfig,
         cached_date: &str,
     ) -> Result<AsyncRx<Array<UpgradeEvent>>>;
-}
+}

src/libs/ws/tungstenite.rs

@@ -1,4 +1,4 @@
 pub mod upgrader;
 
 pub use upgrader::HyperTungsteniteUpgrader;
-pub use upgrader::create_ws_stream;
+pub use upgrader::create_ws_stream;

src/model/endpoint.rs

@@ -1,6 +1,8 @@
 use crate::model::{Field, Type};
 use convert_case::{Case, Casing};
 use eyre::{ContextCompat, Result};
+use serde::de::{Error, Unexpected};
+use serde::ser::SerializeStruct;
 use serde::*;
 use std::fmt::Write;
 
@@ -33,6 +35,10 @@ pub struct EndpointSchema {
 
     // Allowed roles for this endpoint ["EnumRole::EnumVariant"]
     pub roles: Vec<String>,
+
+    /// Public error variants that handlers may return for this endpoint.
+    #[serde(default)]
+    pub errors: Vec<EndpointErrorSchema>,
 }
 
 impl EndpointSchema {
@@ -52,6 +58,7 @@ impl EndpointSchema {
             description: "".to_string(),
             json_schema: Default::default(),
             roles: Vec::new(),
+            errors: Vec::new(),
         }
     }
 
@@ -72,6 +79,117 @@ impl EndpointSchema {
         self.roles = roles;
         self
     }
+
+    /// Adds public error variants to the endpoint.
+    pub fn with_errors(mut self, errors: Vec<EndpointErrorSchema>) -> Self {
+        self.errors = errors;
+        self
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Hash, PartialEq, PartialOrd, Eq, Ord)]
+pub struct EndpointErrorSchema {
+    pub name: String,
+    pub code: EndpointErrorCodeRef,
+    #[serde(default)]
+    pub message: String,
+    #[serde(default)]
+    pub fields: Vec<Field>,
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, PartialOrd, Eq, Ord)]
+pub struct EndpointErrorCodeRef {
+    pub ty: Type,
+    pub variant: String,
+}
+
+impl EndpointErrorCodeRef {
+    pub const ENUM_NAME: &'static str = "ErrorCode";
+
+    pub fn new(variant: impl Into<String>) -> Self {
+        Self {
+            ty: Type::enum_ref(Self::ENUM_NAME, true),
+            variant: variant.into(),
+        }
+    }
+
+    pub fn variant(&self) -> &str {
+        &self.variant
+    }
+
+    pub fn path(&self) -> String {
+        format!("{}::{}", Self::ENUM_NAME, self.variant)
+    }
+
+    fn validate_ty(ty: Type) -> std::result::Result<Type, String> {
+        match &ty {
+            Type::EnumRef { name, .. } if name == Self::ENUM_NAME => Ok(ty),
+            Type::EnumRef { name, .. } => {
+                Err(format!("expected {} enum ref, got {name}", Self::ENUM_NAME))
+            }
+            _ => Err(format!("expected {} enum ref", Self::ENUM_NAME)),
+        }
+    }
+
+    fn parse_path(path: &str) -> std::result::Result<Self, String> {
+        let (enum_name, variant) = path
+            .split_once("::")
+            .ok_or_else(|| format!("expected {}::Variant", Self::ENUM_NAME))?;
+
+        if enum_name != Self::ENUM_NAME {
+            return Err(format!(
+                "expected {} enum path, got {enum_name}",
+                Self::ENUM_NAME
+            ));
+        }
+
+        if variant.is_empty() || variant.contains("::") {
+            return Err(format!("expected {}::Variant", Self::ENUM_NAME));
+        }
+
+        Ok(Self::new(variant))
+    }
+}
+
+impl std::fmt::Display for EndpointErrorCodeRef {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.path())
+    }
+}
+
+impl Serialize for EndpointErrorCodeRef {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_struct("EndpointErrorCodeRef", 2)?;
+        state.serialize_field("ty", &self.ty)?;
+        state.serialize_field("variant", &self.variant)?;
+        state.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for EndpointErrorCodeRef {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(untagged)]
+        enum Helper {
+            Path(String),
+            Structured { ty: Type, variant: String },
+        }
+
+        match Helper::deserialize(deserializer)? {
+            Helper::Path(path) => Self::parse_path(&path)
+                .map_err(|err| D::Error::invalid_value(Unexpected::Str(&path), &err.as_str())),
+            Helper::Structured { ty, variant } => {
+                let ty = Self::validate_ty(ty).map_err(D::Error::custom)?;
+                Ok(Self { ty, variant })
+            }
+        }
+    }
 }
 
 pub fn encode_header<T: Serialize>(v: T, schema: EndpointSchema) -> Result<String> {
@@ -94,3 +212,105 @@ pub fn encode_header<T: Serialize>(v: T, schema: EndpointSchema) -> Result<Strin
     }
     Ok(s)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::libs::error_code::ErrorCode;
+    use std::str::FromStr;
+
+    #[test]
+    fn endpoint_schema_defaults_errors() {
+        let schema: EndpointSchema = serde_json::from_value(serde_json::json!({
+            "name": "Login",
+            "code": 10001,
+            "parameters": [],
+            "returns": [],
+            "roles": []
+        }))
+        .unwrap();
+
+        assert!(schema.errors.is_empty());
+    }
+
+    #[test]
+    fn endpoint_schema_reads_error_definitions() {
+        let schema: EndpointSchema = serde_json::from_value(serde_json::json!({
+            "name": "Login",
+            "code": 10001,
+            "parameters": [],
+            "returns": [],
+            "roles": [],
+            "errors": [
+                {
+                    "name": "WrongPassword",
+                    "code": "ErrorCode::Unauthorized",
+                    "message": "Wrong password",
+                    "fields": []
+                },
+                {
+                    "name": "PasswordTooShort",
+                    "code": "ErrorCode::BadRequest",
+                    "message": "Password too short",
+                    "fields": [
+                        { "name": "min_length", "ty": "Int32" }
+                    ]
+                }
+            ]
+        }))
+        .unwrap();
+
+        assert_eq!(schema.errors.len(), 2);
+        assert_eq!(schema.errors[0].code.variant(), "Unauthorized");
+        assert_eq!(schema.errors[1].fields[0].name, "min_length");
+    }
+
+    #[test]
+    fn endpoint_error_code_ref_serializes_as_typed_ref() {
+        let value = serde_json::to_value(EndpointErrorCodeRef::new("BadRequest")).unwrap();
+
+        assert_eq!(
+            value,
+            serde_json::json!({
+                "ty": {
+                    "EnumRef": {
+                        "name": "ErrorCode"
+                    }
+                },
+                "variant": "BadRequest"
+            })
+        );
+
+        let parsed: EndpointErrorCodeRef = serde_json::from_value(value).unwrap();
+        assert_eq!(parsed.variant(), "BadRequest");
+    }
+
+    #[test]
+    fn endpoint_error_code_ref_rejects_wrong_paths() {
+        assert!(
+            serde_json::from_value::<EndpointErrorCodeRef>(serde_json::json!("BadRequest"))
+                .is_err()
+        );
+        assert!(
+            serde_json::from_value::<EndpointErrorCodeRef>(serde_json::json!("UserRole::Admin"))
+                .is_err()
+        );
+    }
+
+    #[test]
+    fn error_code_parses_names_and_numeric_codes() {
+        assert_eq!(
+            ErrorCode::from_str("BadRequest").unwrap(),
+            ErrorCode::BAD_REQUEST
+        );
+        assert_eq!(
+            ErrorCode::from_str("BAD_REQUEST").unwrap(),
+            ErrorCode::BAD_REQUEST
+        );
+        assert_eq!(
+            ErrorCode::from_str("100777").unwrap(),
+            ErrorCode::new(100777)
+        );
+        assert!(ErrorCode::from_str("not a code").is_err());
+    }
+}