commit eef3a7195dcf76422f638cea00390d8fa529b310 · bretton.dev/coves

+56 -10

internal/api/handlers/community/list.go

···

       20
       20
        
       }

     

       21
       21
        
       

     

       22
       22
        
       // HandleList lists communities with filters

     

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

     

       23
       23
       +
       // GET /xrpc/social.coves.community.list?limit={n}&cursor={str}&sort={popular|active|new|alphabetical}&visibility={public|unlisted|private}

     

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

     

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

     

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

     
···

       30
       30
        
       	// Parse query parameters

     

       31
       31
        
       	query := r.URL.Query()

     

       32
       32
        
       

     

       33
       33
       +
       	// Parse limit (1-100, default 50)

     

       33
       34
        
       	limit := 50

     

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

     

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

     

       36
       36
       -
       			limit = l

     

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

     

       37
       37
       +
       			if l < 1 {

     

       38
       38
       +
       				limit = 1

     

       39
       39
       +
       			} else if l > 100 {

     

       40
       40
       +
       				limit = 100

     

       41
       41
       +
       			} else {

     

       42
       42
       +
       				limit = l

     

       43
       43
       +
       			}

     

       37
       44
        
       		}

     

       38
       45
        
       	}

     

       39
       46
        
       

     

       47
       47
       +
       	// Parse cursor (offset-based for now)

     

       40
       48
        
       	offset := 0

     

       41
       49
        
       	if cursorStr := query.Get("cursor"); cursorStr != "" {

     

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

     
···

       44
       52
        
       		}

     

       45
       53
        
       	}

     

       46
       54
        
       

     

       55
       55
       +
       	// Parse sort enum (default: popular)

     

       56
       56
       +
       	sort := query.Get("sort")

     

       57
       57
       +
       	if sort == "" {

     

       58
       58
       +
       		sort = "popular"

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	// Validate sort value

     

       62
       62
       +
       	validSorts := map[string]bool{

     

       63
       63
       +
       		"popular":      true,

     

       64
       64
       +
       		"active":       true,

     

       65
       65
       +
       		"new":          true,

     

       66
       66
       +
       		"alphabetical": true,

     

       67
       67
       +
       	}

     

       68
       68
       +
       	if !validSorts[sort] {

     

       69
       69
       +
       		http.Error(w, "Invalid sort value. Must be: popular, active, new, or alphabetical", http.StatusBadRequest)

     

       70
       70
       +
       		return

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	// Validate visibility value if provided

     

       74
       74
       +
       	visibility := query.Get("visibility")

     

       75
       75
       +
       	if visibility != "" {

     

       76
       76
       +
       		validVisibilities := map[string]bool{

     

       77
       77
       +
       			"public":   true,

     

       78
       78
       +
       			"unlisted": true,

     

       79
       79
       +
       			"private":  true,

     

       80
       80
       +
       		}

     

       81
       81
       +
       		if !validVisibilities[visibility] {

     

       82
       82
       +
       			http.Error(w, "Invalid visibility value. Must be: public, unlisted, or private", http.StatusBadRequest)

     

       83
       83
       +
       			return

     

       84
       84
       +
       		}

     

       85
       85
       +
       	}

     

       86
       86
       +
       

     

       47
       87
        
       	req := communities.ListCommunitiesRequest{

     

       48
       88
        
       		Limit:      limit,

     

       49
       89
        
       		Offset:     offset,

     

       50
       50
       -
       		Visibility: query.Get("visibility"),

     

       51
       51
       -
       		HostedBy:   query.Get("hostedBy"),

     

       52
       52
       -
       		SortBy:     query.Get("sortBy"),

     

       53
       53
       -
       		SortOrder:  query.Get("sortOrder"),

     

       90
       90
       +
       		Sort:       sort,

     

       91
       91
       +
       		Visibility: visibility,

     

       92
       92
       +
       		Category:   query.Get("category"),

     

       93
       93
       +
       		Language:   query.Get("language"),

     

       54
       94
        
       	}

     

       55
       95
        
       

     

       56
       96
        
       	// Get communities from AppView DB

     

       57
       57
       -
       	results, total, err := h.service.ListCommunities(r.Context(), req)

     

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

     

       58
       98
        
       	if err != nil {

     

       59
       99
        
       		handleServiceError(w, err)

     

       60
       100
        
       		return

     

       61
       101
        
       	}

     

       62
       102
        
       

     

       63
       103
        
       	// Build response

     

       104
       104
       +
       	var cursor string

     

       105
       105
       +
       	if len(results) == limit {

     

       106
       106
       +
       		// More results available - return next cursor

     

       107
       107
       +
       		cursor = strconv.Itoa(offset + len(results))

     

       108
       108
       +
       	}

     

       109
       109
       +
       	// If len(results) < limit, we've reached the end - cursor remains empty string

     

       110
       110
       +
       

     

       64
       111
        
       	response := map[string]interface{}{

     

       65
       112
        
       		"communities": results,

     

       66
       66
       -
       		"cursor":      offset + len(results),

     

       67
       67
       -
       		"total":       total,

     

       113
       113
       +
       		"cursor":      cursor,

     

       68
       114
        
       	}

     

       69
       115
        
       

     

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

+8 -8

internal/core/communities/community.go

···

       123
       123
        
       

     

       124
       124
        
       // ListCommunitiesRequest represents query parameters for listing communities

     

       125
       125
        
       type ListCommunitiesRequest struct {

     

       126
       126
       -
       	Visibility string `json:"visibility,omitempty"`

     

       127
       127
       -
       	HostedBy   string `json:"hostedBy,omitempty"`

     

       128
       128
       -
       	SortBy     string `json:"sortBy,omitempty"`

     

       129
       129
       -
       	SortOrder  string `json:"sortOrder,omitempty"`

     

       130
       130
       -
       	Limit      int    `json:"limit"`

     

       131
       131
       -
       	Offset     int    `json:"offset"`

     

       126
       126
       +
       	Sort       string `json:"sort,omitempty"`       // Enum: popular, active, new, alphabetical

     

       127
       127
       +
       	Visibility string `json:"visibility,omitempty"` // Filter: public, unlisted, private

     

       128
       128
       +
       	Category   string `json:"category,omitempty"`   // Optional: filter by category (future)

     

       129
       129
       +
       	Language   string `json:"language,omitempty"`   // Optional: filter by language (future)

     

       130
       130
       +
       	Limit      int    `json:"limit"`                // 1-100, default 50

     

       131
       131
       +
       	Offset     int    `json:"offset"`               // Pagination offset

     

       132
       132
        
       }

     

       133
       133
        
       

     

       134
       134
        
       // SearchCommunitiesRequest represents query parameters for searching communities

     
···

       159
       159
        
       	name := c.Handle[:communityIndex]

     

       160
       160
        
       

     

       161
       161
        
       	// Extract instance domain (everything after ".community.")

     

       162
       162
       -
       	// len(".community.") = 11

     

       163
       163
       -
       	instanceDomain := c.Handle[communityIndex+11:]

     

       162
       162
       +
       	communitySegment := ".community."

     

       163
       163
       +
       	instanceDomain := c.Handle[communityIndex+len(communitySegment):]

     

       164
       164
        
       

     

       165
       165
        
       	return fmt.Sprintf("!%s@%s", name, instanceDomain)

     

       166
       166
        
       }

+2 -2

internal/core/communities/interfaces.go

···

       16
       16
        
       	UpdateCredentials(ctx context.Context, did, accessToken, refreshToken string) error

     

       17
       17
        
       

     

       18
       18
        
       	// Listing & Search

     

       19
       19
       -
       	List(ctx context.Context, req ListCommunitiesRequest) ([]*Community, int, error) // Returns communities + total count

     

       19
       19
       +
       	List(ctx context.Context, req ListCommunitiesRequest) ([]*Community, error)

     

       20
       20
        
       	Search(ctx context.Context, req SearchCommunitiesRequest) ([]*Community, int, error)

     

       21
       21
        
       

     

       22
       22
        
       	// Subscriptions (lightweight feed follows)

     
···

       62
       62
        
       	CreateCommunity(ctx context.Context, req CreateCommunityRequest) (*Community, error)

     

       63
       63
        
       	GetCommunity(ctx context.Context, identifier string) (*Community, error) // identifier can be DID or handle

     

       64
       64
        
       	UpdateCommunity(ctx context.Context, req UpdateCommunityRequest) (*Community, error)

     

       65
       65
       -
       	ListCommunities(ctx context.Context, req ListCommunitiesRequest) ([]*Community, int, error)

     

       65
       65
       +
       	ListCommunities(ctx context.Context, req ListCommunitiesRequest) ([]*Community, error)

     

       66
       66
        
       	SearchCommunities(ctx context.Context, req SearchCommunitiesRequest) ([]*Community, int, error)

     

       67
       67
        
       

     

       68
       68
        
       	// Subscription operations (write-forward: creates record in user's PDS)

+1 -1

internal/core/communities/service.go

···

       528
       528
        
       }

     

       529
       529
        
       

     

       530
       530
        
       // ListCommunities queries AppView DB for communities with filters

     

       531
       531
       -
       func (s *communityService) ListCommunities(ctx context.Context, req ListCommunitiesRequest) ([]*Community, int, error) {

     

       531
       531
       +
       func (s *communityService) ListCommunities(ctx context.Context, req ListCommunitiesRequest) ([]*Community, error) {

     

       532
       532
        
       	// Set defaults

     

       533
       533
        
       	if req.Limit <= 0 || req.Limit > 100 {

     

       534
       534
        
       		req.Limit = 50

+33 -28

internal/db/postgres/community_repo.go

···

       344
       344
        
       }

     

       345
       345
        
       

     

       346
       346
        
       // List retrieves communities with filtering and pagination

     

       347
       347
       -
       func (r *postgresCommunityRepo) List(ctx context.Context, req communities.ListCommunitiesRequest) ([]*communities.Community, int, error) {

     

       347
       347
       +
       func (r *postgresCommunityRepo) List(ctx context.Context, req communities.ListCommunitiesRequest) ([]*communities.Community, error) {

     

       348
       348
        
       	// Build query with filters

     

       349
       349
        
       	whereClauses := []string{}

     

       350
       350
        
       	args := []interface{}{}

     
···

       356
       356
        
       		argCount++

     

       357
       357
        
       	}

     

       358
       358
        
       

     

       359
       359
       -
       	if req.HostedBy != "" {

     

       360
       360
       -
       		whereClauses = append(whereClauses, fmt.Sprintf("hosted_by_did = $%d", argCount))

     

       361
       361
       -
       		args = append(args, req.HostedBy)

     

       362
       362
       -
       		argCount++

     

       363
       363
       -
       	}

     

       359
       359
       +
       	// TODO: Add category filter when DB schema supports it

     

       360
       360
       +
       	// if req.Category != "" { ... }

     

       361
       361
       +
       

     

       362
       362
       +
       	// TODO: Add language filter when DB schema supports it

     

       363
       363
       +
       	// if req.Language != "" { ... }

     

       364
       364
        
       

     

       365
       365
        
       	whereClause := ""

     

       366
       366
        
       	if len(whereClauses) > 0 {

     

       367
       367
        
       		whereClause = "WHERE " + strings.Join(whereClauses, " AND ")

     

       368
       368
        
       	}

     

       369
       369
        
       

     

       370
       370
       -
       	// Get total count

     

       371
       371
       -
       	countQuery := fmt.Sprintf("SELECT COUNT(*) FROM communities %s", whereClause)

     

       372
       372
       -
       	var totalCount int

     

       373
       373
       -
       	err := r.db.QueryRowContext(ctx, countQuery, args...).Scan(&totalCount)

     

       374
       374
       -
       	if err != nil {

     

       375
       375
       -
       		return nil, 0, fmt.Errorf("failed to count communities: %w", err)

     

       376
       376
       -
       	}

     

       370
       370
       +
       	// Build sort clause - map sort enum to DB columns

     

       371
       371
       +
       	sortColumn := "subscriber_count" // default: popular

     

       372
       372
       +
       	sortOrder := "DESC"

     

       377
       373
        
       

     

       378
       378
       -
       	// Build sort clause

     

       379
       379
       -
       	sortColumn := "created_at"

     

       380
       380
       -
       	if req.SortBy != "" {

     

       381
       381
       -
       		switch req.SortBy {

     

       382
       382
       -
       		case "member_count", "subscriber_count", "post_count", "created_at":

     

       383
       383
       -
       			sortColumn = req.SortBy

     

       384
       384
       -
       		}

     

       385
       385
       -
       	}

     

       386
       386
       -
       

     

       387
       387
       -
       	sortOrder := "DESC"

     

       388
       388
       -
       	if strings.ToUpper(req.SortOrder) == "ASC" {

     

       374
       374
       +
       	switch req.Sort {

     

       375
       375
       +
       	case "popular":

     

       376
       376
       +
       		// Most subscribers (default)

     

       377
       377
       +
       		sortColumn = "subscriber_count"

     

       378
       378
       +
       		sortOrder = "DESC"

     

       379
       379
       +
       	case "active":

     

       380
       380
       +
       		// Most posts/activity

     

       381
       381
       +
       		sortColumn = "post_count"

     

       382
       382
       +
       		sortOrder = "DESC"

     

       383
       383
       +
       	case "new":

     

       384
       384
       +
       		// Recently created

     

       385
       385
       +
       		sortColumn = "created_at"

     

       386
       386
       +
       		sortOrder = "DESC"

     

       387
       387
       +
       	case "alphabetical":

     

       388
       388
       +
       		// Sorted by name A-Z

     

       389
       389
       +
       		sortColumn = "name"

     

       389
       390
        
       		sortOrder = "ASC"

     

       391
       391
       +
       	default:

     

       392
       392
       +
       		// Fallback to popular if empty or invalid (should be validated in handler)

     

       393
       393
       +
       		sortColumn = "subscriber_count"

     

       394
       394
       +
       		sortOrder = "DESC"

     

       390
       395
        
       	}

     

       391
       396
        
       

     

       392
       397
        
       	// Get communities with pagination

     
···

       407
       412
        
       

     

       408
       413
        
       	rows, err := r.db.QueryContext(ctx, query, args...)

     

       409
       414
        
       	if err != nil {

     

       410
       410
       -
       		return nil, 0, fmt.Errorf("failed to list communities: %w", err)

     

       415
       415
       +
       		return nil, fmt.Errorf("failed to list communities: %w", err)

     

       411
       416
        
       	}

     

       412
       417
        
       	defer func() {

     

       413
       418
        
       		if closeErr := rows.Close(); closeErr != nil {

     
···

       436
       441
        
       			&recordURI, &recordCID,

     

       437
       442
        
       		)

     

       438
       443
        
       		if scanErr != nil {

     

       439
       439
       -
       			return nil, 0, fmt.Errorf("failed to scan community: %w", scanErr)

     

       444
       444
       +
       			return nil, fmt.Errorf("failed to scan community: %w", scanErr)

     

       440
       445
        
       		}

     

       441
       446
        
       

     

       442
       447
        
       		// Map nullable fields

     
···

       458
       463
        
       	}

     

       459
       464
        
       

     

       460
       465
        
       	if err = rows.Err(); err != nil {

     

       461
       461
       -
       		return nil, 0, fmt.Errorf("error iterating communities: %w", err)

     

       466
       466
       +
       		return nil, fmt.Errorf("error iterating communities: %w", err)

     

       462
       467
        
       	}

     

       463
       468
        
       

     

       464
       464
       -
       	return result, totalCount, nil

     

       469
       469
       +
       	return result, nil

     

       465
       470
        
       }

     

       466
       471
        
       

     

       467
       472
        
       // Search searches communities by name/description using fuzzy matching