Merge pull request #5 from kavinda-100/develop

Develop

Author: kavinda-100

src/controllers/mod.rs

@@ -1,2 +1,3 @@
 pub mod auth_controller;
 pub mod root_controller;
+pub mod workspace_controller;

src/controllers/workspace_controller.rs

@@ -0,0 +1,220 @@
+use axum::{
+    Json,
+    extract::{Path, State},
+    http::StatusCode,
+};
+use uuid::Uuid;
+use validator::Validate;
+
+use crate::{
+    config::AppState,
+    dtos::workspace_dto::{CreateWorkspacePayload, UpdateWorkspacePayload, WorkspaceResponse},
+    middleware::auth::AuthUser,
+    models::Workspace,
+    utils::{api_error::ApiError, format_validation_errors, response::ApiResponse},
+};
+
+/**
+ * Creates a new workspace with the provided name for the authenticated user.
+ * Validates the input, stores the workspace in the database, and returns a JSON response with the workspace details.
+ * Route: POST /api/v1/workspaces
+ */
+pub async fn create_workspace(
+    State(state): State<AppState>,
+    AuthUser(user): AuthUser,
+    Json(payload): Json<CreateWorkspacePayload>,
+) -> Result<Json<ApiResponse<WorkspaceResponse>>, ApiError> {
+    // logging the workspace creation attempt with the email (but not the password)
+    tracing::info!("Attempting to create workspace with name: {}", payload.name);
+
+    // Validate the input payload
+    payload.validate().map_err(|e| {
+        let error_messages = format_validation_errors(&e);
+        tracing::error!("Validation errors: {}", error_messages);
+        ApiError::BadRequest(error_messages)
+    })?;
+
+    // create the workspace in the database
+    let new_workspace = sqlx::query_as::<_, Workspace>(
+        "INSERT INTO workspaces (name, owner_id) VALUES ($1, $2) RETURNING *",
+    )
+    .bind(&payload.name)
+    .bind(user.id)
+    .fetch_one(&state.db)
+    .await
+    .map_err(|_| ApiError::InternalServerError("Failed to create workspace".into()))?;
+
+    // Placeholder implementation
+    Ok(Json(ApiResponse::new(
+        true,
+        StatusCode::CREATED,
+        "Workspace created successfully",
+        Some(WorkspaceResponse {
+            id: new_workspace.id,
+            name: new_workspace.name,
+            owner_id: new_workspace.owner_id,
+            created_at: new_workspace.created_at,
+            updated_at: new_workspace.updated_at,
+        }),
+    )))
+}
+
+/**
+ * Retrieves a list of workspaces that the authenticated user has access to.
+ * This is a placeholder implementation that currently returns an empty list.
+ * Route: GET /api/v1/workspaces
+ */
+pub async fn get_workspaces(
+    State(state): State<AppState>,
+    AuthUser(user): AuthUser,
+) -> Result<Json<ApiResponse<Vec<WorkspaceResponse>>>, ApiError> {
+    // logging the workspace retrieval attempt
+    tracing::info!("User {} is attempting to retrieve workspaces", user.email);
+
+    // get the workspaces from the database that the user has access to (owned)
+    let _workspaces = sqlx::query_as::<_, Workspace>(
+        "SELECT * FROM workspaces WHERE owner_id = $1 ORDER BY created_at DESC",
+    )
+    .bind(user.id)
+    .fetch_all(&state.db)
+    .await
+    .map_err(|_| ApiError::InternalServerError("Failed to retrieve workspaces".into()))?;
+
+    // map the workspaces to the response DTOs
+    let _workspace_responses: Vec<WorkspaceResponse> = _workspaces
+        .into_iter()
+        .map(|ws| WorkspaceResponse {
+            id: ws.id,
+            name: ws.name,
+            owner_id: ws.owner_id,
+            created_at: ws.created_at,
+            updated_at: ws.updated_at,
+        })
+        .collect();
+
+    // Placeholder implementation
+    Ok(Json(ApiResponse::new(
+        true,
+        StatusCode::OK,
+        "Workspaces retrieved successfully",
+        Some(_workspace_responses), // Return the list of workspaces
+    )))
+}
+
+/**
+ * Updates the name of an existing workspace that belongs to the authenticated user.
+ * Validates the input, checks if the workspace exists and belongs to the user, updates it in the database, and returns a JSON response with the updated workspace details.
+ * Route: PUT /api/v1/workspaces/{id}
+ */
+pub async fn update_workspace(
+    State(state): State<AppState>,
+    AuthUser(user): AuthUser,
+    Path(id): Path<Uuid>,
+    Json(payload): Json<UpdateWorkspacePayload>,
+) -> Result<Json<ApiResponse<WorkspaceResponse>>, ApiError> {
+    // logging the workspace update attempt with the email (but not the password)
+    tracing::info!(
+        "User {} is attempting to update workspace with id: {}",
+        user.email,
+        id
+    );
+
+    // Validate the input payload
+    payload.validate().map_err(|e| {
+        let error_messages = format_validation_errors(&e);
+        tracing::error!("Validation errors: {}", error_messages);
+        ApiError::BadRequest(error_messages)
+    })?;
+
+    // check if the workspace exists and belongs to the user
+    let existing_workspace =
+        sqlx::query_as::<_, Workspace>("SELECT * FROM workspaces WHERE id = $1 AND owner_id = $2")
+            .bind(id)
+            .bind(user.id)
+            .fetch_optional(&state.db)
+            .await
+            .map_err(|_| ApiError::InternalServerError("Failed to retrieve workspace".into()))?;
+
+    // if the workspace doesn't exist or doesn't belong to the user, return a 404 error
+    if existing_workspace.is_none() {
+        tracing::warn!("Workspace with id {} not found for user {}", id, user.email);
+        return Err(ApiError::NotFound("Workspace not found".into()));
+    }
+
+    // update the workspace in the database
+    let updated_workspace = sqlx::query_as::<_, Workspace>(
+        "UPDATE workspaces SET name = $1, updated_at = NOW() WHERE id = $2 AND owner_id = $3 RETURNING *",
+    )
+    .bind(&payload.name)
+    .bind(id)
+    .bind(user.id)
+    .fetch_one(&state.db)
+    .await
+    .map_err(|_| ApiError::InternalServerError("Failed to update workspace".into()))?;
+
+    // Placeholder implementation
+    Ok(Json(ApiResponse::new(
+        true,
+        StatusCode::OK,
+        "Workspace updated successfully",
+        Some(WorkspaceResponse {
+            id: updated_workspace.id,
+            name: updated_workspace.name,
+            owner_id: updated_workspace.owner_id,
+            created_at: updated_workspace.created_at,
+            updated_at: updated_workspace.updated_at,
+        }),
+    )))
+}
+
+/**
+ * Deletes an existing workspace that belongs to the authenticated user.
+ * Validates the input, checks if the workspace exists and belongs to the user, deletes it from the database, and returns a JSON response confirming the deletion.
+ * Route: DELETE /api/v1/workspaces/{id}
+ */
+pub async fn delete_workspace(
+    State(state): State<AppState>,
+    AuthUser(user): AuthUser,
+    Path(id): Path<Uuid>,
+) -> Result<Json<ApiResponse<()>>, ApiError> {
+    // logging the workspace update attempt with the email (but not the password)
+    tracing::info!(
+        "User {} is attempting to delete workspace with id: {}",
+        user.email,
+        id
+    );
+
+    // check if the workspace exists and belongs to the user
+    let existing_workspace =
+        sqlx::query_as::<_, Workspace>("SELECT * FROM workspaces WHERE id = $1 AND owner_id = $2")
+            .bind(id)
+            .bind(user.id)
+            .fetch_optional(&state.db)
+            .await
+            .map_err(|_| ApiError::InternalServerError("Failed to retrieve workspace".into()))?;
+
+    // if the workspace doesn't exist or doesn't belong to the user, return a 404 error
+    let existing_workspace = existing_workspace.ok_or_else(|| {
+        tracing::warn!("Workspace with id {} not found for user {}", id, user.email);
+        ApiError::NotFound("Workspace not found".into())
+    })?;
+
+    // delete the workspace from the database
+    sqlx::query("DELETE FROM workspaces WHERE id = $1 AND owner_id = $2")
+        .bind(id)
+        .bind(user.id)
+        .execute(&state.db)
+        .await
+        .map_err(|_| ApiError::InternalServerError("Failed to delete workspace".into()))?;
+
+    // Return a success response with no data
+    Ok(Json(ApiResponse::new(
+        true,
+        StatusCode::OK,
+        format!(
+            "Workspace named: {} deleted successfully",
+            existing_workspace.name
+        ),
+        None,
+    )))
+}

src/dtos/mod.rs

@@ -1 +1,2 @@
 pub mod auth_dto;
+pub mod workspace_dto;

src/dtos/workspace_dto.rs

@@ -0,0 +1,33 @@
+use chrono::NaiveDateTime;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+use validator::Validate;
+
+#[derive(Debug, Deserialize, Validate)]
+pub struct CreateWorkspacePayload {
+    #[validate(length(
+        min = 2,
+        max = 100,
+        message = "Workspace name must be between 2 and 100 characters"
+    ))]
+    pub name: String,
+}
+
+#[derive(Debug, Deserialize, Validate)]
+pub struct UpdateWorkspacePayload {
+    #[validate(length(
+        min = 2,
+        max = 100,
+        message = "Workspace name must be between 2 and 100 characters"
+    ))]
+    pub name: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct WorkspaceResponse {
+    pub id: Uuid,
+    pub name: String,
+    pub owner_id: Uuid,
+    pub created_at: NaiveDateTime,
+    pub updated_at: NaiveDateTime,
+}

src/routes/mod.rs

@@ -2,10 +2,11 @@ use axum::{Router, routing::get};
 use tower_http::services::fs::ServeDir;
 
 pub mod auth_routes;
+pub mod workspace_routes;
 
 use crate::{
     config::AppState, controllers::root_controller::health_check,
-    routes::auth_routes::create_auth_routes,
+    routes::auth_routes::create_auth_routes, routes::workspace_routes::create_workspace_routes,
 };
 
 /// Creates the main API router with all route groups
@@ -27,7 +28,7 @@ pub fn create_routes() -> Router<AppState> {
 
 // Helper function to create API v1 routes
 fn api_v1_routes() -> Router<AppState> {
-    Router::new().merge(create_auth_routes())
-    // other routes
-    // .merge(create_user_routes())
+    Router::new()
+        .merge(create_auth_routes())
+        .merge(create_workspace_routes())
 }

src/routes/workspace_routes.rs

@@ -0,0 +1,23 @@
+use axum::{
+    Router,
+    routing::{post, put},
+};
+
+use crate::{
+    config::AppState,
+    controllers::workspace_controller::{
+        create_workspace, delete_workspace, get_workspaces, update_workspace,
+    },
+};
+
+// Workspace routes module
+// This module defines all routes related to workspaces
+// Route path: base_url/api/v1/workspaces/*
+pub fn create_workspace_routes() -> Router<AppState> {
+    Router::new()
+        .route("/workspaces", post(create_workspace).get(get_workspaces))
+        .route(
+            "/workspaces/{id}",
+            put(update_workspace).delete(delete_workspace),
+        )
+}