commit 5466ac959681b58281dbf0d11651b402b7870564 · bretton.dev/coves

+72

internal/api/handlers/community/create.go

···

       1
       1
       +
       package community

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       

     

       7
       7
       +
       	"Coves/internal/core/communities"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // CreateHandler handles community creation

     

       11
       11
       +
       type CreateHandler struct {

     

       12
       12
       +
       	service communities.Service

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       // NewCreateHandler creates a new create handler

     

       16
       16
       +
       func NewCreateHandler(service communities.Service) *CreateHandler {

     

       17
       17
       +
       	return &CreateHandler{

     

       18
       18
       +
       		service: service,

     

       19
       19
       +
       	}

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       // HandleCreate creates a new community

     

       23
       23
       +
       // POST /xrpc/social.coves.community.create

     

       24
       24
       +
       // Body matches CreateCommunityRequest

     

       25
       25
       +
       func (h *CreateHandler) HandleCreate(w http.ResponseWriter, r *http.Request) {

     

       26
       26
       +
       	if r.Method != http.MethodPost {

     

       27
       27
       +
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       28
       28
       +
       		return

     

       29
       29
       +
       	}

     

       30
       30
       +
       

     

       31
       31
       +
       	// Parse request body

     

       32
       32
       +
       	var req communities.CreateCommunityRequest

     

       33
       33
       +
       	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {

     

       34
       34
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "Invalid request body")

     

       35
       35
       +
       		return

     

       36
       36
       +
       	}

     

       37
       37
       +
       

     

       38
       38
       +
       	// TODO(Communities-OAuth): Extract authenticated user DID from request context

     

       39
       39
       +
       	// This MUST be replaced with OAuth middleware before production deployment

     

       40
       40
       +
       	// Expected implementation:

     

       41
       41
       +
       	//   userDID := r.Context().Value("authenticated_user_did").(string)

     

       42
       42
       +
       	//   req.CreatedByDID = userDID

     

       43
       43
       +
       	// For now, we require client to send it (INSECURE - allows impersonation)

     

       44
       44
       +
       	if req.CreatedByDID == "" {

     

       45
       45
       +
       		writeError(w, http.StatusUnauthorized, "AuthRequired", "Authentication required")

     

       46
       46
       +
       		return

     

       47
       47
       +
       	}

     

       48
       48
       +
       

     

       49
       49
       +
       	if req.HostedByDID == "" {

     

       50
       50
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "hostedByDid is required")

     

       51
       51
       +
       		return

     

       52
       52
       +
       	}

     

       53
       53
       +
       

     

       54
       54
       +
       	// Create community via service (write-forward to PDS)

     

       55
       55
       +
       	community, err := h.service.CreateCommunity(r.Context(), req)

     

       56
       56
       +
       	if err != nil {

     

       57
       57
       +
       		handleServiceError(w, err)

     

       58
       58
       +
       		return

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	// Return success response matching lexicon output

     

       62
       62
       +
       	response := map[string]interface{}{

     

       63
       63
       +
       		"uri":    community.RecordURI,

     

       64
       64
       +
       		"cid":    community.RecordCID,

     

       65
       65
       +
       		"did":    community.DID,

     

       66
       66
       +
       		"handle": community.Handle,

     

       67
       67
       +
       	}

     

       68
       68
       +
       

     

       69
       69
       +
       	w.Header().Set("Content-Type", "application/json")

     

       70
       70
       +
       	w.WriteHeader(http.StatusOK)

     

       71
       71
       +
       	json.NewEncoder(w).Encode(response)

     

       72
       72
       +
       }

+47

internal/api/handlers/community/errors.go

···

       1
       1
       +
       package community

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       

     

       7
       7
       +
       	"Coves/internal/core/communities"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // XRPCError represents an XRPC error response

     

       11
       11
       +
       type XRPCError struct {

     

       12
       12
       +
       	Error   string `json:"error"`

     

       13
       13
       +
       	Message string `json:"message"`

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // writeError writes an XRPC error response

     

       17
       17
       +
       func writeError(w http.ResponseWriter, status int, error, message string) {

     

       18
       18
       +
       	w.Header().Set("Content-Type", "application/json")

     

       19
       19
       +
       	w.WriteHeader(status)

     

       20
       20
       +
       	json.NewEncoder(w).Encode(XRPCError{

     

       21
       21
       +
       		Error:   error,

     

       22
       22
       +
       		Message: message,

     

       23
       23
       +
       	})

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       // handleServiceError converts service errors to appropriate HTTP responses

     

       27
       27
       +
       func handleServiceError(w http.ResponseWriter, err error) {

     

       28
       28
       +
       	switch {

     

       29
       29
       +
       	case communities.IsNotFound(err):

     

       30
       30
       +
       		writeError(w, http.StatusNotFound, "NotFound", err.Error())

     

       31
       31
       +
       	case communities.IsConflict(err):

     

       32
       32
       +
       		if err == communities.ErrHandleTaken {

     

       33
       33
       +
       			writeError(w, http.StatusConflict, "NameTaken", "Community handle is already taken")

     

       34
       34
       +
       		} else {

     

       35
       35
       +
       			writeError(w, http.StatusConflict, "AlreadyExists", err.Error())

     

       36
       36
       +
       		}

     

       37
       37
       +
       	case communities.IsValidationError(err):

     

       38
       38
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", err.Error())

     

       39
       39
       +
       	case err == communities.ErrUnauthorized:

     

       40
       40
       +
       		writeError(w, http.StatusForbidden, "Forbidden", "You do not have permission to perform this action")

     

       41
       41
       +
       	case err == communities.ErrMemberBanned:

     

       42
       42
       +
       		writeError(w, http.StatusForbidden, "Blocked", "You are blocked from this community")

     

       43
       43
       +
       	default:

     

       44
       44
       +
       		// Internal server error

     

       45
       45
       +
       		writeError(w, http.StatusInternalServerError, "InternalServerError", "An internal error occurred")

     

       46
       46
       +
       	}

     

       47
       47
       +
       }

+48

internal/api/handlers/community/get.go

···

       1
       1
       +
       package community

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       

     

       7
       7
       +
       	"Coves/internal/core/communities"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // GetHandler handles community retrieval

     

       11
       11
       +
       type GetHandler struct {

     

       12
       12
       +
       	service communities.Service

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       // NewGetHandler creates a new get handler

     

       16
       16
       +
       func NewGetHandler(service communities.Service) *GetHandler {

     

       17
       17
       +
       	return &GetHandler{

     

       18
       18
       +
       		service: service,

     

       19
       19
       +
       	}

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       // HandleGet retrieves a community by DID or handle

     

       23
       23
       +
       // GET /xrpc/social.coves.community.get?community={did_or_handle}

     

       24
       24
       +
       func (h *GetHandler) HandleGet(w http.ResponseWriter, r *http.Request) {

     

       25
       25
       +
       	if r.Method != http.MethodGet {

     

       26
       26
       +
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       27
       27
       +
       		return

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	// Get community identifier from query params

     

       31
       31
       +
       	communityID := r.URL.Query().Get("community")

     

       32
       32
       +
       	if communityID == "" {

     

       33
       33
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "community parameter is required")

     

       34
       34
       +
       		return

     

       35
       35
       +
       	}

     

       36
       36
       +
       

     

       37
       37
       +
       	// Get community from AppView DB

     

       38
       38
       +
       	community, err := h.service.GetCommunity(r.Context(), communityID)

     

       39
       39
       +
       	if err != nil {

     

       40
       40
       +
       		handleServiceError(w, err)

     

       41
       41
       +
       		return

     

       42
       42
       +
       	}

     

       43
       43
       +
       

     

       44
       44
       +
       	// Return community data

     

       45
       45
       +
       	w.Header().Set("Content-Type", "application/json")

     

       46
       46
       +
       	w.WriteHeader(http.StatusOK)

     

       47
       47
       +
       	json.NewEncoder(w).Encode(community)

     

       48
       48
       +
       }

+74

internal/api/handlers/community/list.go

···

       1
       1
       +
       package community

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"strconv"

     

       7
       7
       +
       

     

       8
       8
       +
       	"Coves/internal/core/communities"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // ListHandler handles listing communities

     

       12
       12
       +
       type ListHandler struct {

     

       13
       13
       +
       	service communities.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewListHandler creates a new list handler

     

       17
       17
       +
       func NewListHandler(service communities.Service) *ListHandler {

     

       18
       18
       +
       	return &ListHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // HandleList lists communities with filters

     

       24
       24
       +
       // GET /xrpc/social.coves.community.list?limit={n}&cursor={offset}&visibility={public|unlisted}&sortBy={created_at|member_count}

     

       25
       25
       +
       func (h *ListHandler) HandleList(w http.ResponseWriter, r *http.Request) {

     

       26
       26
       +
       	if r.Method != http.MethodGet {

     

       27
       27
       +
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       28
       28
       +
       		return

     

       29
       29
       +
       	}

     

       30
       30
       +
       

     

       31
       31
       +
       	// Parse query parameters

     

       32
       32
       +
       	query := r.URL.Query()

     

       33
       33
       +
       

     

       34
       34
       +
       	limit := 50

     

       35
       35
       +
       	if limitStr := query.Get("limit"); limitStr != "" {

     

       36
       36
       +
       		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 {

     

       37
       37
       +
       			limit = l

     

       38
       38
       +
       		}

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	offset := 0

     

       42
       42
       +
       	if cursorStr := query.Get("cursor"); cursorStr != "" {

     

       43
       43
       +
       		if o, err := strconv.Atoi(cursorStr); err == nil && o >= 0 {

     

       44
       44
       +
       			offset = o

     

       45
       45
       +
       		}

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	req := communities.ListCommunitiesRequest{

     

       49
       49
       +
       		Limit:      limit,

     

       50
       50
       +
       		Offset:     offset,

     

       51
       51
       +
       		Visibility: query.Get("visibility"),

     

       52
       52
       +
       		HostedBy:   query.Get("hostedBy"),

     

       53
       53
       +
       		SortBy:     query.Get("sortBy"),

     

       54
       54
       +
       		SortOrder:  query.Get("sortOrder"),

     

       55
       55
       +
       	}

     

       56
       56
       +
       

     

       57
       57
       +
       	// Get communities from AppView DB

     

       58
       58
       +
       	results, total, err := h.service.ListCommunities(r.Context(), req)

     

       59
       59
       +
       	if err != nil {

     

       60
       60
       +
       		handleServiceError(w, err)

     

       61
       61
       +
       		return

     

       62
       62
       +
       	}

     

       63
       63
       +
       

     

       64
       64
       +
       	// Build response

     

       65
       65
       +
       	response := map[string]interface{}{

     

       66
       66
       +
       		"communities": results,

     

       67
       67
       +
       		"cursor":      offset + len(results),

     

       68
       68
       +
       		"total":       total,

     

       69
       69
       +
       	}

     

       70
       70
       +
       

     

       71
       71
       +
       	w.Header().Set("Content-Type", "application/json")

     

       72
       72
       +
       	w.WriteHeader(http.StatusOK)

     

       73
       73
       +
       	json.NewEncoder(w).Encode(response)

     

       74
       74
       +
       }

+78

internal/api/handlers/community/search.go

···

       1
       1
       +
       package community

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"strconv"

     

       7
       7
       +
       

     

       8
       8
       +
       	"Coves/internal/core/communities"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // SearchHandler handles community search

     

       12
       12
       +
       type SearchHandler struct {

     

       13
       13
       +
       	service communities.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewSearchHandler creates a new search handler

     

       17
       17
       +
       func NewSearchHandler(service communities.Service) *SearchHandler {

     

       18
       18
       +
       	return &SearchHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // HandleSearch searches communities by name/description

     

       24
       24
       +
       // GET /xrpc/social.coves.community.search?q={query}&limit={n}&cursor={offset}

     

       25
       25
       +
       func (h *SearchHandler) HandleSearch(w http.ResponseWriter, r *http.Request) {

     

       26
       26
       +
       	if r.Method != http.MethodGet {

     

       27
       27
       +
       		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

     

       28
       28
       +
       		return

     

       29
       29
       +
       	}

     

       30
       30
       +
       

     

       31
       31
       +
       	// Parse query parameters

     

       32
       32
       +
       	query := r.URL.Query()

     

       33
       33
       +
       

     

       34
       34
       +
       	searchQuery := query.Get("q")

     

       35
       35
       +
       	if searchQuery == "" {

     

       36
       36
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "q parameter is required")

     

       37
       37
       +
       		return

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

       40
       40
       +
       	limit := 50

     

       41
       41
       +
       	if limitStr := query.Get("limit"); limitStr != "" {

     

       42
       42
       +
       		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 {

     

       43
       43
       +
       			limit = l

     

       44
       44
       +
       		}

     

       45
       45
       +
       	}

     

       46
       46
       +
       

     

       47
       47
       +
       	offset := 0

     

       48
       48
       +
       	if cursorStr := query.Get("cursor"); cursorStr != "" {

     

       49
       49
       +
       		if o, err := strconv.Atoi(cursorStr); err == nil && o >= 0 {

     

       50
       50
       +
       			offset = o

     

       51
       51
       +
       		}

     

       52
       52
       +
       	}

     

       53
       53
       +
       

     

       54
       54
       +
       	req := communities.SearchCommunitiesRequest{

     

       55
       55
       +
       		Query:      searchQuery,

     

       56
       56
       +
       		Limit:      limit,

     

       57
       57
       +
       		Offset:     offset,

     

       58
       58
       +
       		Visibility: query.Get("visibility"),

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	// Search communities in AppView DB

     

       62
       62
       +
       	results, total, err := h.service.SearchCommunities(r.Context(), req)

     

       63
       63
       +
       	if err != nil {

     

       64
       64
       +
       		handleServiceError(w, err)

     

       65
       65
       +
       		return

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

       68
       68
       +
       	// Build response

     

       69
       69
       +
       	response := map[string]interface{}{

     

       70
       70
       +
       		"communities": results,

     

       71
       71
       +
       		"cursor":      offset + len(results),

     

       72
       72
       +
       		"total":       total,

     

       73
       73
       +
       	}

     

       74
       74
       +
       

     

       75
       75
       +
       	w.Header().Set("Content-Type", "application/json")

     

       76
       76
       +
       	w.WriteHeader(http.StatusOK)

     

       77
       77
       +
       	json.NewEncoder(w).Encode(response)

     

       78
       78
       +
       }

+43

internal/api/routes/community.go

···

       1
       1
       +
       package routes

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"github.com/go-chi/chi/v5"

     

       5
       5
       +
       

     

       6
       6
       +
       	"Coves/internal/api/handlers/community"

     

       7
       7
       +
       	"Coves/internal/core/communities"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // RegisterCommunityRoutes registers community-related XRPC endpoints on the router

     

       11
       11
       +
       // Implements social.coves.community.* lexicon endpoints

     

       12
       12
       +
       func RegisterCommunityRoutes(r chi.Router, service communities.Service) {

     

       13
       13
       +
       	// Initialize handlers

     

       14
       14
       +
       	createHandler := community.NewCreateHandler(service)

     

       15
       15
       +
       	getHandler := community.NewGetHandler(service)

     

       16
       16
       +
       	listHandler := community.NewListHandler(service)

     

       17
       17
       +
       	searchHandler := community.NewSearchHandler(service)

     

       18
       18
       +
       	subscribeHandler := community.NewSubscribeHandler(service)

     

       19
       19
       +
       

     

       20
       20
       +
       	// Query endpoints (GET)

     

       21
       21
       +
       	// social.coves.community.get - get a single community by identifier

     

       22
       22
       +
       	r.Get("/xrpc/social.coves.community.get", getHandler.HandleGet)

     

       23
       23
       +
       

     

       24
       24
       +
       	// social.coves.community.list - list communities with filters

     

       25
       25
       +
       	r.Get("/xrpc/social.coves.community.list", listHandler.HandleList)

     

       26
       26
       +
       

     

       27
       27
       +
       	// social.coves.community.search - search communities

     

       28
       28
       +
       	r.Get("/xrpc/social.coves.community.search", searchHandler.HandleSearch)

     

       29
       29
       +
       

     

       30
       30
       +
       	// Procedure endpoints (POST) - write-forward operations

     

       31
       31
       +
       	// social.coves.community.create - create a new community

     

       32
       32
       +
       	r.Post("/xrpc/social.coves.community.create", createHandler.HandleCreate)

     

       33
       33
       +
       

     

       34
       34
       +
       	// social.coves.community.subscribe - subscribe to a community

     

       35
       35
       +
       	r.Post("/xrpc/social.coves.community.subscribe", subscribeHandler.HandleSubscribe)

     

       36
       36
       +
       

     

       37
       37
       +
       	// social.coves.community.unsubscribe - unsubscribe from a community

     

       38
       38
       +
       	r.Post("/xrpc/social.coves.community.unsubscribe", subscribeHandler.HandleUnsubscribe)

     

       39
       39
       +
       

     

       40
       40
       +
       	// TODO: Add update and delete handlers when implemented

     

       41
       41
       +
       	// r.Post("/xrpc/social.coves.community.update", updateHandler.HandleUpdate)

     

       42
       42
       +
       	// r.Post("/xrpc/social.coves.community.delete", deleteHandler.HandleDelete)

     

       43
       43
       +
       }