Rework request context handler

backend/internal/api/auth_handlers.go

@@ -1,146 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"net/http"
-	"novamd/internal/auth"
-	"novamd/internal/db"
-	"novamd/internal/models"
-
-	"golang.org/x/crypto/bcrypt"
-)
-
-type LoginRequest struct {
-	Email    string `json:"email"`
-	Password string `json:"password"`
-}
-
-type LoginResponse struct {
-	AccessToken  string        `json:"accessToken"`
-	RefreshToken string        `json:"refreshToken"`
-	User         *models.User  `json:"user"`
-	Session      *auth.Session `json:"session"`
-}
-
-type RefreshRequest struct {
-	RefreshToken string `json:"refreshToken"`
-}
-
-type RefreshResponse struct {
-	AccessToken string `json:"accessToken"`
-}
-
-// Login handles user authentication and returns JWT tokens
-func Login(authService *auth.SessionService, db *db.DB) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var req LoginRequest
-		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-			http.Error(w, "Invalid request body", http.StatusBadRequest)
-			return
-		}
-
-		// Validate request
-		if req.Email == "" || req.Password == "" {
-			http.Error(w, "Email and password are required", http.StatusBadRequest)
-			return
-		}
-
-		// Get user from database
-		user, err := db.GetUserByEmail(req.Email)
-		if err != nil {
-			http.Error(w, "Invalid credentials", http.StatusUnauthorized)
-			return
-		}
-
-		// Verify password
-		err = bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(req.Password))
-		if err != nil {
-			http.Error(w, "Invalid credentials", http.StatusUnauthorized)
-			return
-		}
-
-		// Create session and generate tokens
-		session, accessToken, err := authService.CreateSession(user.ID, string(user.Role))
-		if err != nil {
-			http.Error(w, "Failed to create session", http.StatusInternalServerError)
-			return
-		}
-
-		// Prepare response
-		response := LoginResponse{
-			AccessToken:  accessToken,
-			RefreshToken: session.RefreshToken,
-			User:         user,
-			Session:      session,
-		}
-
-		respondJSON(w, response)
-	}
-}
-
-// Logout invalidates the user's session
-func Logout(authService *auth.SessionService) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		sessionID := r.Header.Get("X-Session-ID")
-		if sessionID == "" {
-			http.Error(w, "Session ID required", http.StatusBadRequest)
-			return
-		}
-
-		err := authService.InvalidateSession(sessionID)
-		if err != nil {
-			http.Error(w, "Failed to logout", http.StatusInternalServerError)
-			return
-		}
-
-		w.WriteHeader(http.StatusOK)
-	}
-}
-
-// RefreshToken generates a new access token using a refresh token
-func RefreshToken(authService *auth.SessionService) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var req RefreshRequest
-		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-			http.Error(w, "Invalid request body", http.StatusBadRequest)
-			return
-		}
-
-		if req.RefreshToken == "" {
-			http.Error(w, "Refresh token required", http.StatusBadRequest)
-			return
-		}
-
-		// Generate new access token
-		accessToken, err := authService.RefreshSession(req.RefreshToken)
-		if err != nil {
-			http.Error(w, "Invalid refresh token", http.StatusUnauthorized)
-			return
-		}
-
-		response := RefreshResponse{
-			AccessToken: accessToken,
-		}
-
-		respondJSON(w, response)
-	}
-}
-
-// GetCurrentUser returns the currently authenticated user
-func (h *BaseHandler) GetCurrentUser(db *db.DB) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		// Get user from database
-		user, err := db.GetUserByID(ctx.UserID)
-		if err != nil {
-			http.Error(w, "User not found", http.StatusNotFound)
-			return
-		}
-
-		respondJSON(w, user)
-	}
-}

backend/internal/api/context.go

@@ -1,85 +0,0 @@
-// api/context.go
-package api
-
-import (
-	"context"
-	"net/http"
-	"novamd/internal/auth"
-	"novamd/internal/db"
-	"novamd/internal/filesystem"
-	"novamd/internal/models"
-
-	"github.com/go-chi/chi/v5"
-)
-
-type HandlerContext struct {
-	UserID    int
-	UserRole  string
-	Workspace *models.Workspace
-}
-
-type contextKey string
-
-const handlerContextKey contextKey = "handlerContext"
-
-// Middleware to populate handler context
-func WithHandlerContext(db *db.DB) func(http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			// Get user claims from auth context
-			claims, err := auth.GetUserFromContext(r.Context())
-			if err != nil {
-				http.Error(w, "Unauthorized", http.StatusUnauthorized)
-				return
-			}
-
-			// Get workspace name from URL if it exists
-			workspaceName := chi.URLParam(r, "workspaceName")
-
-			var workspace *models.Workspace
-			// Only look up workspace if name is provided
-			if workspaceName != "" {
-				workspace, err = db.GetWorkspaceByName(claims.UserID, workspaceName)
-				if err != nil {
-					http.Error(w, "Workspace not found", http.StatusNotFound)
-					return
-				}
-			}
-
-			// Create handler context
-			ctx := &HandlerContext{
-				UserID:    claims.UserID,
-				UserRole:  claims.Role,
-				Workspace: workspace,
-			}
-
-			// Add to request context
-			reqCtx := context.WithValue(r.Context(), handlerContextKey, ctx)
-			next.ServeHTTP(w, r.WithContext(reqCtx))
-		})
-	}
-}
-
-// Helper function to get handler context
-func GetHandlerContext(r *http.Request) *HandlerContext {
-	ctx := r.Context().Value(handlerContextKey)
-	if ctx == nil {
-		return nil
-	}
-	return ctx.(*HandlerContext)
-}
-
-type BaseHandler struct {
-	DB *db.DB
-	FS *filesystem.FileSystem
-}
-
-// Helper method to get context and handle errors
-func (h *BaseHandler) getContext(w http.ResponseWriter, r *http.Request) (*HandlerContext, bool) {
-	ctx := GetHandlerContext(r)
-	if ctx == nil {
-		http.Error(w, "Internal server error", http.StatusInternalServerError)
-		return nil, false
-	}
-	return ctx, true
-}

backend/internal/api/file_handlers.go

@@ -1,169 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"io"
-	"net/http"
-
-	"novamd/internal/db"
-	"novamd/internal/filesystem"
-
-	"github.com/go-chi/chi/v5"
-)
-
-func (h *BaseHandler) ListFiles(fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		files, err := fs.ListFilesRecursively(ctx.UserID, ctx.Workspace.ID)
-		if err != nil {
-			http.Error(w, "Failed to list files", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, files)
-	}
-}
-
-func (h *BaseHandler) LookupFileByName(fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		filename := r.URL.Query().Get("filename")
-		if filename == "" {
-			http.Error(w, "Filename is required", http.StatusBadRequest)
-			return
-		}
-
-		filePaths, err := fs.FindFileByName(ctx.UserID, ctx.Workspace.ID, filename)
-		if err != nil {
-			http.Error(w, "File not found", http.StatusNotFound)
-			return
-		}
-
-		respondJSON(w, map[string][]string{"paths": filePaths})
-	}
-}
-
-func (h *BaseHandler) GetFileContent(fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		filePath := chi.URLParam(r, "*")
-		content, err := fs.GetFileContent(ctx.UserID, ctx.Workspace.ID, filePath)
-		if err != nil {
-			http.Error(w, "Failed to read file", http.StatusNotFound)
-			return
-		}
-
-		w.Header().Set("Content-Type", "text/plain")
-		w.Write(content)
-	}
-}
-
-func (h *BaseHandler) SaveFile(fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		filePath := chi.URLParam(r, "*")
-		content, err := io.ReadAll(r.Body)
-		if err != nil {
-			http.Error(w, "Failed to read request body", http.StatusBadRequest)
-			return
-		}
-
-		err = fs.SaveFile(ctx.UserID, ctx.Workspace.ID, filePath, content)
-		if err != nil {
-			http.Error(w, "Failed to save file", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, map[string]string{"message": "File saved successfully"})
-	}
-}
-
-func (h *BaseHandler) DeleteFile(fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		filePath := chi.URLParam(r, "*")
-		err := fs.DeleteFile(ctx.UserID, ctx.Workspace.ID, filePath)
-		if err != nil {
-			http.Error(w, "Failed to delete file", http.StatusInternalServerError)
-			return
-		}
-
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte("File deleted successfully"))
-	}
-}
-
-func (h *BaseHandler) GetLastOpenedFile(db *db.DB, fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		filePath, err := db.GetLastOpenedFile(ctx.Workspace.ID)
-		if err != nil {
-			http.Error(w, "Failed to get last opened file", http.StatusInternalServerError)
-			return
-		}
-
-		if _, err := fs.ValidatePath(ctx.UserID, ctx.Workspace.ID, filePath); err != nil {
-			http.Error(w, "Invalid file path", http.StatusBadRequest)
-			return
-		}
-
-		respondJSON(w, map[string]string{"lastOpenedFilePath": filePath})
-	}
-}
-
-func (h *BaseHandler) UpdateLastOpenedFile(db *db.DB, fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		var requestBody struct {
-			FilePath string `json:"filePath"`
-		}
-
-		if err := json.NewDecoder(r.Body).Decode(&requestBody); err != nil {
-			http.Error(w, "Invalid request body", http.StatusBadRequest)
-			return
-		}
-
-		// Validate the file path exists in the workspace
-		if requestBody.FilePath != "" {
-			if _, err := fs.ValidatePath(ctx.UserID, ctx.Workspace.ID, requestBody.FilePath); err != nil {
-				http.Error(w, "Invalid file path", http.StatusBadRequest)
-				return
-			}
-		}
-
-		if err := db.UpdateLastOpenedFile(ctx.Workspace.ID, requestBody.FilePath); err != nil {
-			http.Error(w, "Failed to update last opened file", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, map[string]string{"message": "Last opened file updated successfully"})
-	}
-}

backend/internal/api/git_handlers.go

@@ -1,56 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"net/http"
-
-	"novamd/internal/filesystem"
-)
-
-func (h *BaseHandler) StageCommitAndPush(fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		var requestBody struct {
-			Message string `json:"message"`
-		}
-
-		if err := json.NewDecoder(r.Body).Decode(&requestBody); err != nil {
-			http.Error(w, "Invalid request body", http.StatusBadRequest)
-			return
-		}
-
-		if requestBody.Message == "" {
-			http.Error(w, "Commit message is required", http.StatusBadRequest)
-			return
-		}
-
-		err := fs.StageCommitAndPush(ctx.UserID, ctx.Workspace.ID, requestBody.Message)
-		if err != nil {
-			http.Error(w, "Failed to stage, commit, and push changes: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, map[string]string{"message": "Changes staged, committed, and pushed successfully"})
-	}
-}
-
-func (h *BaseHandler) PullChanges(fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		err := fs.Pull(ctx.UserID, ctx.Workspace.ID)
-		if err != nil {
-			http.Error(w, "Failed to pull changes: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, map[string]string{"message": "Pulled changes from remote"})
-	}
-}

backend/internal/api/handler_utils.go

@@ -1,27 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"errors"
-	"net/http"
-	"strconv"
-
-	"github.com/go-chi/chi/v5"
-)
-
-func getWorkspaceID(r *http.Request) (int, error) {
-	workspaceIDStr := chi.URLParam(r, "workspaceId")
-	workspaceID, err := strconv.Atoi(workspaceIDStr)
-	if err != nil {
-		return 0, errors.New("invalid workspaceId")
-	}
-
-	return workspaceID, nil
-}
-
-func respondJSON(w http.ResponseWriter, data interface{}) {
-	w.Header().Set("Content-Type", "application/json")
-	if err := json.NewEncoder(w).Encode(data); err != nil {
-		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
-	}
-}

backend/internal/api/routes.go

@@ -4,32 +4,34 @@ import (
 	"novamd/internal/auth"
 	"novamd/internal/db"
 	"novamd/internal/filesystem"
+	"novamd/internal/handlers"
+	"novamd/internal/middleware"
 
 	"github.com/go-chi/chi/v5"
 )
 
 func SetupRoutes(r chi.Router, db *db.DB, fs *filesystem.FileSystem, authMiddleware *auth.Middleware, sessionService *auth.SessionService) {
 
-	handler := &BaseHandler{
+	handler := &handlers.Handler{
 		DB: db,
 		FS: fs,
 	}
 
 	// Public routes (no authentication required)
 	r.Group(func(r chi.Router) {
-		r.Post("/auth/login", Login(sessionService, db))
-		r.Post("/auth/refresh", RefreshToken(sessionService))
+		r.Post("/auth/login", handler.Login(sessionService))
+		r.Post("/auth/refresh", handler.RefreshToken(sessionService))
 	})
 
 	// Protected routes (authentication required)
 	r.Group(func(r chi.Router) {
 		// Apply authentication middleware to all routes in this group
 		r.Use(authMiddleware.Authenticate)
-		r.Use(WithHandlerContext(db))
+		r.Use(middleware.WithHandlerContext(db))
 
 		// Auth routes
-		r.Post("/auth/logout", Logout(sessionService))
-		r.Get("/auth/me", handler.GetCurrentUser(db))
+		r.Post("/auth/logout", handler.Logout(sessionService))
+		r.Get("/auth/me", handler.GetCurrentUser())
 
 		// Admin-only routes
 		r.Group(func(r chi.Router) {
@@ -41,35 +43,35 @@ func SetupRoutes(r chi.Router, db *db.DB, fs *filesystem.FileSystem, authMiddlew
 
 		// Workspace routes
 		r.Route("/workspaces", func(r chi.Router) {
-			r.Get("/", handler.ListWorkspaces(db))
-			r.Post("/", handler.CreateWorkspace(db, fs))
-			r.Get("/last", handler.GetLastWorkspace(db))
-			r.Put("/last", handler.UpdateLastWorkspace(db))
+			r.Get("/", handler.ListWorkspaces())
+			r.Post("/", handler.CreateWorkspace())
+			r.Get("/last", handler.GetLastWorkspace())
+			r.Put("/last", handler.UpdateLastWorkspace())
 
 			// Single workspace routes
 			r.Route("/{workspaceId}", func(r chi.Router) {
-				r.Use(authMiddleware.RequireWorkspaceOwnership(db))
+				r.Use(authMiddleware.RequireWorkspaceAccess)
 
-				r.Get("/", handler.GetWorkspace(db))
-				r.Put("/", handler.UpdateWorkspace(db, fs))
-				r.Delete("/", handler.DeleteWorkspace(db))
+				r.Get("/", handler.GetWorkspace())
+				r.Put("/", handler.UpdateWorkspace())
+				r.Delete("/", handler.DeleteWorkspace())
 
 				// File routes
 				r.Route("/files", func(r chi.Router) {
-					r.Get("/", handler.ListFiles(fs))
-					r.Get("/last", handler.GetLastOpenedFile(db, fs))
-					r.Put("/last", handler.UpdateLastOpenedFile(db, fs))
-					r.Get("/lookup", handler.LookupFileByName(fs))
+					r.Get("/", handler.ListFiles())
+					r.Get("/last", handler.GetLastOpenedFile())
+					r.Put("/last", handler.UpdateLastOpenedFile())
+					r.Get("/lookup", handler.LookupFileByName())
 
-					r.Post("/*", handler.SaveFile(fs))
-					r.Get("/*", handler.GetFileContent(fs))
-					r.Delete("/*", handler.DeleteFile(fs))
+					r.Post("/*", handler.SaveFile())
+					r.Get("/*", handler.GetFileContent())
+					r.Delete("/*", handler.DeleteFile())
 				})
 
 				// Git routes
 				r.Route("/git", func(r chi.Router) {
-					r.Post("/commit", handler.StageCommitAndPush(fs))
-					r.Post("/pull", handler.PullChanges(fs))
+					r.Post("/commit", handler.StageCommitAndPush())
+					r.Post("/pull", handler.PullChanges())
 				})
 			})
 		})

backend/internal/api/static_handler.go

@@ -1,70 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// StaticHandler serves static files with support for SPA routing and pre-compressed files
-type StaticHandler struct {
-	staticPath string
-}
-
-func NewStaticHandler(staticPath string) *StaticHandler {
-	return &StaticHandler{
-		staticPath: staticPath,
-	}
-}
-
-func (h *StaticHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Get the requested path
-	requestedPath := r.URL.Path
-	fullPath := filepath.Join(h.staticPath, requestedPath)
-	cleanPath := filepath.Clean(fullPath)
-
-	// Security check to prevent directory traversal
-	if !strings.HasPrefix(cleanPath, h.staticPath) {
-		http.Error(w, "Invalid path", http.StatusBadRequest)
-		return
-	}
-
-	// Set cache headers for assets
-	if strings.HasPrefix(requestedPath, "/assets/") {
-		w.Header().Set("Cache-Control", "public, max-age=31536000") // 1 year
-	}
-
-	// Check if file exists (not counting .gz files)
-	stat, err := os.Stat(cleanPath)
-	if err != nil || stat.IsDir() {
-		// Serve index.html for SPA routing
-		indexPath := filepath.Join(h.staticPath, "index.html")
-		http.ServeFile(w, r, indexPath)
-		return
-	}
-
-	// Check for pre-compressed version
-	if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
-		gzPath := cleanPath + ".gz"
-		if _, err := os.Stat(gzPath); err == nil {
-			w.Header().Set("Content-Encoding", "gzip")
-
-			// Set proper content type based on original file
-			switch filepath.Ext(cleanPath) {
-			case ".js":
-				w.Header().Set("Content-Type", "application/javascript")
-			case ".css":
-				w.Header().Set("Content-Type", "text/css")
-			case ".html":
-				w.Header().Set("Content-Type", "text/html")
-			}
-
-			http.ServeFile(w, r, gzPath)
-			return
-		}
-	}
-
-	// Serve original file
-	http.ServeFile(w, r, cleanPath)
-}

backend/internal/api/user_handlers.go

@@ -1,24 +0,0 @@
-package api
-
-import (
-	"net/http"
-
-	"novamd/internal/db"
-)
-
-func (h *BaseHandler) GetUser(db *db.DB) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		user, err := db.GetUserByID(ctx.UserID)
-		if err != nil {
-			http.Error(w, "Failed to get user", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, user)
-	}
-}

backend/internal/api/workspace_handlers.go

@@ -1,236 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"net/http"
-
-	"novamd/internal/db"
-	"novamd/internal/filesystem"
-	"novamd/internal/models"
-)
-
-func (h *BaseHandler) ListWorkspaces(db *db.DB) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		workspaces, err := db.GetWorkspacesByUserID(ctx.UserID)
-		if err != nil {
-			http.Error(w, "Failed to list workspaces", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, workspaces)
-	}
-}
-
-func (h *BaseHandler) CreateWorkspace(db *db.DB, fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		var workspace models.Workspace
-		if err := json.NewDecoder(r.Body).Decode(&workspace); err != nil {
-			http.Error(w, "Invalid request body", http.StatusBadRequest)
-			return
-		}
-
-		workspace.UserID = ctx.UserID
-		if err := db.CreateWorkspace(&workspace); err != nil {
-			http.Error(w, "Failed to create workspace", http.StatusInternalServerError)
-			return
-		}
-
-		if err := fs.InitializeUserWorkspace(workspace.UserID, workspace.ID); err != nil {
-			http.Error(w, "Failed to initialize workspace directory", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, workspace)
-	}
-}
-
-func (h *BaseHandler) GetWorkspace(db *db.DB) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		respondJSON(w, ctx.Workspace)
-	}
-}
-
-func gitSettingsChanged(new, old *models.Workspace) bool {
-	// Check if Git was enabled/disabled
-	if new.GitEnabled != old.GitEnabled {
-		return true
-	}
-
-	// If Git is enabled, check if any settings changed
-	if new.GitEnabled {
-		return new.GitURL != old.GitURL ||
-			new.GitUser != old.GitUser ||
-			new.GitToken != old.GitToken
-	}
-
-	return false
-}
-
-func (h *BaseHandler) UpdateWorkspace(db *db.DB, fs *filesystem.FileSystem) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		var workspace models.Workspace
-		if err := json.NewDecoder(r.Body).Decode(&workspace); err != nil {
-			http.Error(w, "Invalid request body", http.StatusBadRequest)
-			return
-		}
-
-		// Set IDs from the request
-		workspace.ID = ctx.Workspace.ID
-		workspace.UserID = ctx.UserID
-
-		// Validate the workspace
-		if err := workspace.Validate(); err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		// Handle Git repository setup/teardown if Git settings changed
-		if gitSettingsChanged(&workspace, ctx.Workspace) {
-			if workspace.GitEnabled {
-				if err := fs.SetupGitRepo(
-					ctx.UserID,
-					ctx.Workspace.ID,
-					workspace.GitURL,
-					workspace.GitUser,
-					workspace.GitToken,
-				); err != nil {
-					http.Error(w, "Failed to setup git repo: "+err.Error(), http.StatusInternalServerError)
-					return
-				}
-
-			} else {
-				fs.DisableGitRepo(ctx.UserID, ctx.Workspace.ID)
-			}
-		}
-
-		if err := db.UpdateWorkspace(&workspace); err != nil {
-			http.Error(w, "Failed to update workspace", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, workspace)
-	}
-}
-
-func (h *BaseHandler) DeleteWorkspace(db *db.DB) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		// Check if this is the user's last workspace
-		workspaces, err := db.GetWorkspacesByUserID(ctx.UserID)
-		if err != nil {
-			http.Error(w, "Failed to get workspaces", http.StatusInternalServerError)
-			return
-		}
-
-		if len(workspaces) <= 1 {
-			http.Error(w, "Cannot delete the last workspace", http.StatusBadRequest)
-			return
-		}
-
-		// Find another workspace to set as last
-		var nextWorkspaceID int
-		for _, ws := range workspaces {
-			if ws.ID != ctx.Workspace.ID {
-				nextWorkspaceID = ws.ID
-				break
-			}
-		}
-
-		// Start transaction
-		tx, err := db.Begin()
-		if err != nil {
-			http.Error(w, "Failed to start transaction", http.StatusInternalServerError)
-			return
-		}
-		defer tx.Rollback()
-
-		// Update last workspace ID first
-		err = db.UpdateLastWorkspaceTx(tx, ctx.UserID, nextWorkspaceID)
-		if err != nil {
-			http.Error(w, "Failed to update last workspace", http.StatusInternalServerError)
-			return
-		}
-
-		// Delete the workspace
-		err = db.DeleteWorkspaceTx(tx, ctx.Workspace.ID)
-		if err != nil {
-			http.Error(w, "Failed to delete workspace", http.StatusInternalServerError)
-			return
-		}
-
-		// Commit transaction
-		if err = tx.Commit(); err != nil {
-			http.Error(w, "Failed to commit transaction", http.StatusInternalServerError)
-			return
-		}
-
-		// Return the next workspace ID in the response so frontend knows where to redirect
-		respondJSON(w, map[string]int{"nextWorkspaceId": nextWorkspaceID})
-	}
-}
-
-func (h *BaseHandler) GetLastWorkspace(db *db.DB) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		workspaceID, err := db.GetLastWorkspaceID(ctx.UserID)
-		if err != nil {
-			http.Error(w, "Failed to get last workspace", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, map[string]int{"lastWorkspaceId": workspaceID})
-	}
-}
-
-func (h *BaseHandler) UpdateLastWorkspace(db *db.DB) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		ctx, ok := h.getContext(w, r)
-		if !ok {
-			return
-		}
-
-		var requestBody struct {
-			WorkspaceID int `json:"workspaceId"`
-		}
-
-		if err := json.NewDecoder(r.Body).Decode(&requestBody); err != nil {
-			http.Error(w, "Invalid request body", http.StatusBadRequest)
-			return
-		}
-
-		if err := db.UpdateLastWorkspace(ctx.UserID, requestBody.WorkspaceID); err != nil {
-			http.Error(w, "Failed to update last workspace", http.StatusInternalServerError)
-			return
-		}
-
-		respondJSON(w, map[string]string{"message": "Last workspace updated successfully"})
-	}
-}