phase 2 initial test

internal/api/handlers/repos.go

@@ -3,36 +3,199 @@ package handlers
 import (
 	"encoding/json"
 	"net/http"
+	"path/filepath"
+	"strconv"
+
+	"github.com/go-chi/chi/v5"
+	"xorm.io/xorm"
+
+	"github.com/forgeo/forgebucket/internal/api/middleware"
+	"github.com/forgeo/forgebucket/internal/config"
+	gitdomain "github.com/forgeo/forgebucket/internal/domain/git"
+	"github.com/forgeo/forgebucket/internal/models"
 )
 
-type RepoHandler struct{}
+type RepoHandler struct {
+	db  *xorm.Engine
+	cfg *config.Config
+}
 
-func NewRepoHandler() *RepoHandler {
-	return &RepoHandler{}
+func NewRepoHandler(db *xorm.Engine, cfg *config.Config) *RepoHandler {
+	return &RepoHandler{db: db, cfg: cfg}
 }
 
 func (h *RepoHandler) List(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode([]any{})
+	userID, _ := middleware.UserIDFromContext(r.Context())
+
+	var repos []models.Repository
+	if err := h.db.Where("owner_id = ?", userID).Find(&repos); err != nil {
+		jsonError(w, "could not list repositories", http.StatusInternalServerError)
+		return
+	}
+	if repos == nil {
+		repos = []models.Repository{}
+	}
+	jsonOK(w, repos)
 }
 
 func (h *RepoHandler) Create(w http.ResponseWriter, r *http.Request) {
+	userID, _ := middleware.UserIDFromContext(r.Context())
+
+	var body struct {
+		Name        string `json:"name"`
+		Description string `json:"description"`
+		IsPrivate   bool   `json:"isPrivate"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		jsonError(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+	if body.Name == "" {
+		jsonError(w, "name is required", http.StatusBadRequest)
+		return
+	}
+
+	diskPath := filepath.Join(h.cfg.RepoRoot, strconv.FormatInt(userID, 10), body.Name+".git")
+
+	repo := &models.Repository{
+		OwnerID:       userID,
+		Name:          body.Name,
+		Description:   body.Description,
+		IsPrivate:     body.IsPrivate,
+		DefaultBranch: "main",
+		DiskPath:      diskPath,
+	}
+
+	// Initialise bare repo on disk before inserting to DB
+	gitdomain.SetRepoRoot(h.cfg.RepoRoot)
+	if err := gitdomain.Init(diskPath); err != nil {
+		jsonError(w, "could not initialise git repository", http.StatusInternalServerError)
+		return
+	}
+
+	if _, err := h.db.Insert(repo); err != nil {
+		jsonError(w, "repository name already taken", http.StatusConflict)
+		return
+	}
+
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusCreated)
-	json.NewEncoder(w).Encode(map[string]string{"status": "created"})
+	json.NewEncoder(w).Encode(repo)
 }
 
 func (h *RepoHandler) Get(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+	repo, ok := h.lookupRepo(w, r)
+	if !ok {
+		return
+	}
+	jsonOK(w, repo)
 }
 
 func (h *RepoHandler) Tree(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode([]any{})
+	repo, ok := h.lookupRepo(w, r)
+	if !ok {
+		return
+	}
+
+	ref := r.URL.Query().Get("ref")
+	if ref == "" {
+		ref = repo.DefaultBranch
+	}
+	subPath := r.URL.Query().Get("path")
+
+	gitdomain.SetRepoRoot(h.cfg.RepoRoot)
+	entries, err := gitdomain.TreeLS(repo.DiskPath, ref, subPath)
+	if err != nil {
+		jsonError(w, "could not read tree", http.StatusInternalServerError)
+		return
+	}
+	if entries == nil {
+		entries = []gitdomain.TreeEntry{}
+	}
+	jsonOK(w, entries)
 }
 
 func (h *RepoHandler) Blob(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(map[string]string{"content": ""})
+	repo, ok := h.lookupRepo(w, r)
+	if !ok {
+		return
+	}
+
+	ref := r.URL.Query().Get("ref")
+	if ref == "" {
+		ref = repo.DefaultBranch
+	}
+	path := r.URL.Query().Get("path")
+	if path == "" {
+		jsonError(w, "path is required", http.StatusBadRequest)
+		return
+	}
+
+	gitdomain.SetRepoRoot(h.cfg.RepoRoot)
+	content, err := gitdomain.BlobCat(repo.DiskPath, ref, path)
+	if err != nil {
+		jsonError(w, "file not found", http.StatusNotFound)
+		return
+	}
+	jsonOK(w, map[string]string{"content": string(content), "path": path, "ref": ref})
+}
+
+func (h *RepoHandler) Commits(w http.ResponseWriter, r *http.Request) {
+	repo, ok := h.lookupRepo(w, r)
+	if !ok {
+		return
+	}
+
+	ref := r.URL.Query().Get("ref")
+	if ref == "" {
+		ref = repo.DefaultBranch
+	}
+	limit := 30
+	if l := r.URL.Query().Get("limit"); l != "" {
+		if n, err := strconv.Atoi(l); err == nil && n > 0 && n <= 100 {
+			limit = n
+		}
+	}
+
+	gitdomain.SetRepoRoot(h.cfg.RepoRoot)
+	commits, err := gitdomain.Log(repo.DiskPath, ref, limit)
+	if err != nil {
+		jsonError(w, "could not read commits", http.StatusInternalServerError)
+		return
+	}
+	if commits == nil {
+		commits = []gitdomain.Commit{}
+	}
+	jsonOK(w, commits)
+}
+
+// lookupRepo resolves {owner}/{repo} URL params to a DB row, enforcing access.
+func (h *RepoHandler) lookupRepo(w http.ResponseWriter, r *http.Request) (*models.Repository, bool) {
+	ownerName := chi.URLParam(r, "owner")
+	repoName := chi.URLParam(r, "repo")
+
+	var owner models.User
+	found, err := h.db.Where("username = ?", ownerName).Get(&owner)
+	if err != nil || !found {
+		jsonError(w, "repository not found", http.StatusNotFound)
+		return nil, false
+	}
+
+	var repo models.Repository
+	found, err = h.db.Where("owner_id = ? AND name = ?", owner.ID, repoName).Get(&repo)
+	if err != nil || !found {
+		jsonError(w, "repository not found", http.StatusNotFound)
+		return nil, false
+	}
+
+	// Private repo: only the owner may access (RBAC will be expanded in Phase 3)
+	if repo.IsPrivate {
+		callerID, _ := middleware.UserIDFromContext(r.Context())
+		if callerID != repo.OwnerID {
+			jsonError(w, "repository not found", http.StatusNotFound)
+			return nil, false
+		}
+	}
+
+	return &repo, true
 }