commit ff7cb2ef115baf086b2e7a97defd65a37a867288 · bretton.dev/coves

+99 -1
internal/atproto/jetstream/community_consumer.go
···

       1
       1
        
       package jetstream

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/atproto/utils"

     

       4
       5
        
       	"Coves/internal/core/communities"

     

       5
       6
        
       	"context"

     

       6
       7
        
       	"encoding/json"

     
···

       35
       36
        
       	// IMPORTANT: Collection names refer to RECORD TYPES in repositories, not XRPC procedures

     

       36
       37
        
       	// - social.coves.community.profile: Community profile records (in community's own repo)

     

       37
       38
        
       	// - social.coves.community.subscription: Subscription records (in user's repo)

     

       39
       39
       +
       	// - social.coves.community.block: Block records (in user's repo)

     

       38
       40
        
       	//

     

       39
       41
        
       	// XRPC procedures (social.coves.community.subscribe/unsubscribe) are just HTTP endpoints

     

       40
       42
        
       	// that CREATE or DELETE records in these collections

     
···

       44
       46
        
       	case "social.coves.community.subscription":

     

       45
       47
        
       		// Handle both create (subscribe) and delete (unsubscribe) operations

     

       46
       48
        
       		return c.handleSubscription(ctx, event.Did, commit)

     

       49
       49
       +
       	case "social.coves.community.block":

     

       50
       50
       +
       		// Handle both create (block) and delete (unblock) operations

     

       51
       51
       +
       		return c.handleBlock(ctx, event.Did, commit)

     

       47
       52
        
       	default:

     

       48
       53
        
       		// Not a community-related collection

     

       49
       54
        
       		return nil

     
···

       267
       272
        
       	uri := fmt.Sprintf("at://%s/social.coves.community.subscription/%s", userDID, commit.RKey)

     

       268
       273
        
       

     

       269
       274
        
       	// Create subscription entity

     

       275
       275
       +
       	// Parse createdAt from record to preserve chronological ordering during replays

     

       270
       276
        
       	subscription := &communities.Subscription{

     

       271
       277
        
       		UserDID:           userDID,

     

       272
       278
        
       		CommunityDID:      communityDID,

     

       273
       279
        
       		ContentVisibility: contentVisibility,

     

       274
       274
       -
       		SubscribedAt:      time.Now(),

     

       280
       280
       +
       		SubscribedAt:      utils.ParseCreatedAt(commit.Record),

     

       275
       281
        
       		RecordURI:         uri,

     

       276
       282
        
       		RecordCID:         commit.CID,

     

       277
       283
        
       	}

     
···

       325
       331
        
       	}

     

       326
       332
        
       

     

       327
       333
        
       	log.Printf("✓ Removed subscription: %s -> %s", userDID, subscription.CommunityDID)

     

       334
       334
       +
       	return nil

     

       335
       335
       +
       }

     

       336
       336
       +
       

     

       337
       337
       +
       // handleBlock processes block create/delete events

     

       338
       338
       +
       // CREATE operation = user blocked a community

     

       339
       339
       +
       // DELETE operation = user unblocked a community

     

       340
       340
       +
       func (c *CommunityEventConsumer) handleBlock(ctx context.Context, userDID string, commit *CommitEvent) error {

     

       341
       341
       +
       	switch commit.Operation {

     

       342
       342
       +
       	case "create":

     

       343
       343
       +
       		return c.createBlock(ctx, userDID, commit)

     

       344
       344
       +
       	case "delete":

     

       345
       345
       +
       		return c.deleteBlock(ctx, userDID, commit)

     

       346
       346
       +
       	default:

     

       347
       347
       +
       		// Update operations shouldn't happen on blocks, but ignore gracefully

     

       348
       348
       +
       		log.Printf("Ignoring unexpected operation on block: %s (userDID=%s, rkey=%s)",

     

       349
       349
       +
       			commit.Operation, userDID, commit.RKey)

     

       350
       350
       +
       		return nil

     

       351
       351
       +
       	}

     

       352
       352
       +
       }

     

       353
       353
       +
       

     

       354
       354
       +
       // createBlock indexes a new block

     

       355
       355
       +
       func (c *CommunityEventConsumer) createBlock(ctx context.Context, userDID string, commit *CommitEvent) error {

     

       356
       356
       +
       	if commit.Record == nil {

     

       357
       357
       +
       		return fmt.Errorf("block create event missing record data")

     

       358
       358
       +
       	}

     

       359
       359
       +
       

     

       360
       360
       +
       	// Extract community DID from record's subject field (following atProto conventions)

     

       361
       361
       +
       	communityDID, ok := commit.Record["subject"].(string)

     

       362
       362
       +
       	if !ok {

     

       363
       363
       +
       		return fmt.Errorf("block record missing subject field")

     

       364
       364
       +
       	}

     

       365
       365
       +
       

     

       366
       366
       +
       	// Build AT-URI for block record

     

       367
       367
       +
       	// The record lives in the USER's repository

     

       368
       368
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.block/%s", userDID, commit.RKey)

     

       369
       369
       +
       

     

       370
       370
       +
       	// Create block entity

     

       371
       371
       +
       	// Parse createdAt from record to preserve chronological ordering during replays

     

       372
       372
       +
       	block := &communities.CommunityBlock{

     

       373
       373
       +
       		UserDID:      userDID,

     

       374
       374
       +
       		CommunityDID: communityDID,

     

       375
       375
       +
       		BlockedAt:    utils.ParseCreatedAt(commit.Record),

     

       376
       376
       +
       		RecordURI:    uri,

     

       377
       377
       +
       		RecordCID:    commit.CID,

     

       378
       378
       +
       	}

     

       379
       379
       +
       

     

       380
       380
       +
       	// Index the block

     

       381
       381
       +
       	// This is idempotent - safe for Jetstream replays

     

       382
       382
       +
       	_, err := c.repo.BlockCommunity(ctx, block)

     

       383
       383
       +
       	if err != nil {

     

       384
       384
       +
       		// If already exists, that's fine (idempotency)

     

       385
       385
       +
       		if communities.IsConflict(err) {

     

       386
       386
       +
       			log.Printf("Block already indexed: %s -> %s", userDID, communityDID)

     

       387
       387
       +
       			return nil

     

       388
       388
       +
       		}

     

       389
       389
       +
       		return fmt.Errorf("failed to index block: %w", err)

     

       390
       390
       +
       	}

     

       391
       391
       +
       

     

       392
       392
       +
       	log.Printf("✓ Indexed block: %s -> %s", userDID, communityDID)

     

       393
       393
       +
       	return nil

     

       394
       394
       +
       }

     

       395
       395
       +
       

     

       396
       396
       +
       // deleteBlock removes a block from the index

     

       397
       397
       +
       // DELETE operations don't include record data, so we need to look up the block

     

       398
       398
       +
       // by its URI to find which community the user unblocked

     

       399
       399
       +
       func (c *CommunityEventConsumer) deleteBlock(ctx context.Context, userDID string, commit *CommitEvent) error {

     

       400
       400
       +
       	// Build AT-URI from the rkey

     

       401
       401
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.block/%s", userDID, commit.RKey)

     

       402
       402
       +
       

     

       403
       403
       +
       	// Look up the block to get the community DID

     

       404
       404
       +
       	// (DELETE operations don't include record data in Jetstream)

     

       405
       405
       +
       	block, err := c.repo.GetBlockByURI(ctx, uri)

     

       406
       406
       +
       	if err != nil {

     

       407
       407
       +
       		if communities.IsNotFound(err) {

     

       408
       408
       +
       			// Already deleted - this is fine (idempotency)

     

       409
       409
       +
       			log.Printf("Block already deleted: %s", uri)

     

       410
       410
       +
       			return nil

     

       411
       411
       +
       		}

     

       412
       412
       +
       		return fmt.Errorf("failed to find block for deletion: %w", err)

     

       413
       413
       +
       	}

     

       414
       414
       +
       

     

       415
       415
       +
       	// Remove the block from the index

     

       416
       416
       +
       	err = c.repo.UnblockCommunity(ctx, userDID, block.CommunityDID)

     

       417
       417
       +
       	if err != nil {

     

       418
       418
       +
       		if communities.IsNotFound(err) {

     

       419
       419
       +
       			log.Printf("Block already removed: %s -> %s", userDID, block.CommunityDID)

     

       420
       420
       +
       			return nil

     

       421
       421
       +
       		}

     

       422
       422
       +
       		return fmt.Errorf("failed to remove block: %w", err)

     

       423
       423
       +
       	}

     

       424
       424
       +
       

     

       425
       425
       +
       	log.Printf("✓ Removed block: %s -> %s", userDID, block.CommunityDID)

     

       328
       426
        
       	return nil

     

       329
       427
        
       }

     

       330
       428