chore: update routes to use utoipa

crates/core/database/src/lib.rs

@@ -25,6 +25,10 @@ pub use mongodb;
 #[macro_use]
 extern crate bson;
 
+#[cfg(feature = "utoipa")]
+#[macro_use]
+extern crate utoipa;
+
 #[cfg(not(feature = "async-std-runtime"))]
 compile_error!("async-std-runtime feature must be enabled.");
 

crates/core/database/src/models/users/model.rs

@@ -15,7 +15,7 @@ use serde_json::json;
 use ulid::Ulid;
 
 auto_derived_partial!(
-    /// # User
+    /// User
     pub struct User {
         /// Unique Id
         #[serde(rename = "_id")]

crates/core/database/src/util/idempotency.rs

@@ -10,16 +10,16 @@ use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
-pub struct IdempotencyKey {
-    key: String,
-}
+#[cfg_attr(feature = "utoipa", derive(IntoParams))]
+#[cfg_attr(feature = "utoipa", into_params(names("Idempotency-Key"), parameter_in=Header))]
+pub struct IdempotencyKey(String);
 
 static TOKEN_CACHE: Lazy<Mutex<lru::LruCache<String, ()>>> =
     Lazy::new(|| Mutex::new(lru::LruCache::new(NonZeroUsize::new(1000).unwrap())));
 
 impl IdempotencyKey {
     pub fn unchecked_from_string(key: String) -> Self {
-        Self { key }
+        Self(key)
     }
 
     // Backwards compatibility.
@@ -32,14 +32,14 @@ impl IdempotencyKey {
             }
 
             cache.put(v.clone(), ());
-            self.key = v;
+            self.0 = v;
         }
 
         Ok(())
     }
 
     pub fn into_key(self) -> String {
-        self.key
+        self.0
     }
 }
 
@@ -110,18 +110,16 @@ impl<'r> FromRequest<'r> for IdempotencyKey {
                 ));
             }
 
-            let idempotency = IdempotencyKey { key };
+            let idempotency = IdempotencyKey(key);
             let mut cache = TOKEN_CACHE.lock().await;
-            if cache.get(&idempotency.key).is_some() {
+            if cache.get(&idempotency.0).is_some() {
                 return Outcome::Error((Status::Conflict, create_error!(DuplicateNonce)));
             }
 
-            cache.put(idempotency.key.clone(), ());
+            cache.put(idempotency.0.clone(), ());
             return Outcome::Success(idempotency);
         }
 
-        Outcome::Success(IdempotencyKey {
-            key: ulid::Ulid::new().to_string(),
-        })
+        Outcome::Success(IdempotencyKey(ulid::Ulid::new().to_string()))
     }
 }