add location header to post machine identity response (#195)

* add location header to post machine identity response

* bump up nebula version into 0.0.4

Author: boris-cremit

Cargo.lock

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.0.3"
+version = "0.0.4"
 edition = "2021"
 authors = ["John Choi <john@cremit.io>", "Boris Im <boris@cremit.io>"]
 repository = "https://github.com/cremithq/nebula"

Cargo.toml

@@ -22,6 +22,10 @@ pub struct MachineIdentity {
     deleted: bool,
 }
 
+pub struct MachineIdentityCreationResult {
+    pub id: Ulid,
+}
+
 impl MachineIdentity {
     pub(crate) fn update_attributes(&mut self, attributes: &[(&str, &str)]) {
         let current_attributes: HashSet<(&str, &str)> =
@@ -139,11 +143,11 @@ impl MachineIdentityService {
         transaction: &DatabaseTransaction,
         owner_claim: &NebulaClaim,
         label: &str,
-    ) -> Result<()> {
-        let machine_identity_id = UlidId::new(Ulid::new());
+    ) -> Result<MachineIdentityCreationResult> {
+        let machine_identity_id = Ulid::new();
         let now = Utc::now();
         machine_identity::ActiveModel {
-            id: Set(machine_identity_id),
+            id: Set(UlidId::new(machine_identity_id)),
             owner_gid: Set(owner_claim.gid.to_owned()),
             label: Set(label.to_owned()),
             created_at: Set(now),
@@ -152,7 +156,7 @@ impl MachineIdentityService {
         .insert(transaction)
         .await?;
 
-        Ok(())
+        Ok(MachineIdentityCreationResult { id: machine_identity_id })
     }
 
     pub async fn get_machine_identities(&self, transaction: &DatabaseTransaction) -> Result<Vec<MachineIdentity>> {

crates/nebula-authorization/src/domain/machine_identity/mod.rs

@@ -1,8 +1,8 @@
-use std::sync::Arc;
+use std::{str::FromStr, sync::Arc};
 
 use axum::{
-    extract::{Path, Query, Request, State},
-    http::{HeaderMap, StatusCode},
+    extract::{OriginalUri, Path, Query, Request, State},
+    http::{header, uri::PathAndQuery, HeaderMap, HeaderValue, StatusCode, Uri},
     middleware::{self, Next},
     response::{IntoResponse, Redirect, Response},
     routing::{delete, get, patch, post},
@@ -18,6 +18,7 @@ use nebula_token::{
 use sea_orm::{DatabaseTransaction, DbErr, TransactionTrait};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
+use tracing::error;
 use ulid::Ulid;
 
 use crate::{
@@ -371,6 +372,9 @@ enum MachineIdentityError {
     #[error("Error occurrred by database")]
     #[status(StatusCode::INTERNAL_SERVER_ERROR)]
     DatabaseError(#[from] DbErr),
+    #[error("failed to create location header")]
+    #[status(StatusCode::INTERNAL_SERVER_ERROR)]
+    FailedToCreateLocationHeader,
 }
 
 impl From<machine_identity::Error> for MachineIdentityError {
@@ -382,18 +386,43 @@ impl From<machine_identity::Error> for MachineIdentityError {
 }
 
 async fn handle_post_machine_identity(
+    OriginalUri(uri): OriginalUri,
     Path(workspace_name): Path<String>,
     State(application): State<Arc<Application>>,
     Extension(claim): Extension<NebulaClaim>,
     Json(payload): Json<PostMachineIdentityRequest>,
 ) -> Result<impl IntoResponse, MachineIdentityError> {
     let transaction = application.database_connection.begin_with_workspace_scope(&workspace_name).await?;
 
-    application.machine_identity_service.register_machine_identity(&transaction, &claim, &payload.label).await?;
+    let result =
+        application.machine_identity_service.register_machine_identity(&transaction, &claim, &payload.label).await?;
+
+    let mut parts = uri.into_parts();
+
+    let new_machine_identity_path = PathAndQuery::from_str(&format!(
+        "{}/{}",
+        parts.path_and_query.ok_or_else(|| {
+            error!("failed to get request path while creating location url");
+            MachineIdentityError::FailedToCreateLocationHeader
+        })?,
+        result.id
+    ))
+    .inspect_err(|e| error!(error = %e, "failed to create uri path from new machine identity resource"))
+    .map_err(|_| MachineIdentityError::FailedToCreateLocationHeader)?;
+
+    parts.path_and_query = Some(new_machine_identity_path);
+    let location_header_uri = Uri::from_parts(parts)
+        .inspect_err(|e| error!(error = %e, "failed to create location uri from new machine identity resource"))
+        .map_err(|_| MachineIdentityError::FailedToCreateLocationHeader)?;
+    let location_header_value = HeaderValue::from_str(&location_header_uri.to_string())
+        .inspect_err(
+            |e| error!(error = %e, "failed to create location header value from new machine identity resource"),
+        )
+        .map_err(|_| MachineIdentityError::FailedToCreateLocationHeader)?;
 
     transaction.commit().await?;
 
-    Ok(StatusCode::CREATED)
+    Ok((StatusCode::CREATED, [(header::LOCATION, location_header_value)]))
 }
 
 #[derive(Serialize)]