commit 352514b4f452bad69b9a652de6b439623ff06162 · bretton.dev/coves

+54

internal/api/handlers/aggregator/errors.go

···

       1
       1
       +
       package aggregator

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/core/aggregators"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"log"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // ErrorResponse represents an XRPC error response

     

       11
       11
       +
       type ErrorResponse struct {

     

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

     

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

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // writeError writes a JSON error response

     

       17
       17
       +
       func writeError(w http.ResponseWriter, statusCode int, errorType, message string) {

     

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

     

       19
       19
       +
       	w.WriteHeader(statusCode)

     

       20
       20
       +
       	if err := json.NewEncoder(w).Encode(ErrorResponse{

     

       21
       21
       +
       		Error:   errorType,

     

       22
       22
       +
       		Message: message,

     

       23
       23
       +
       	}); err != nil {

     

       24
       24
       +
       		log.Printf("ERROR: Failed to encode error response: %v", err)

     

       25
       25
       +
       	}

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       // handleServiceError maps service errors to HTTP responses

     

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

     

       30
       30
       +
       	if err == nil {

     

       31
       31
       +
       		return

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       34
       34
       +
       	// Map domain errors to HTTP status codes

     

       35
       35
       +
       	switch {

     

       36
       36
       +
       	case aggregators.IsNotFound(err):

     

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

     

       38
       38
       +
       	case aggregators.IsValidationError(err):

     

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

     

       40
       40
       +
       	case aggregators.IsUnauthorized(err):

     

       41
       41
       +
       		writeError(w, http.StatusForbidden, "Forbidden", err.Error())

     

       42
       42
       +
       	case aggregators.IsConflict(err):

     

       43
       43
       +
       		writeError(w, http.StatusConflict, "Conflict", err.Error())

     

       44
       44
       +
       	case aggregators.IsRateLimited(err):

     

       45
       45
       +
       		writeError(w, http.StatusTooManyRequests, "RateLimitExceeded", err.Error())

     

       46
       46
       +
       	case aggregators.IsNotImplemented(err):

     

       47
       47
       +
       		writeError(w, http.StatusNotImplemented, "NotImplemented", "This feature is not yet available (Phase 2)")

     

       48
       48
       +
       	default:

     

       49
       49
       +
       		// Internal errors - don't leak details

     

       50
       50
       +
       		log.Printf("ERROR: Aggregator service error: %v", err)

     

       51
       51
       +
       		writeError(w, http.StatusInternalServerError, "InternalServerError",

     

       52
       52
       +
       			"An internal error occurred")

     

       53
       53
       +
       	}

     

       54
       54
       +
       }

+143

internal/api/handlers/aggregator/get_authorizations.go

···

       1
       1
       +
       package aggregator

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/core/aggregators"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"log"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"strconv"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // GetAuthorizationsHandler handles listing authorizations for an aggregator

     

       12
       12
       +
       type GetAuthorizationsHandler struct {

     

       13
       13
       +
       	service aggregators.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewGetAuthorizationsHandler creates a new get authorizations handler

     

       17
       17
       +
       func NewGetAuthorizationsHandler(service aggregators.Service) *GetAuthorizationsHandler {

     

       18
       18
       +
       	return &GetAuthorizationsHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // HandleGetAuthorizations lists all communities that authorized an aggregator

     

       24
       24
       +
       // GET /xrpc/social.coves.aggregator.getAuthorizations?aggregatorDid=did:plc:abc123&enabledOnly=true&limit=50&cursor=xyz

     

       25
       25
       +
       // Following Bluesky's pattern for listing feed subscribers

     

       26
       26
       +
       func (h *GetAuthorizationsHandler) HandleGetAuthorizations(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       29
       29
       +
       		return

     

       30
       30
       +
       	}

     

       31
       31
       +
       

     

       32
       32
       +
       	// Parse request

     

       33
       33
       +
       	req, err := h.parseRequest(r)

     

       34
       34
       +
       	if err != nil {

     

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

     

       36
       36
       +
       		return

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	// Get aggregator details first (needed for nested aggregator object in response)

     

       40
       40
       +
       	agg, err := h.service.GetAggregator(r.Context(), req.AggregatorDID)

     

       41
       41
       +
       	if err != nil {

     

       42
       42
       +
       		if aggregators.IsNotFound(err) {

     

       43
       43
       +
       			writeError(w, http.StatusNotFound, "AggregatorNotFound", "Aggregator DID does not exist or has no service declaration")

     

       44
       44
       +
       			return

     

       45
       45
       +
       		}

     

       46
       46
       +
       		handleServiceError(w, err)

     

       47
       47
       +
       		return

     

       48
       48
       +
       	}

     

       49
       49
       +
       

     

       50
       50
       +
       	// Get authorizations from service

     

       51
       51
       +
       	auths, err := h.service.GetAuthorizationsForAggregator(r.Context(), req)

     

       52
       52
       +
       	if err != nil {

     

       53
       53
       +
       		handleServiceError(w, err)

     

       54
       54
       +
       		return

     

       55
       55
       +
       	}

     

       56
       56
       +
       

     

       57
       57
       +
       	// Build response

     

       58
       58
       +
       	response := GetAuthorizationsResponse{

     

       59
       59
       +
       		Authorizations: make([]CommunityAuthView, 0, len(auths)),

     

       60
       60
       +
       	}

     

       61
       61
       +
       

     

       62
       62
       +
       	// Convert aggregator to view for nesting in each authorization

     

       63
       63
       +
       	aggregatorView := toAggregatorView(agg)

     

       64
       64
       +
       

     

       65
       65
       +
       	for _, auth := range auths {

     

       66
       66
       +
       		response.Authorizations = append(response.Authorizations, toCommunityAuthView(auth, aggregatorView))

     

       67
       67
       +
       	}

     

       68
       68
       +
       

     

       69
       69
       +
       	// Return response

     

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

     

       71
       71
       +
       	w.WriteHeader(http.StatusOK)

     

       72
       72
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       73
       73
       +
       		log.Printf("ERROR: Failed to encode getAuthorizations response: %v", err)

     

       74
       74
       +
       	}

     

       75
       75
       +
       }

     

       76
       76
       +
       

     

       77
       77
       +
       // parseRequest parses query parameters

     

       78
       78
       +
       func (h *GetAuthorizationsHandler) parseRequest(r *http.Request) (aggregators.GetAuthorizationsRequest, error) {

     

       79
       79
       +
       	req := aggregators.GetAuthorizationsRequest{}

     

       80
       80
       +
       

     

       81
       81
       +
       	// Required: aggregatorDid

     

       82
       82
       +
       	req.AggregatorDID = r.URL.Query().Get("aggregatorDid")

     

       83
       83
       +
       

     

       84
       84
       +
       	// Optional: enabledOnly (default: false)

     

       85
       85
       +
       	if enabledOnlyStr := r.URL.Query().Get("enabledOnly"); enabledOnlyStr == "true" {

     

       86
       86
       +
       		req.EnabledOnly = true

     

       87
       87
       +
       	}

     

       88
       88
       +
       

     

       89
       89
       +
       	// Optional: limit (default: 50, set by service)

     

       90
       90
       +
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       91
       91
       +
       		if limit, err := strconv.Atoi(limitStr); err == nil {

     

       92
       92
       +
       			req.Limit = limit

     

       93
       93
       +
       		}

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       96
       96
       +
       	// Optional: offset (default: 0)

     

       97
       97
       +
       	if offsetStr := r.URL.Query().Get("offset"); offsetStr != "" {

     

       98
       98
       +
       		if offset, err := strconv.Atoi(offsetStr); err == nil {

     

       99
       99
       +
       			req.Offset = offset

     

       100
       100
       +
       		}

     

       101
       101
       +
       	}

     

       102
       102
       +
       

     

       103
       103
       +
       	return req, nil

     

       104
       104
       +
       }

     

       105
       105
       +
       

     

       106
       106
       +
       // GetAuthorizationsResponse matches the lexicon output

     

       107
       107
       +
       type GetAuthorizationsResponse struct {

     

       108
       108
       +
       	Authorizations []CommunityAuthView `json:"authorizations"`

     

       109
       109
       +
       	Cursor         *string             `json:"cursor,omitempty"` // Pagination cursor

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       // CommunityAuthView matches social.coves.aggregator.defs#communityAuthView

     

       113
       113
       +
       // Shows authorization from aggregator's perspective with nested aggregator details

     

       114
       114
       +
       type CommunityAuthView struct {

     

       115
       115
       +
       	Aggregator AggregatorView `json:"aggregator"` // REQUIRED: Nested full aggregator object

     

       116
       116
       +
       	Enabled    bool           `json:"enabled"`    // REQUIRED

     

       117
       117
       +
       	Config     interface{}    `json:"config,omitempty"`

     

       118
       118
       +
       	CreatedAt  string         `json:"createdAt"` // REQUIRED

     

       119
       119
       +
       	RecordUri  string         `json:"recordUri,omitempty"`

     

       120
       120
       +
       }

     

       121
       121
       +
       

     

       122
       122
       +
       // toCommunityAuthView converts domain model to API view

     

       123
       123
       +
       func toCommunityAuthView(auth *aggregators.Authorization, aggregatorView AggregatorView) CommunityAuthView {

     

       124
       124
       +
       	view := CommunityAuthView{

     

       125
       125
       +
       		Aggregator: aggregatorView, // Nested aggregator object

     

       126
       126
       +
       		Enabled:    auth.Enabled,

     

       127
       127
       +
       		CreatedAt:  auth.CreatedAt.Format("2006-01-02T15:04:05.000Z"),

     

       128
       128
       +
       	}

     

       129
       129
       +
       

     

       130
       130
       +
       	// Add optional fields

     

       131
       131
       +
       	if len(auth.Config) > 0 {

     

       132
       132
       +
       		// Config is JSONB, unmarshal it

     

       133
       133
       +
       		var config interface{}

     

       134
       134
       +
       		if err := json.Unmarshal(auth.Config, &config); err == nil {

     

       135
       135
       +
       			view.Config = config

     

       136
       136
       +
       		}

     

       137
       137
       +
       	}

     

       138
       138
       +
       	if auth.RecordURI != "" {

     

       139
       139
       +
       		view.RecordUri = auth.RecordURI

     

       140
       140
       +
       	}

     

       141
       141
       +
       

     

       142
       142
       +
       	return view

     

       143
       143
       +
       }

+194

internal/api/handlers/aggregator/get_services.go

···

       1
       1
       +
       package aggregator

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/core/aggregators"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"log"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // GetServicesHandler handles aggregator service details retrieval

     

       12
       12
       +
       type GetServicesHandler struct {

     

       13
       13
       +
       	service aggregators.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewGetServicesHandler creates a new get services handler

     

       17
       17
       +
       func NewGetServicesHandler(service aggregators.Service) *GetServicesHandler {

     

       18
       18
       +
       	return &GetServicesHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // HandleGetServices retrieves aggregator details by DID(s)

     

       24
       24
       +
       // GET /xrpc/social.coves.aggregator.getServices?dids=did:plc:abc123,did:plc:def456&detailed=true

     

       25
       25
       +
       // Following Bluesky's pattern: app.bsky.feed.getFeedGenerators

     

       26
       26
       +
       func (h *GetServicesHandler) HandleGetServices(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       29
       29
       +
       		return

     

       30
       30
       +
       	}

     

       31
       31
       +
       

     

       32
       32
       +
       	// Parse DIDs from query parameter

     

       33
       33
       +
       	didsParam := r.URL.Query().Get("dids")

     

       34
       34
       +
       	if didsParam == "" {

     

       35
       35
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "dids parameter is required")

     

       36
       36
       +
       		return

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	// Parse detailed flag (default: false)

     

       40
       40
       +
       	detailed := r.URL.Query().Get("detailed") == "true"

     

       41
       41
       +
       

     

       42
       42
       +
       	// Split comma-separated DIDs

     

       43
       43
       +
       	rawDIDs := strings.Split(didsParam, ",")

     

       44
       44
       +
       

     

       45
       45
       +
       	// Trim whitespace and filter out empty DIDs (handles double commas, trailing commas, etc.)

     

       46
       46
       +
       	dids := make([]string, 0, len(rawDIDs))

     

       47
       47
       +
       	for _, did := range rawDIDs {

     

       48
       48
       +
       		trimmed := strings.TrimSpace(did)

     

       49
       49
       +
       		if trimmed != "" {

     

       50
       50
       +
       			dids = append(dids, trimmed)

     

       51
       51
       +
       		}

     

       52
       52
       +
       	}

     

       53
       53
       +
       

     

       54
       54
       +
       	// Validate we have at least one valid DID

     

       55
       55
       +
       	if len(dids) == 0 {

     

       56
       56
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "at least one valid DID is required")

     

       57
       57
       +
       		return

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	// Get aggregators from service

     

       61
       61
       +
       	aggs, err := h.service.GetAggregators(r.Context(), dids)

     

       62
       62
       +
       	if err != nil {

     

       63
       63
       +
       		handleServiceError(w, err)

     

       64
       64
       +
       		return

     

       65
       65
       +
       	}

     

       66
       66
       +
       

     

       67
       67
       +
       	// Build response with appropriate view type based on detailed flag

     

       68
       68
       +
       	response := GetServicesResponse{

     

       69
       69
       +
       		Views: make([]interface{}, 0, len(aggs)),

     

       70
       70
       +
       	}

     

       71
       71
       +
       

     

       72
       72
       +
       	for _, agg := range aggs {

     

       73
       73
       +
       		if detailed {

     

       74
       74
       +
       			response.Views = append(response.Views, toAggregatorViewDetailed(agg))

     

       75
       75
       +
       		} else {

     

       76
       76
       +
       			response.Views = append(response.Views, toAggregatorView(agg))

     

       77
       77
       +
       		}

     

       78
       78
       +
       	}

     

       79
       79
       +
       

     

       80
       80
       +
       	// Return response

     

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

     

       82
       82
       +
       	w.WriteHeader(http.StatusOK)

     

       83
       83
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       84
       84
       +
       		log.Printf("ERROR: Failed to encode getServices response: %v", err)

     

       85
       85
       +
       	}

     

       86
       86
       +
       }

     

       87
       87
       +
       

     

       88
       88
       +
       // GetServicesResponse matches the lexicon output

     

       89
       89
       +
       type GetServicesResponse struct {

     

       90
       90
       +
       	Views []interface{} `json:"views"` // Union of aggregatorView | aggregatorViewDetailed

     

       91
       91
       +
       }

     

       92
       92
       +
       

     

       93
       93
       +
       // AggregatorView matches social.coves.aggregator.defs#aggregatorView (without stats)

     

       94
       94
       +
       type AggregatorView struct {

     

       95
       95
       +
       	DID           string      `json:"did"`

     

       96
       96
       +
       	DisplayName   string      `json:"displayName"`

     

       97
       97
       +
       	Description   *string     `json:"description,omitempty"`

     

       98
       98
       +
       	Avatar        *string     `json:"avatar,omitempty"`

     

       99
       99
       +
       	ConfigSchema  interface{} `json:"configSchema,omitempty"`

     

       100
       100
       +
       	SourceURL     *string     `json:"sourceUrl,omitempty"`

     

       101
       101
       +
       	MaintainerDID *string     `json:"maintainer,omitempty"`

     

       102
       102
       +
       	CreatedAt     string      `json:"createdAt"`

     

       103
       103
       +
       	RecordUri     string      `json:"recordUri"`

     

       104
       104
       +
       }

     

       105
       105
       +
       

     

       106
       106
       +
       // AggregatorViewDetailed matches social.coves.aggregator.defs#aggregatorViewDetailed (with stats)

     

       107
       107
       +
       type AggregatorViewDetailed struct {

     

       108
       108
       +
       	DID           string           `json:"did"`

     

       109
       109
       +
       	DisplayName   string           `json:"displayName"`

     

       110
       110
       +
       	Description   *string          `json:"description,omitempty"`

     

       111
       111
       +
       	Avatar        *string          `json:"avatar,omitempty"`

     

       112
       112
       +
       	ConfigSchema  interface{}      `json:"configSchema,omitempty"`

     

       113
       113
       +
       	SourceURL     *string          `json:"sourceUrl,omitempty"`

     

       114
       114
       +
       	MaintainerDID *string          `json:"maintainer,omitempty"`

     

       115
       115
       +
       	CreatedAt     string           `json:"createdAt"`

     

       116
       116
       +
       	RecordUri     string           `json:"recordUri"`

     

       117
       117
       +
       	Stats         AggregatorStats  `json:"stats"`

     

       118
       118
       +
       }

     

       119
       119
       +
       

     

       120
       120
       +
       // AggregatorStats matches social.coves.aggregator.defs#aggregatorStats

     

       121
       121
       +
       type AggregatorStats struct {

     

       122
       122
       +
       	CommunitiesUsing int `json:"communitiesUsing"`

     

       123
       123
       +
       	PostsCreated     int `json:"postsCreated"`

     

       124
       124
       +
       }

     

       125
       125
       +
       

     

       126
       126
       +
       // toAggregatorView converts domain model to basic aggregatorView (no stats)

     

       127
       127
       +
       func toAggregatorView(agg *aggregators.Aggregator) AggregatorView {

     

       128
       128
       +
       	view := AggregatorView{

     

       129
       129
       +
       		DID:         agg.DID,

     

       130
       130
       +
       		DisplayName: agg.DisplayName,

     

       131
       131
       +
       		CreatedAt:   agg.CreatedAt.Format("2006-01-02T15:04:05.000Z"),

     

       132
       132
       +
       		RecordUri:   agg.RecordURI,

     

       133
       133
       +
       	}

     

       134
       134
       +
       

     

       135
       135
       +
       	// Add optional fields

     

       136
       136
       +
       	if agg.Description != "" {

     

       137
       137
       +
       		view.Description = &agg.Description

     

       138
       138
       +
       	}

     

       139
       139
       +
       	if agg.AvatarURL != "" {

     

       140
       140
       +
       		view.Avatar = &agg.AvatarURL

     

       141
       141
       +
       	}

     

       142
       142
       +
       	if agg.MaintainerDID != "" {

     

       143
       143
       +
       		view.MaintainerDID = &agg.MaintainerDID

     

       144
       144
       +
       	}

     

       145
       145
       +
       	if agg.SourceURL != "" {

     

       146
       146
       +
       		view.SourceURL = &agg.SourceURL

     

       147
       147
       +
       	}

     

       148
       148
       +
       	if len(agg.ConfigSchema) > 0 {

     

       149
       149
       +
       		// ConfigSchema is already JSON, unmarshal it for the view

     

       150
       150
       +
       		var schema interface{}

     

       151
       151
       +
       		if err := json.Unmarshal(agg.ConfigSchema, &schema); err == nil {

     

       152
       152
       +
       			view.ConfigSchema = schema

     

       153
       153
       +
       		}

     

       154
       154
       +
       	}

     

       155
       155
       +
       

     

       156
       156
       +
       	return view

     

       157
       157
       +
       }

     

       158
       158
       +
       

     

       159
       159
       +
       // toAggregatorViewDetailed converts domain model to detailed aggregatorViewDetailed (with stats)

     

       160
       160
       +
       func toAggregatorViewDetailed(agg *aggregators.Aggregator) AggregatorViewDetailed {

     

       161
       161
       +
       	view := AggregatorViewDetailed{

     

       162
       162
       +
       		DID:         agg.DID,

     

       163
       163
       +
       		DisplayName: agg.DisplayName,

     

       164
       164
       +
       		CreatedAt:   agg.CreatedAt.Format("2006-01-02T15:04:05.000Z"),

     

       165
       165
       +
       		RecordUri:   agg.RecordURI,

     

       166
       166
       +
       		Stats: AggregatorStats{

     

       167
       167
       +
       			CommunitiesUsing: agg.CommunitiesUsing,

     

       168
       168
       +
       			PostsCreated:     agg.PostsCreated,

     

       169
       169
       +
       		},

     

       170
       170
       +
       	}

     

       171
       171
       +
       

     

       172
       172
       +
       	// Add optional fields

     

       173
       173
       +
       	if agg.Description != "" {

     

       174
       174
       +
       		view.Description = &agg.Description

     

       175
       175
       +
       	}

     

       176
       176
       +
       	if agg.AvatarURL != "" {

     

       177
       177
       +
       		view.Avatar = &agg.AvatarURL

     

       178
       178
       +
       	}

     

       179
       179
       +
       	if agg.MaintainerDID != "" {

     

       180
       180
       +
       		view.MaintainerDID = &agg.MaintainerDID

     

       181
       181
       +
       	}

     

       182
       182
       +
       	if agg.SourceURL != "" {

     

       183
       183
       +
       		view.SourceURL = &agg.SourceURL

     

       184
       184
       +
       	}

     

       185
       185
       +
       	if len(agg.ConfigSchema) > 0 {

     

       186
       186
       +
       		// ConfigSchema is already JSON, unmarshal it for the view

     

       187
       187
       +
       		var schema interface{}

     

       188
       188
       +
       		if err := json.Unmarshal(agg.ConfigSchema, &schema); err == nil {

     

       189
       189
       +
       			view.ConfigSchema = schema

     

       190
       190
       +
       		}

     

       191
       191
       +
       	}

     

       192
       192
       +
       

     

       193
       193
       +
       	return view

     

       194
       194
       +
       }

+173

internal/api/handlers/aggregator/list_for_community.go

···

       1
       1
       +
       package aggregator

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/core/aggregators"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"log"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"strconv"

     

       9
       9
       +
       )

     

       10
       10
       +
       

     

       11
       11
       +
       // ListForCommunityHandler handles listing aggregators for a community

     

       12
       12
       +
       type ListForCommunityHandler struct {

     

       13
       13
       +
       	service aggregators.Service

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       // NewListForCommunityHandler creates a new list for community handler

     

       17
       17
       +
       func NewListForCommunityHandler(service aggregators.Service) *ListForCommunityHandler {

     

       18
       18
       +
       	return &ListForCommunityHandler{

     

       19
       19
       +
       		service: service,

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       // HandleListForCommunity lists all aggregators authorized by a community

     

       24
       24
       +
       // GET /xrpc/social.coves.aggregator.listForCommunity?community=did:plc:xyz789&enabledOnly=true&limit=50&cursor=xyz

     

       25
       25
       +
       // Used by community settings UI to manage aggregators

     

       26
       26
       +
       func (h *ListForCommunityHandler) HandleListForCommunity(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       29
       29
       +
       		return

     

       30
       30
       +
       	}

     

       31
       31
       +
       

     

       32
       32
       +
       	// Parse request

     

       33
       33
       +
       	req, communityIdentifier, err := h.parseRequest(r)

     

       34
       34
       +
       	if err != nil {

     

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

     

       36
       36
       +
       		return

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	// Resolve community identifier to DID (handles both DIDs and handles)

     

       40
       40
       +
       	// TODO: Implement identifier resolution service - for now, assume it's a DID

     

       41
       41
       +
       	req.CommunityDID = communityIdentifier

     

       42
       42
       +
       

     

       43
       43
       +
       	// Get authorizations from service

     

       44
       44
       +
       	// Note: Community handle/name fields will be empty until we integrate with communities service

     

       45
       45
       +
       	// This is acceptable for alpha - clients can resolve community details separately if needed

     

       46
       46
       +
       	auths, err := h.service.ListAggregatorsForCommunity(r.Context(), req)

     

       47
       47
       +
       	if err != nil {

     

       48
       48
       +
       		handleServiceError(w, err)

     

       49
       49
       +
       		return

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	// Build response

     

       53
       53
       +
       	response := ListForCommunityResponse{

     

       54
       54
       +
       		Aggregators: make([]AuthorizationView, 0, len(auths)),

     

       55
       55
       +
       	}

     

       56
       56
       +
       

     

       57
       57
       +
       	for _, auth := range auths {

     

       58
       58
       +
       		response.Aggregators = append(response.Aggregators, toAuthorizationView(auth, req.CommunityDID))

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	// Return response

     

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

     

       63
       63
       +
       	w.WriteHeader(http.StatusOK)

     

       64
       64
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       65
       65
       +
       		log.Printf("ERROR: Failed to encode listForCommunity response: %v", err)

     

       66
       66
       +
       	}

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       // parseRequest parses query parameters and returns request + community identifier

     

       70
       70
       +
       func (h *ListForCommunityHandler) parseRequest(r *http.Request) (aggregators.ListForCommunityRequest, string, error) {

     

       71
       71
       +
       	req := aggregators.ListForCommunityRequest{}

     

       72
       72
       +
       

     

       73
       73
       +
       	// Required: community (at-identifier: DID or handle)

     

       74
       74
       +
       	communityIdentifier := r.URL.Query().Get("community")

     

       75
       75
       +
       	if communityIdentifier == "" {

     

       76
       76
       +
       		return req, "", writeErrorMsg("community parameter is required")

     

       77
       77
       +
       	}

     

       78
       78
       +
       

     

       79
       79
       +
       	// Optional: enabledOnly (default: false per lexicon)

     

       80
       80
       +
       	if enabledOnlyStr := r.URL.Query().Get("enabledOnly"); enabledOnlyStr == "true" {

     

       81
       81
       +
       		req.EnabledOnly = true

     

       82
       82
       +
       	}

     

       83
       83
       +
       

     

       84
       84
       +
       	// Optional: limit (default: 50, set by service)

     

       85
       85
       +
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       86
       86
       +
       		if limit, err := strconv.Atoi(limitStr); err == nil {

     

       87
       87
       +
       			req.Limit = limit

     

       88
       88
       +
       		}

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	// TODO: Add cursor-based pagination support

     

       92
       92
       +
       	// if cursor := r.URL.Query().Get("cursor"); cursor != "" {

     

       93
       93
       +
       	//     req.Cursor = cursor

     

       94
       94
       +
       	// }

     

       95
       95
       +
       

     

       96
       96
       +
       	return req, communityIdentifier, nil

     

       97
       97
       +
       }

     

       98
       98
       +
       

     

       99
       99
       +
       // writeErrorMsg creates an error for returning

     

       100
       100
       +
       func writeErrorMsg(msg string) error {

     

       101
       101
       +
       	return &requestError{Message: msg}

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       type requestError struct {

     

       105
       105
       +
       	Message string

     

       106
       106
       +
       }

     

       107
       107
       +
       

     

       108
       108
       +
       func (e *requestError) Error() string {

     

       109
       109
       +
       	return e.Message

     

       110
       110
       +
       }

     

       111
       111
       +
       

     

       112
       112
       +
       // ListForCommunityResponse matches the lexicon output

     

       113
       113
       +
       type ListForCommunityResponse struct {

     

       114
       114
       +
       	Aggregators []AuthorizationView `json:"aggregators"`

     

       115
       115
       +
       	Cursor      *string             `json:"cursor,omitempty"` // Pagination cursor

     

       116
       116
       +
       }

     

       117
       117
       +
       

     

       118
       118
       +
       // AuthorizationView matches social.coves.aggregator.defs#authorizationView

     

       119
       119
       +
       // Shows authorization from community's perspective

     

       120
       120
       +
       type AuthorizationView struct {

     

       121
       121
       +
       	AggregatorDID   string      `json:"aggregatorDid"`

     

       122
       122
       +
       	CommunityDID    string      `json:"communityDid"`

     

       123
       123
       +
       	CommunityHandle *string     `json:"communityHandle,omitempty"` // Optional: populated when communities service integration is complete

     

       124
       124
       +
       	CommunityName   *string     `json:"communityName,omitempty"`   // Optional: populated when communities service integration is complete

     

       125
       125
       +
       	Enabled         bool        `json:"enabled"`

     

       126
       126
       +
       	Config          interface{} `json:"config,omitempty"`

     

       127
       127
       +
       	CreatedAt       string      `json:"createdAt"` // REQUIRED

     

       128
       128
       +
       	CreatedBy       *string     `json:"createdBy,omitempty"`

     

       129
       129
       +
       	DisabledAt      *string     `json:"disabledAt,omitempty"`

     

       130
       130
       +
       	DisabledBy      *string     `json:"disabledBy,omitempty"`

     

       131
       131
       +
       	RecordUri       string      `json:"recordUri,omitempty"`

     

       132
       132
       +
       }

     

       133
       133
       +
       

     

       134
       134
       +
       // toAuthorizationView converts domain model to API view

     

       135
       135
       +
       // communityHandle and communityName are left nil until communities service integration is complete

     

       136
       136
       +
       func toAuthorizationView(auth *aggregators.Authorization, communityDID string) AuthorizationView {

     

       137
       137
       +
       	// Safety check for nil authorization

     

       138
       138
       +
       	if auth == nil {

     

       139
       139
       +
       		return AuthorizationView{}

     

       140
       140
       +
       	}

     

       141
       141
       +
       

     

       142
       142
       +
       	view := AuthorizationView{

     

       143
       143
       +
       		AggregatorDID: auth.AggregatorDID,

     

       144
       144
       +
       		CommunityDID:  communityDID,

     

       145
       145
       +
       		// CommunityHandle and CommunityName left nil - TODO: fetch from communities service

     

       146
       146
       +
       		Enabled:   auth.Enabled,

     

       147
       147
       +
       		CreatedAt: auth.CreatedAt.Format("2006-01-02T15:04:05.000Z"),

     

       148
       148
       +
       	}

     

       149
       149
       +
       

     

       150
       150
       +
       	// Add optional fields

     

       151
       151
       +
       	if len(auth.Config) > 0 {

     

       152
       152
       +
       		// Config is JSONB, unmarshal it

     

       153
       153
       +
       		var config interface{}

     

       154
       154
       +
       		if err := json.Unmarshal(auth.Config, &config); err == nil {

     

       155
       155
       +
       			view.Config = config

     

       156
       156
       +
       		}

     

       157
       157
       +
       	}

     

       158
       158
       +
       	if auth.CreatedBy != "" {

     

       159
       159
       +
       		view.CreatedBy = &auth.CreatedBy

     

       160
       160
       +
       	}

     

       161
       161
       +
       	if auth.DisabledAt != nil && !auth.DisabledAt.IsZero() {

     

       162
       162
       +
       		disabledAt := auth.DisabledAt.Format("2006-01-02T15:04:05.000Z")

     

       163
       163
       +
       		view.DisabledAt = &disabledAt

     

       164
       164
       +
       	}

     

       165
       165
       +
       	if auth.DisabledBy != "" {

     

       166
       166
       +
       		view.DisabledBy = &auth.DisabledBy

     

       167
       167
       +
       	}

     

       168
       168
       +
       	if auth.RecordURI != "" {

     

       169
       169
       +
       		view.RecordUri = auth.RecordURI

     

       170
       170
       +
       	}

     

       171
       171
       +
       

     

       172
       172
       +
       	return view

     

       173
       173
       +
       }

+39

internal/api/routes/aggregator.go

···

       1
       1
       +
       package routes

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/api/handlers/aggregator"

     

       5
       5
       +
       	"Coves/internal/core/aggregators"

     

       6
       6
       +
       

     

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

     

       8
       8
       +
       )

     

       9
       9
       +
       

     

       10
       10
       +
       // RegisterAggregatorRoutes registers aggregator-related XRPC endpoints

     

       11
       11
       +
       // Following Bluesky's pattern for feed generators and labelers

     

       12
       12
       +
       func RegisterAggregatorRoutes(

     

       13
       13
       +
       	r chi.Router,

     

       14
       14
       +
       	aggregatorService aggregators.Service,

     

       15
       15
       +
       ) {

     

       16
       16
       +
       	// Create query handlers

     

       17
       17
       +
       	getServicesHandler := aggregator.NewGetServicesHandler(aggregatorService)

     

       18
       18
       +
       	getAuthorizationsHandler := aggregator.NewGetAuthorizationsHandler(aggregatorService)

     

       19
       19
       +
       	listForCommunityHandler := aggregator.NewListForCommunityHandler(aggregatorService)

     

       20
       20
       +
       

     

       21
       21
       +
       	// Query endpoints (public - no auth required)

     

       22
       22
       +
       	// GET /xrpc/social.coves.aggregator.getServices?dids=did:plc:abc,did:plc:def

     

       23
       23
       +
       	// Following app.bsky.feed.getFeedGenerators pattern

     

       24
       24
       +
       	r.Get("/xrpc/social.coves.aggregator.getServices", getServicesHandler.HandleGetServices)

     

       25
       25
       +
       

     

       26
       26
       +
       	// GET /xrpc/social.coves.aggregator.getAuthorizations?aggregatorDid=did:plc:abc&enabledOnly=true

     

       27
       27
       +
       	// Lists communities that authorized an aggregator

     

       28
       28
       +
       	r.Get("/xrpc/social.coves.aggregator.getAuthorizations", getAuthorizationsHandler.HandleGetAuthorizations)

     

       29
       29
       +
       

     

       30
       30
       +
       	// GET /xrpc/social.coves.aggregator.listForCommunity?communityDid=did:plc:xyz&enabledOnly=true

     

       31
       31
       +
       	// Lists aggregators authorized by a community

     

       32
       32
       +
       	r.Get("/xrpc/social.coves.aggregator.listForCommunity", listForCommunityHandler.HandleListForCommunity)

     

       33
       33
       +
       

     

       34
       34
       +
       	// Write endpoints (Phase 2 - require authentication and moderator permissions)

     

       35
       35
       +
       	// TODO: Implement after Jetstream consumer is ready

     

       36
       36
       +
       	// POST /xrpc/social.coves.aggregator.enable (requires auth + moderator)

     

       37
       37
       +
       	// POST /xrpc/social.coves.aggregator.disable (requires auth + moderator)

     

       38
       38
       +
       	// POST /xrpc/social.coves.aggregator.updateConfig (requires auth + moderator)

     

       39
       39
       +
       }