commit 9f6c088908763d7218eb45431e3bd98736807018 · bretton.dev/coves

+15 -5

internal/core/comments/comment_service.go

···

       6
       6
        
       	"errors"

     

       7
       7
        
       	"fmt"

     

       8
       8
        
       	"log"

     

       9
       9
       +
       	"net/url"

     

       9
       10
        
       	"strings"

     

       10
       11
        
       	"time"

     

       11
       12
        
       

     
···

       475
       476
        
       		// Avatar is stored as blob in community's repository

     

       476
       477
        
       		// Format: https://{pds}/xrpc/com.atproto.sync.getBlob?did={community_did}&cid={avatar_cid}

     

       477
       478
        
       		if community.AvatarCID != "" && community.PDSURL != "" {

     

       478
       478
       -
       			avatarURLString := fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob?did=%s&cid=%s",

     

       479
       479
       -
       				strings.TrimSuffix(community.PDSURL, "/"),

     

       480
       480
       -
       				community.DID,

     

       481
       481
       -
       				community.AvatarCID)

     

       482
       482
       -
       			avatarURL = &avatarURLString

     

       479
       479
       +
       			// Validate HTTPS for security (prevent mixed content warnings, MitM attacks)

     

       480
       480
       +
       			if !strings.HasPrefix(community.PDSURL, "https://") {

     

       481
       481
       +
       				log.Printf("Warning: Skipping non-HTTPS PDS URL for community %s", community.DID)

     

       482
       482
       +
       			} else if !strings.HasPrefix(community.AvatarCID, "baf") {

     

       483
       483
       +
       				// Validate CID format (IPFS CIDs start with "baf" for CIDv1 base32)

     

       484
       484
       +
       				log.Printf("Warning: Invalid CID format for community %s", community.DID)

     

       485
       485
       +
       			} else {

     

       486
       486
       +
       				// Use proper URL escaping to prevent injection attacks

     

       487
       487
       +
       				avatarURLString := fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob?did=%s&cid=%s",

     

       488
       488
       +
       					strings.TrimSuffix(community.PDSURL, "/"),

     

       489
       489
       +
       					url.QueryEscape(community.DID),

     

       490
       490
       +
       					url.QueryEscape(community.AvatarCID))

     

       491
       491
       +
       				avatarURL = &avatarURLString

     

       492
       492
       +
       			}

     

       483
       493
        
       		}

     

       484
       494
        
       	} else {

     

       485
       495
        
       		// Log warning but don't fail the entire request

+20

internal/core/users/interfaces.go

···

       8
       8
        
       	GetByDID(ctx context.Context, did string) (*User, error)

     

       9
       9
        
       	GetByHandle(ctx context.Context, handle string) (*User, error)

     

       10
       10
        
       	UpdateHandle(ctx context.Context, did, newHandle string) (*User, error)

     

       11
       11
       +
       

     

       12
       12
       +
       	// GetByDIDs retrieves multiple users by their DIDs in a single batch query.

     

       13
       13
       +
       	// Returns a map of DID → User for efficient lookups.

     

       14
       14
       +
       	// Missing users are not included in the result map (no error for missing users).

     

       15
       15
       +
       	// Returns error only on database failures or validation errors (invalid DIDs, batch too large).

     

       16
       16
       +
       	//

     

       17
       17
       +
       	// Parameters:

     

       18
       18
       +
       	//   - ctx: Context for cancellation and timeout

     

       19
       19
       +
       	//   - dids: Array of DIDs to retrieve (must start with "did:", max 1000 items)

     

       20
       20
       +
       	//

     

       21
       21
       +
       	// Returns:

     

       22
       22
       +
       	//   - map[string]*User: Map of DID → User for found users

     

       23
       23
       +
       	//   - error: Validation or database errors (not errors for missing users)

     

       24
       24
       +
       	//

     

       25
       25
       +
       	// Example:

     

       26
       26
       +
       	//   userMap, err := repo.GetByDIDs(ctx, []string{"did:plc:abc", "did:plc:xyz"})

     

       27
       27
       +
       	//   if err != nil { return err }

     

       28
       28
       +
       	//   if user, found := userMap["did:plc:abc"]; found {

     

       29
       29
       +
       	//       // Use user

     

       30
       30
       +
       	//   }

     

       11
       31
        
       	GetByDIDs(ctx context.Context, dids []string) (map[string]*User, error)

     

       12
       32
        
       }

     

       13
       33

+15

internal/db/postgres/user_repo.go

···

       106
       106
        
       	return user, nil

     

       107
       107
        
       }

     

       108
       108
        
       

     

       109
       109
       +
       const MaxBatchSize = 1000

     

       110
       110
       +
       

     

       109
       111
        
       // GetByDIDs retrieves multiple users by their DIDs in a single query

     

       110
       112
        
       // Returns a map of DID -> User for efficient lookups

     

       111
       113
        
       // Missing users are not included in the result map (no error for missing users)

     

       112
       114
        
       func (r *postgresUserRepo) GetByDIDs(ctx context.Context, dids []string) (map[string]*users.User, error) {

     

       113
       115
        
       	if len(dids) == 0 {

     

       114
       116
        
       		return make(map[string]*users.User), nil

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

       119
       119
       +
       	// Validate batch size to prevent excessive memory usage and query timeouts

     

       120
       120
       +
       	if len(dids) > MaxBatchSize {

     

       121
       121
       +
       		return nil, fmt.Errorf("batch size %d exceeds maximum %d", len(dids), MaxBatchSize)

     

       122
       122
       +
       	}

     

       123
       123
       +
       

     

       124
       124
       +
       	// Validate DID format to prevent SQL injection and malformed queries

     

       125
       125
       +
       	// All atProto DIDs must start with "did:" prefix

     

       126
       126
       +
       	for _, did := range dids {

     

       127
       127
       +
       		if !strings.HasPrefix(did, "did:") {

     

       128
       128
       +
       			return nil, fmt.Errorf("invalid DID format: %s", did)

     

       129
       129
       +
       		}

     

       115
       130
        
       	}

     

       116
       131
        
       

     

       117
       132
        
       	// Build parameterized query with IN clause