Handlers are _named operations_, which can be exposed via routes.

Each domain module that exposes handlers does so through a `handlers` child module, ideally as a top-level symbol that can be plugged directly into Axum's `MethodRouter`. Modules could make exceptions to this - kill the doctrinaire inside yourself, after all - but none of the API modules that actually exist need such exceptions, and consistency is useful.

The related details of request types, URL types, response types, errors, &c &c are then organized into modules under `handlers`, along with their respective tests.

1 files changed, 41 insertions, 0 deletions

diff --git a/src/invite/handlers/get/mod.rs b/src/invite/handlers/get/mod.rs
new file mode 100644
index 0000000..bb72586
--- /dev/null
+++ b/src/invite/handlers/get/mod.rs
@@ -0,0 +1,41 @@
+use axum::{
+    extract::{Json, Path, State},
+    response::{IntoResponse, Response},
+};
+
+use crate::{
+    app::App,
+    error::{Internal, NotFound},
+    invite::{Id, Summary, handlers::PathInfo},
+};
+
+#[cfg(test)]
+mod test;
+
+pub async fn handler(
+    State(app): State<App>,
+    Path(invite): Path<PathInfo>,
+) -> Result<Json<Summary>, Error> {
+    app.invites()
+        .get(&invite)
+        .await?
+        .map(Json)
+        .ok_or_else(move || Error::NotFound(invite))
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("invite not found: {0}")]
+    NotFound(Id),
+    #[error(transparent)]
+    Database(#[from] sqlx::Error),
+}
+
+impl IntoResponse for Error {
+    fn into_response(self) -> Response {
+        match self {
+            Self::NotFound(_) => NotFound(self).into_response(),
+            Self::Database(_) => Internal::from(self).into_response(),
+        }
+    }
+}