commit cc003261f010f917fa3b690fc552e9438d57c768 · bretton.dev/coves

+31 -39
internal/api/handlers/community/block.go
···

       23
       23
        
       }

     

       24
       24
        
       

     

       25
       25
        
       // HandleBlock blocks a community

     

       26
       26
       -
       // POST /xrpc/social.coves.community.block

     

       27
       27
       -
       // Body: { "community": "did:plc:xxx" or "!gaming@coves.social" }

     

       26
       26
       +
       // POST /xrpc/social.coves.community.blockCommunity

     

       27
       27
       +
       //

     

       28
       28
       +
       // Request body: { "community": "did:plc:xxx" }

     

       29
       29
       +
       // Note: Per lexicon spec, only DIDs are accepted (not handles).

     

       30
       30
       +
       // The block record's "subject" field requires format: "did".

     

       28
       31
        
       func (h *BlockHandler) HandleBlock(w http.ResponseWriter, r *http.Request) {

     

       29
       32
        
       	if r.Method != http.MethodPost {

     

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

     
···

       33
       36
        
       

     

       34
       37
        
       	// Parse request body

     

       35
       38
        
       	var req struct {

     

       36
       36
       -
       		Community string `json:"community"` // DID or handle

     

       39
       39
       +
       		Community string `json:"community"` // DID only (per lexicon)

     

       37
       40
        
       	}

     

       38
       41
        
       

     

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

     
···

       46
       49
        
       		return

     

       47
       50
        
       	}

     

       48
       51
        
       

     

       49
       49
       -
       	// Validate format (DID or handle) with proper regex patterns

     

       50
       50
       -
       	if strings.HasPrefix(req.Community, "did:") {

     

       51
       51
       -
       		// Validate DID format: did:method:identifier

     

       52
       52
       -
       		// atProto supports did:plc and did:web

     

       53
       53
       -
       		didRegex := regexp.MustCompile(`^did:(plc|web):[a-zA-Z0-9._:%-]+$`)

     

       54
       54
       -
       		if !didRegex.MatchString(req.Community) {

     

       55
       55
       -
       			writeError(w, http.StatusBadRequest, "InvalidRequest", "invalid DID format")

     

       56
       56
       -
       			return

     

       57
       57
       -
       		}

     

       58
       58
       -
       	} else if strings.HasPrefix(req.Community, "!") {

     

       59
       59
       -
       		// Validate handle format: !name@domain.tld

     

       60
       60
       -
       		if !strings.Contains(req.Community, "@") {

     

       61
       61
       -
       			writeError(w, http.StatusBadRequest, "InvalidRequest", "handle must contain @domain")

     

       62
       62
       -
       			return

     

       63
       63
       -
       		}

     

       64
       64
       -
       	} else {

     

       52
       52
       +
       	// Validate DID format (per lexicon: format must be "did")

     

       53
       53
       +
       	if !strings.HasPrefix(req.Community, "did:") {

     

       65
       54
        
       		writeError(w, http.StatusBadRequest, "InvalidRequest",

     

       66
       66
       -
       			"community must be a DID (did:plc:...) or handle (!name@instance.com)")

     

       55
       55
       +
       			"community must be a DID (did:plc:... or did:web:...)")

     

       56
       56
       +
       		return

     

       57
       57
       +
       	}

     

       58
       58
       +
       

     

       59
       59
       +
       	// Validate DID format with regex: did:method:identifier

     

       60
       60
       +
       	didRegex := regexp.MustCompile(`^did:(plc|web):[a-zA-Z0-9._:%-]+$`)

     

       61
       61
       +
       	if !didRegex.MatchString(req.Community) {

     

       62
       62
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "invalid DID format")

     

       67
       63
        
       		return

     

       68
       64
        
       	}

     

       69
       65
        
       

     
···

       103
       99
        
       }

     

       104
       100
        
       

     

       105
       101
        
       // HandleUnblock unblocks a community

     

       106
       106
       -
       // POST /xrpc/social.coves.community.unblock

     

       107
       107
       -
       // Body: { "community": "did:plc:xxx" or "!gaming@coves.social" }

     

       102
       102
       +
       // POST /xrpc/social.coves.community.unblockCommunity

     

       103
       103
       +
       //

     

       104
       104
       +
       // Request body: { "community": "did:plc:xxx" }

     

       105
       105
       +
       // Note: Per lexicon spec, only DIDs are accepted (not handles).

     

       108
       106
        
       func (h *BlockHandler) HandleUnblock(w http.ResponseWriter, r *http.Request) {

     

       109
       107
        
       	if r.Method != http.MethodPost {

     

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

     
···

       113
       111
        
       

     

       114
       112
        
       	// Parse request body

     

       115
       113
        
       	var req struct {

     

       116
       116
       -
       		Community string `json:"community"`

     

       114
       114
       +
       		Community string `json:"community"` // DID only (per lexicon)

     

       117
       115
        
       	}

     

       118
       116
        
       

     

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

     
···

       126
       124
        
       		return

     

       127
       125
        
       	}

     

       128
       126
        
       

     

       129
       129
       -
       	// Validate format (DID or handle) with proper regex patterns

     

       130
       130
       -
       	if strings.HasPrefix(req.Community, "did:") {

     

       131
       131
       -
       		// Validate DID format: did:method:identifier

     

       132
       132
       -
       		didRegex := regexp.MustCompile(`^did:(plc|web):[a-zA-Z0-9._:%-]+$`)

     

       133
       133
       -
       		if !didRegex.MatchString(req.Community) {

     

       134
       134
       -
       			writeError(w, http.StatusBadRequest, "InvalidRequest", "invalid DID format")

     

       135
       135
       -
       			return

     

       136
       136
       -
       		}

     

       137
       137
       -
       	} else if strings.HasPrefix(req.Community, "!") {

     

       138
       138
       -
       		// Validate handle format: !name@domain.tld

     

       139
       139
       -
       		if !strings.Contains(req.Community, "@") {

     

       140
       140
       -
       			writeError(w, http.StatusBadRequest, "InvalidRequest", "handle must contain @domain")

     

       141
       141
       -
       			return

     

       142
       142
       -
       		}

     

       143
       143
       -
       	} else {

     

       127
       127
       +
       	// Validate DID format (per lexicon: format must be "did")

     

       128
       128
       +
       	if !strings.HasPrefix(req.Community, "did:") {

     

       144
       129
        
       		writeError(w, http.StatusBadRequest, "InvalidRequest",

     

       145
       145
       -
       			"community must be a DID (did:plc:...) or handle (!name@instance.com)")

     

       130
       130
       +
       			"community must be a DID (did:plc:... or did:web:...)")

     

       131
       131
       +
       		return

     

       132
       132
       +
       	}

     

       133
       133
       +
       

     

       134
       134
       +
       	// Validate DID format with regex: did:method:identifier

     

       135
       135
       +
       	didRegex := regexp.MustCompile(`^did:(plc|web):[a-zA-Z0-9._:%-]+$`)

     

       136
       136
       +
       	if !didRegex.MatchString(req.Community) {

     

       137
       137
       +
       		writeError(w, http.StatusBadRequest, "InvalidRequest", "invalid DID format")

     

       146
       138
        
       		return

     

       147
       139
        
       	}

     

       148
       140