feat: axum method add valid

Author: baerwang

Cargo.lock

@@ -10,4 +10,5 @@ publish = false
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.9"
-axum = "0.7"
+axum = "0.7"
+anyhow = "1.0"

Cargo.toml

@@ -19,6 +19,7 @@ use crate::request::validator::ValidateRequest;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::hash::Hash;
+use std::str::FromStr;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct OpenAPI {
@@ -39,7 +40,7 @@ impl OpenAPI {
         serde_yaml::from_str(contents)
     }
 
-    pub fn validator(&self, _: impl ValidateRequest) -> Result<(), String> {
+    pub fn validator(&self, valid: impl ValidateRequest) -> Result<(), String> {
         if self.openapi.is_empty() {
             return Err("OpenAPI version is required".to_string());
         }
@@ -49,6 +50,10 @@ impl OpenAPI {
         if self.info.version.is_empty() {
             return Err("Version is required".to_string());
         }
+        if self.paths.is_empty() {
+            return Err("Paths are required".to_string());
+        }
+        valid.path(self).unwrap();
         Ok(())
     }
 }
@@ -214,6 +219,25 @@ pub enum Method {
     Trace,
 }
 
+impl FromStr for Method {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_uppercase().as_str() {
+            "GET" => Ok(Method::Get),
+            "HEAD" => Ok(Method::Head),
+            "POST" => Ok(Method::Post),
+            "PUT" => Ok(Method::Put),
+            "DELETE" => Ok(Method::Delete),
+            "CONNECT" => Ok(Method::Connect),
+            "PATCH" => Ok(Method::Patch),
+            "OPTIONS" => Ok(Method::Options),
+            "TRACE" => Ok(Method::Trace),
+            _ => Err(format!("Invalid method: {}", s)),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all(deserialize = "lowercase"))]
 pub enum In {

src/model/parse.rs

@@ -14,11 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+use crate::model::parse::{Method, OpenAPI};
 use crate::request::validator::ValidateRequest;
+use anyhow::{Context, Result};
 use axum::body::{Body, Bytes};
 use axum::http::Request;
-use std::io::Error;
+use std::str::FromStr;
 
 #[allow(dead_code)]
 pub struct RequestData {
@@ -27,19 +28,34 @@ pub struct RequestData {
 }
 
 impl ValidateRequest for RequestData {
-    fn header(&self) -> Result<(), Error> {
+    fn header(&self, _: &OpenAPI) -> Result<()> {
+        Ok(())
+    }
+
+    fn method(&self, open_api: &OpenAPI) -> Result<()> {
+        let path = open_api
+            .paths
+            .get(self.inner.uri().path())
+            .context("Path not found")?;
+
+        let method =
+            Method::from_str(self.inner.method().as_str()).map_err(|e| anyhow::anyhow!(e))?;
+
+        if path.get(&method).is_none() {
+            return Err(anyhow::anyhow!("Path is empty"));
+        }
         Ok(())
     }
 
-    fn query(&self) -> Result<(), Error> {
+    fn query(&self, _: &OpenAPI) -> Result<()> {
         Ok(())
     }
 
-    fn path(&self) -> Result<(), Error> {
+    fn path(&self, _: &OpenAPI) -> Result<()> {
         Ok(())
     }
 
-    fn body(&self) -> Result<(), Error> {
+    fn body(&self, _: &OpenAPI) -> Result<()> {
         Ok(())
     }
 }

src/request/axum.rs

@@ -14,12 +14,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-use std::io::Error;
+use crate::model::parse::OpenAPI;
+use anyhow::Result;
 
 pub trait ValidateRequest {
-    fn header(&self) -> Result<(), Error>;
-    fn query(&self) -> Result<(), Error>;
-    fn path(&self) -> Result<(), Error>;
-    fn body(&self) -> Result<(), Error>;
+    fn header(&self, _: &OpenAPI) -> Result<()>;
+    fn method(&self, _: &OpenAPI) -> Result<()>;
+    fn query(&self, _: &OpenAPI) -> Result<()>;
+    fn path(&self, _: &OpenAPI) -> Result<()>;
+    fn body(&self, _: &OpenAPI) -> Result<()>;
 }