commit d5e51e2705312dc7694528031ac91669a4ed24d7 · bretton.dev/coves

+2 -2

cmd/server/main.go

···

       404
       404
        
       	commentJetstreamURL := os.Getenv("COMMENT_JETSTREAM_URL")

     

       405
       405
        
       	if commentJetstreamURL == "" {

     

       406
       406
        
       		// Listen to comment record CREATE/UPDATE/DELETE events from user repositories

     

       407
       407
       -
       		commentJetstreamURL = "ws://localhost:6008/subscribe?wantedCollections=social.coves.feed.comment"

     

       407
       407
       +
       		commentJetstreamURL = "ws://localhost:6008/subscribe?wantedCollections=social.coves.community.comment"

     

       408
       408
        
       	}

     

       409
       409
        
       

     

       410
       410
        
       	commentEventConsumer := jetstream.NewCommentEventConsumer(commentRepo, db)

     
···

       417
       417
        
       	}()

     

       418
       418
        
       

     

       419
       419
        
       	log.Printf("Started Jetstream comment consumer: %s", commentJetstreamURL)

     

       420
       420
       -
       	log.Println("  - Indexing: social.coves.feed.comment CREATE/UPDATE/DELETE operations")

     

       420
       420
       +
       	log.Println("  - Indexing: social.coves.community.comment CREATE/UPDATE/DELETE operations")

     

       421
       421
        
       	log.Println("  - Updating: Post comment counts and comment reply counts atomically")

     

       422
       422
        
       

     

       423
       423
        
       	// Register XRPC routes

+18 -15

docs/COMMENT_SYSTEM_IMPLEMENTATION.md

···

       308
       308
        
       ```json

     

       309
       309
        
       {

     

       310
       310
        
         "lexicon": 1,

     

       311
       311
       -
         "id": "social.coves.feed.comment",

     

       311
       311
       +
         "id": "social.coves.community.comment",

     

       312
       312
        
         "defs": {

     

       313
       313
        
           "main": {

     

       314
       314
        
             "type": "record",

     
···

       365
       365
        
       ```sql

     

       366
       366
        
       CREATE TABLE comments (

     

       367
       367
        
           id BIGSERIAL PRIMARY KEY,

     

       368
       368
       -
           uri TEXT UNIQUE NOT NULL,               -- AT-URI (at://commenter_did/social.coves.feed.comment/rkey)

     

       368
       368
       +
           uri TEXT UNIQUE NOT NULL,               -- AT-URI (at://commenter_did/social.coves.community.comment/rkey)

     

       369
       369
        
           cid TEXT NOT NULL,                      -- Content ID

     

       370
       370
        
           rkey TEXT NOT NULL,                     -- Record key (TID)

     

       371
       371
        
           commenter_did TEXT NOT NULL,            -- User who commented (from AT-URI repo field)

     
···

       559
       559
        
               return nil

     

       560
       560
        
           }

     

       561
       561
        
       

     

       562
       562
       -
           if event.Commit.Collection == "social.coves.feed.comment" {

     

       562
       562
       +
           if event.Commit.Collection == "social.coves.community.comment" {

     

       563
       563
        
               switch event.Commit.Operation {

     

       564
       564
        
               case "create":

     

       565
       565
        
                   return c.createComment(ctx, event.Did, commit)

     
···

       653
       653
        
       - Auto-reconnect on errors (5-second retry)

     

       654
       654
        
       - Ping/pong keepalive (30-second ping, 60-second read deadline)

     

       655
       655
        
       - Graceful shutdown via context cancellation

     

       656
       656
       -
       - Subscribes to: `wantedCollections=social.coves.feed.comment`

     

       656
       656
       +
       - Subscribes to: `wantedCollections=social.coves.community.comment`

     

       657
       657
        
       

     

       658
       658
        
       ---

     

       659
       659
        
       

     
···

       669
       669
        
       // Start Jetstream consumer for comments

     

       670
       670
        
       commentJetstreamURL := os.Getenv("COMMENT_JETSTREAM_URL")

     

       671
       671
        
       if commentJetstreamURL == "" {

     

       672
       672
       -
           commentJetstreamURL = "ws://localhost:6008/subscribe?wantedCollections=social.coves.feed.comment"

     

       672
       672
       +
           commentJetstreamURL = "ws://localhost:6008/subscribe?wantedCollections=social.coves.community.comment"

     

       673
       673
        
       }

     

       674
       674
        
       

     

       675
       675
        
       commentEventConsumer := jetstream.NewCommentEventConsumer(commentRepo, db)

     
···

       682
       682
        
       }()

     

       683
       683
        
       

     

       684
       684
        
       log.Printf("Started Jetstream comment consumer: %s", commentJetstreamURL)

     

       685
       685
       -
       log.Println("  - Indexing: social.coves.feed.comment CREATE/UPDATE/DELETE operations")

     

       685
       685
       +
       log.Println("  - Indexing: social.coves.community.comment CREATE/UPDATE/DELETE operations")

     

       686
       686
        
       log.Println("  - Updating: Post comment counts and comment reply counts atomically")

     

       687
       687
        
       ```

     

       688
       688
        
       

     
···

       835
       835
        
       | Aspect | Votes | Comments |

     

       836
       836
        
       |--------|-------|----------|

     

       837
       837
        
       | **Location** | User repositories | User repositories |

     

       838
       838
       -
       | **Lexicon** | `social.coves.feed.vote` | `social.coves.feed.comment` |

     

       838
       838
       +
       | **Lexicon** | `social.coves.feed.vote` | `social.coves.community.comment` |

     

       839
       839
        
       | **Operations** | CREATE, DELETE | CREATE, UPDATE, DELETE |

     

       840
       840
        
       | **Mutability** | Immutable | Editable |

     

       841
       841
        
       | **Foreign Keys** | None (out-of-order indexing) | None (out-of-order indexing) |

     
···

       1197
       1197
        
       

     

       1198
       1198
        
       ---

     

       1199
       1199
        
       

     

       1200
       1200
       -
       ### 📋 Phase 4: Namespace Migration (Separate Task)

     

       1200
       1200
       +
       ### ✅ Phase 4: Namespace Migration (COMPLETED)

     

       1201
       1201
       +
       

     

       1202
       1202
       +
       **Completed:** 2025-11-16

     

       1201
       1203
        
       

     

       1202
       1204
        
       **Scope:**

     

       1203
       1203
       -
       - Migrate existing `social.coves.feed.comment` records to `social.coves.community.comment`

     

       1204
       1204
       -
       - Update all AT-URIs in database

     

       1205
       1205
       -
       - Update Jetstream consumer collection filter

     

       1206
       1206
       -
       - Migration script with rollback capability

     

       1207
       1207
       -
       - Zero-downtime deployment strategy

     

       1205
       1205
       +
       - ✅ Migrated `social.coves.community.comment` namespace to `social.coves.community.comment`

     

       1206
       1206
       +
       - ✅ Updated lexicon definitions (record and query schemas)

     

       1207
       1207
       +
       - ✅ Updated Jetstream consumer collection filter

     

       1208
       1208
       +
       - ✅ Updated all code references (consumer, service, validation layers)

     

       1209
       1209
       +
       - ✅ Updated integration tests and test data generation scripts

     

       1210
       1210
       +
       - ✅ Created database migration (018_migrate_comment_namespace.sql)

     

       1208
       1211
        
       

     

       1209
       1209
       -
       **Note:** Currently out of scope - will be tackled separately when needed.

     

       1212
       1212
       +
       **Note:** Since we're pre-production, no historical data migration was needed. Migration script updates URIs in comments table (uri, root_uri, parent_uri columns).

     

       1210
       1213
        
       

     

       1211
       1214
        
       ---

     

       1212
       1215
        
       

     
···

       1456
       1459
        
       ### Environment Variables

     

       1457
       1460
        
       ```bash

     

       1458
       1461
        
       # Jetstream URL (optional, defaults to localhost:6008)

     

       1459
       1459
       -
       export COMMENT_JETSTREAM_URL="ws://localhost:6008/subscribe?wantedCollections=social.coves.feed.comment"

     

       1462
       1462
       +
       export COMMENT_JETSTREAM_URL="ws://localhost:6008/subscribe?wantedCollections=social.coves.community.comment"

     

       1460
       1463
        
       

     

       1461
       1464
        
       # Database URL

     

       1462
       1465
        
       export TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"

+9 -9

internal/atproto/jetstream/comment_consumer.go

···

       17
       17
        
       // Constants for comment validation and processing

     

       18
       18
        
       const (

     

       19
       19
        
       	// CommentCollection is the lexicon collection identifier for comments

     

       20
       20
       -
       	CommentCollection = "social.coves.feed.comment"

     

       20
       20
       +
       	CommentCollection = "social.coves.community.comment"

     

       21
       21
        
       

     

       22
       22
        
       	// ATProtoScheme is the URI scheme for atProto AT-URIs

     

       23
       23
        
       	ATProtoScheme = "at://"

     
···

       28
       28
        
       )

     

       29
       29
        
       

     

       30
       30
        
       // CommentEventConsumer consumes comment-related events from Jetstream

     

       31
       31
       -
       // Handles CREATE, UPDATE, and DELETE operations for social.coves.feed.comment

     

       31
       31
       +
       // Handles CREATE, UPDATE, and DELETE operations for social.coves.community.comment

     

       32
       32
        
       type CommentEventConsumer struct {

     

       33
       33
        
       	commentRepo comments.Repository

     

       34
       34
        
       	db          *sql.DB // Direct DB access for atomic count updates

     
···

       89
       89
        
       	}

     

       90
       90
        
       

     

       91
       91
        
       	// Build AT-URI for this comment

     

       92
       92
       -
       	// Format: at://commenter_did/social.coves.feed.comment/rkey

     

       93
       93
       -
       	uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", repoDID, commit.RKey)

     

       92
       92
       +
       	// Format: at://commenter_did/social.coves.community.comment/rkey

     

       93
       93
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", repoDID, commit.RKey)

     

       94
       94
        
       

     

       95
       95
        
       	// Parse timestamp from record

     

       96
       96
        
       	createdAt, err := time.Parse(time.RFC3339, commentRecord.CreatedAt)

     
···

       149
       149
        
       	}

     

       150
       150
        
       

     

       151
       151
        
       	// Build AT-URI for the comment being updated

     

       152
       152
       -
       	uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", repoDID, commit.RKey)

     

       152
       152
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", repoDID, commit.RKey)

     

       153
       153
        
       

     

       154
       154
        
       	// Fetch existing comment to validate threading references are immutable

     

       155
       155
        
       	existingComment, err := c.commentRepo.GetByURI(ctx, uri)

     
···

       202
       202
        
       // deleteComment soft-deletes a comment and updates parent counts

     

       203
       203
        
       func (c *CommentEventConsumer) deleteComment(ctx context.Context, repoDID string, commit *CommitEvent) error {

     

       204
       204
        
       	// Build AT-URI for the comment being deleted

     

       205
       205
       -
       	uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", repoDID, commit.RKey)

     

       205
       205
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", repoDID, commit.RKey)

     

       206
       206
        
       

     

       207
       207
        
       	// Get existing comment to know its parent (for decrementing the right counter)

     

       208
       208
        
       	existingComment, err := c.commentRepo.GetByURI(ctx, uri)

     
···

       382
       382
        
       			WHERE uri = $1 AND deleted_at IS NULL

     

       383
       383
        
       		`

     

       384
       384
        
       

     

       385
       385
       -
       	case "social.coves.feed.comment":

     

       385
       385
       +
       	case "social.coves.community.comment":

     

       386
       386
        
       		// Reply to comment - update comments.reply_count

     

       387
       387
        
       		updateQuery = `

     

       388
       388
        
       			UPDATE comments

     
···

       475
       475
        
       			WHERE uri = $1 AND deleted_at IS NULL

     

       476
       476
        
       		`

     

       477
       477
        
       

     

       478
       478
       -
       	case "social.coves.feed.comment":

     

       478
       478
       +
       	case "social.coves.community.comment":

     

       479
       479
        
       		// Reply to comment - decrement comments.reply_count

     

       480
       480
        
       		updateQuery = `

     

       481
       481
        
       			UPDATE comments

     
···

       600
       600
        
       }

     

       601
       601
        
       

     

       602
       602
        
       // CommentRecordFromJetstream represents a comment record as received from Jetstream

     

       603
       603
       -
       // Matches social.coves.feed.comment lexicon

     

       603
       603
       +
       // Matches social.coves.community.comment lexicon

     

       604
       604
        
       type CommentRecordFromJetstream struct {

     

       605
       605
        
       	Labels    interface{}            `json:"labels,omitempty"`

     

       606
       606
        
       	Embed     map[string]interface{} `json:"embed,omitempty"`

+2 -2

internal/atproto/jetstream/vote_consumer.go

···

       204
       204
        
       			`

     

       205
       205
        
       		}

     

       206
       206
        
       

     

       207
       207
       -
       	case "social.coves.feed.comment":

     

       207
       207
       +
       	case "social.coves.community.comment":

     

       208
       208
        
       		// Vote on comment - update comments table

     

       209
       209
        
       		if vote.Direction == "up" {

     

       210
       210
        
       			updateQuery = `

     
···

       317
       317
        
       			`

     

       318
       318
        
       		}

     

       319
       319
        
       

     

       320
       320
       -
       	case "social.coves.feed.comment":

     

       320
       320
       +
       	case "social.coves.community.comment":

     

       321
       321
        
       		// Vote on comment - update comments table

     

       322
       322
        
       		if vote.Direction == "up" {

     

       323
       323
        
       			updateQuery = `

+1 -1

internal/atproto/utils/record_utils.go

···

       20
       20
        
       // Format: at://did/collection/rkey -> collection

     

       21
       21
        
       //

     

       22
       22
        
       // Returns:

     

       23
       23
       -
       //   - Collection name (e.g., "social.coves.feed.comment") if URI is well-formed

     

       23
       23
       +
       //   - Collection name (e.g., "social.coves.community.comment") if URI is well-formed

     

       24
       24
        
       //   - Empty string if URI is malformed or doesn't contain a collection segment

     

       25
       25
        
       //

     

       26
       26
        
       // Note: Empty string indicates "unknown/unsupported collection" and should be

+1 -1

internal/core/comments/comment.go

···

       33
       33
        
       

     

       34
       34
        
       // CommentRecord represents the atProto record structure indexed from Jetstream

     

       35
       35
        
       // This is the data structure that gets stored in the user's repository

     

       36
       36
       -
       // Matches social.coves.feed.comment lexicon

     

       36
       36
       +
       // Matches social.coves.community.comment lexicon

     

       37
       37
        
       type CommentRecord struct {

     

       38
       38
        
       	Embed     map[string]interface{} `json:"embed,omitempty"`

     

       39
       39
        
       	Labels    *SelfLabels            `json:"labels,omitempty"`

+1 -1

internal/core/comments/comment_service.go

···

       381
       381
        
       // Deserializes JSONB fields (embed, facets, labels) for complete record (Phase 2C)

     

       382
       382
        
       func (s *commentService) buildCommentRecord(comment *Comment) *CommentRecord {

     

       383
       383
        
       	record := &CommentRecord{

     

       384
       384
       -
       		Type: "social.coves.feed.comment",

     

       384
       384
       +
       		Type: "social.coves.community.comment",

     

       385
       385
        
       		Reply: ReplyRef{

     

       386
       386
        
       			Root: StrongRef{

     

       387
       387
        
       				URI: comment.RootURI,

+2 -2

internal/core/comments/view_models.go

···

       5
       5
        
       )

     

       6
       6
        
       

     

       7
       7
        
       // CommentView represents the full view of a comment with all metadata

     

       8
       8
       -
       // Matches social.coves.feed.getComments#commentView lexicon

     

       8
       8
       +
       // Matches social.coves.community.comment.getComments#commentView lexicon

     

       9
       9
        
       // Used in thread views and get endpoints

     

       10
       10
        
       type CommentView struct {

     

       11
       11
        
       	Embed         interface{}         `json:"embed,omitempty"`

     
···

       24
       24
        
       }

     

       25
       25
        
       

     

       26
       26
        
       // ThreadViewComment represents a comment with its nested replies

     

       27
       27
       -
       // Matches social.coves.feed.getComments#threadViewComment lexicon

     

       27
       27
       +
       // Matches social.coves.community.comment.getComments#threadViewComment lexicon

     

       28
       28
        
       // Supports recursive threading for comment trees

     

       29
       29
        
       type ThreadViewComment struct {

     

       30
       30
        
       	Comment *CommentView         `json:"comment"`

+34

internal/db/migrations/018_migrate_comment_namespace.sql

···

       1
       1
       +
       -- +goose Up

     

       2
       2
       +
       -- Migration: Update comment URIs from social.coves.feed.comment to social.coves.community.comment

     

       3
       3
       +
       -- This updates the namespace for all comment records in the database.

     

       4
       4
       +
       -- Since we're pre-production, we're only updating the comments table (not votes).

     

       5
       5
       +
       

     

       6
       6
       +
       -- Update main comment URIs

     

       7
       7
       +
       UPDATE comments

     

       8
       8
       +
       SET uri = REPLACE(uri, '/social.coves.feed.comment/', '/social.coves.community.comment/')

     

       9
       9
       +
       WHERE uri LIKE '%/social.coves.feed.comment/%';

     

       10
       10
       +
       

     

       11
       11
       +
       -- Update root references (when root is a comment, not a post)

     

       12
       12
       +
       UPDATE comments

     

       13
       13
       +
       SET root_uri = REPLACE(root_uri, '/social.coves.feed.comment/', '/social.coves.community.comment/')

     

       14
       14
       +
       WHERE root_uri LIKE '%/social.coves.feed.comment/%';

     

       15
       15
       +
       

     

       16
       16
       +
       -- Update parent references (when parent is a comment)

     

       17
       17
       +
       UPDATE comments

     

       18
       18
       +
       SET parent_uri = REPLACE(parent_uri, '/social.coves.feed.comment/', '/social.coves.community.comment/')

     

       19
       19
       +
       WHERE parent_uri LIKE '%/social.coves.feed.comment/%';

     

       20
       20
       +
       

     

       21
       21
       +
       -- +goose Down

     

       22
       22
       +
       -- Rollback: Revert comment URIs from social.coves.community.comment to social.coves.feed.comment

     

       23
       23
       +
       

     

       24
       24
       +
       UPDATE comments

     

       25
       25
       +
       SET uri = REPLACE(uri, '/social.coves.community.comment/', '/social.coves.feed.comment/')

     

       26
       26
       +
       WHERE uri LIKE '%/social.coves.community.comment/%';

     

       27
       27
       +
       

     

       28
       28
       +
       UPDATE comments

     

       29
       29
       +
       SET root_uri = REPLACE(root_uri, '/social.coves.community.comment/', '/social.coves.feed.comment/')

     

       30
       30
       +
       WHERE root_uri LIKE '%/social.coves.community.comment/%';

     

       31
       31
       +
       

     

       32
       32
       +
       UPDATE comments

     

       33
       33
       +
       SET parent_uri = REPLACE(parent_uri, '/social.coves.community.comment/', '/social.coves.feed.comment/')

     

       34
       34
       +
       WHERE parent_uri LIKE '%/social.coves.community.comment/%';

+1 -1

internal/validation/lexicon.go

···

       86
       86
        
       

     

       87
       87
        
       // ValidateComment validates a comment record

     

       88
       88
        
       func (v *LexiconValidator) ValidateComment(comment map[string]interface{}) error {

     

       89
       89
       -
       	return v.ValidateRecord(comment, "social.coves.feed.comment")

     

       89
       89
       +
       	return v.ValidateRecord(comment, "social.coves.community.comment")

     

       90
       90
        
       }

     

       91
       91
        
       

     

       92
       92
        
       // ValidateVote validates a vote record

+1 -1

scripts/generate_deep_thread.go

···

       84
       84
        
       

     

       85
       85
        
       func createComment(db *sql.DB, user *User, content, parentURI, parentCID string, createdAt time.Time) (*Comment, error) {

     

       86
       86
        
       	rkey := generateTID()

     

       87
       87
       -
       	uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", user.DID, rkey)

     

       87
       87
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", user.DID, rkey)

     

       88
       88
        
       	cid := fmt.Sprintf("bafy%s", rkey)

     

       89
       89
        
       

     

       90
       90
        
       	comment := &Comment{

+1 -1

scripts/generate_nba_comments.go

···

       144
       144
        
       

     

       145
       145
        
       func createComment(db *sql.DB, user *User, content, parentURI, parentCID string, createdAt time.Time) (*Comment, error) {

     

       146
       146
        
       	rkey := generateTID()

     

       147
       147
       -
       	uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", user.DID, rkey)

     

       147
       147
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", user.DID, rkey)

     

       148
       148
        
       	cid := fmt.Sprintf("bafy%s", rkey)

     

       149
       149
        
       

     

       150
       150
        
       	comment := &Comment{

+1 -1

scripts/generate_test_comments.go

···

       140
       140
        
       

     

       141
       141
        
       func createComment(db *sql.DB, user *User, content, parentURI, parentCID string, createdAt time.Time) (*Comment, error) {

     

       142
       142
        
       	rkey := generateTID()

     

       143
       143
       -
       	uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", user.DID, rkey)

     

       143
       143
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", user.DID, rkey)

     

       144
       144
        
       	cid := fmt.Sprintf("bafy%s", rkey)

     

       145
       145
        
       

     

       146
       146
        
       	comment := &Comment{

+61 -61

tests/integration/comment_consumer_test.go

···

       32
       32
        
       

     

       33
       33
        
       	t.Run("Create comment on post", func(t *testing.T) {

     

       34
       34
        
       		rkey := generateTID()

     

       35
       35
       -
       		uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, rkey)

     

       35
       35
       +
       		uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, rkey)

     

       36
       36
        
       

     

       37
       37
        
       		// Simulate Jetstream comment create event

     

       38
       38
        
       		event := &jetstream.JetstreamEvent{

     
···

       41
       41
        
       			Commit: &jetstream.CommitEvent{

     

       42
       42
        
       				Rev:        "test-rev",

     

       43
       43
        
       				Operation:  "create",

     

       44
       44
       -
       				Collection: "social.coves.feed.comment",

     

       44
       44
       +
       				Collection: "social.coves.community.comment",

     

       45
       45
        
       				RKey:       rkey,

     

       46
       46
        
       				CID:        "bafytest123",

     

       47
       47
        
       				Record: map[string]interface{}{

     

       48
       48
       -
       					"$type":   "social.coves.feed.comment",

     

       48
       48
       +
       					"$type":   "social.coves.community.comment",

     

       49
       49
        
       					"content": "This is a test comment on a post!",

     

       50
       50
        
       					"reply": map[string]interface{}{

     

       51
       51
        
       						"root": map[string]interface{}{

     
···

       115
       115
        
       			Commit: &jetstream.CommitEvent{

     

       116
       116
        
       				Rev:        "test-rev",

     

       117
       117
        
       				Operation:  "create",

     

       118
       118
       -
       				Collection: "social.coves.feed.comment",

     

       118
       118
       +
       				Collection: "social.coves.community.comment",

     

       119
       119
        
       				RKey:       rkey,

     

       120
       120
        
       				CID:        "bafytest456",

     

       121
       121
        
       				Record: map[string]interface{}{

     

       122
       122
       -
       					"$type":   "social.coves.feed.comment",

     

       122
       122
       +
       					"$type":   "social.coves.community.comment",

     

       123
       123
        
       					"content": "Idempotent test comment",

     

       124
       124
        
       					"reply": map[string]interface{}{

     

       125
       125
        
       						"root": map[string]interface{}{

     
···

       191
       191
        
       	t.Run("Create nested comment replies", func(t *testing.T) {

     

       192
       192
        
       		// Create first-level comment on post

     

       193
       193
        
       		comment1Rkey := generateTID()

     

       194
       194
       -
       		comment1URI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, comment1Rkey)

     

       194
       194
       +
       		comment1URI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, comment1Rkey)

     

       195
       195
        
       

     

       196
       196
        
       		event1 := &jetstream.JetstreamEvent{

     

       197
       197
        
       			Did:  testUser.DID,

     

       198
       198
        
       			Kind: "commit",

     

       199
       199
        
       			Commit: &jetstream.CommitEvent{

     

       200
       200
        
       				Operation:  "create",

     

       201
       201
       -
       				Collection: "social.coves.feed.comment",

     

       201
       201
       +
       				Collection: "social.coves.community.comment",

     

       202
       202
        
       				RKey:       comment1Rkey,

     

       203
       203
        
       				CID:        "bafycomment1",

     

       204
       204
        
       				Record: map[string]interface{}{

     
···

       225
       225
        
       

     

       226
       226
        
       		// Create second-level comment (reply to first comment)

     

       227
       227
        
       		comment2Rkey := generateTID()

     

       228
       228
       -
       		comment2URI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, comment2Rkey)

     

       228
       228
       +
       		comment2URI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, comment2Rkey)

     

       229
       229
        
       

     

       230
       230
        
       		event2 := &jetstream.JetstreamEvent{

     

       231
       231
        
       			Did:  testUser.DID,

     

       232
       232
        
       			Kind: "commit",

     

       233
       233
        
       			Commit: &jetstream.CommitEvent{

     

       234
       234
        
       				Operation:  "create",

     

       235
       235
       -
       				Collection: "social.coves.feed.comment",

     

       235
       235
       +
       				Collection: "social.coves.community.comment",

     

       236
       236
        
       				RKey:       comment2Rkey,

     

       237
       237
        
       				CID:        "bafycomment2",

     

       238
       238
        
       				Record: map[string]interface{}{

     
···

       346
       346
        
       

     

       347
       347
        
       	t.Run("Update comment content preserves vote counts", func(t *testing.T) {

     

       348
       348
        
       		rkey := generateTID()

     

       349
       349
       -
       		uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, rkey)

     

       349
       349
       +
       		uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, rkey)

     

       350
       350
        
       

     

       351
       351
        
       		// Create initial comment

     

       352
       352
        
       		createEvent := &jetstream.JetstreamEvent{

     
···

       354
       354
        
       			Kind: "commit",

     

       355
       355
        
       			Commit: &jetstream.CommitEvent{

     

       356
       356
        
       				Operation:  "create",

     

       357
       357
       -
       				Collection: "social.coves.feed.comment",

     

       357
       357
       +
       				Collection: "social.coves.community.comment",

     

       358
       358
        
       				RKey:       rkey,

     

       359
       359
        
       				CID:        "bafyoriginal",

     

       360
       360
        
       				Record: map[string]interface{}{

     
···

       395
       395
        
       			Kind: "commit",

     

       396
       396
        
       			Commit: &jetstream.CommitEvent{

     

       397
       397
        
       				Operation:  "update",

     

       398
       398
       -
       				Collection: "social.coves.feed.comment",

     

       398
       398
       +
       				Collection: "social.coves.community.comment",

     

       399
       399
        
       				RKey:       rkey,

     

       400
       400
        
       				CID:        "bafyupdated",

     

       401
       401
        
       				Record: map[string]interface{}{

     
···

       472
       472
        
       

     

       473
       473
        
       	t.Run("Delete comment decrements parent count", func(t *testing.T) {

     

       474
       474
        
       		rkey := generateTID()

     

       475
       475
       -
       		uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, rkey)

     

       475
       475
       +
       		uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, rkey)

     

       476
       476
        
       

     

       477
       477
        
       		// Create comment

     

       478
       478
        
       		createEvent := &jetstream.JetstreamEvent{

     
···

       480
       480
        
       			Kind: "commit",

     

       481
       481
        
       			Commit: &jetstream.CommitEvent{

     

       482
       482
        
       				Operation:  "create",

     

       483
       483
       -
       				Collection: "social.coves.feed.comment",

     

       483
       483
       +
       				Collection: "social.coves.community.comment",

     

       484
       484
        
       				RKey:       rkey,

     

       485
       485
        
       				CID:        "bafydelete",

     

       486
       486
        
       				Record: map[string]interface{}{

     
···

       518
       518
        
       			Kind: "commit",

     

       519
       519
        
       			Commit: &jetstream.CommitEvent{

     

       520
       520
        
       				Operation:  "delete",

     

       521
       521
       -
       				Collection: "social.coves.feed.comment",

     

       521
       521
       +
       				Collection: "social.coves.community.comment",

     

       522
       522
        
       				RKey:       rkey,

     

       523
       523
        
       			},

     

       524
       524
        
       		}

     
···

       559
       559
        
       			Kind: "commit",

     

       560
       560
        
       			Commit: &jetstream.CommitEvent{

     

       561
       561
        
       				Operation:  "create",

     

       562
       562
       -
       				Collection: "social.coves.feed.comment",

     

       562
       562
       +
       				Collection: "social.coves.community.comment",

     

       563
       563
        
       				RKey:       rkey,

     

       564
       564
        
       				CID:        "bafyidempdelete",

     

       565
       565
        
       				Record: map[string]interface{}{

     
···

       590
       590
        
       			Kind: "commit",

     

       591
       591
        
       			Commit: &jetstream.CommitEvent{

     

       592
       592
        
       				Operation:  "delete",

     

       593
       593
       -
       				Collection: "social.coves.feed.comment",

     

       593
       593
       +
       				Collection: "social.coves.community.comment",

     

       594
       594
        
       				RKey:       rkey,

     

       595
       595
        
       			},

     

       596
       596
        
       		}

     
···

       651
       651
        
       			Kind: "commit",

     

       652
       652
        
       			Commit: &jetstream.CommitEvent{

     

       653
       653
        
       				Operation:  "create",

     

       654
       654
       -
       				Collection: "social.coves.feed.comment",

     

       654
       654
       +
       				Collection: "social.coves.community.comment",

     

       655
       655
        
       				RKey:       generateTID(),

     

       656
       656
        
       				CID:        "bafyinvalid",

     

       657
       657
        
       				Record: map[string]interface{}{

     
···

       683
       683
        
       			Kind: "commit",

     

       684
       684
        
       			Commit: &jetstream.CommitEvent{

     

       685
       685
        
       				Operation:  "create",

     

       686
       686
       -
       				Collection: "social.coves.feed.comment",

     

       686
       686
       +
       				Collection: "social.coves.community.comment",

     

       687
       687
        
       				RKey:       generateTID(),

     

       688
       688
        
       				CID:        "bafyinvalid2",

     

       689
       689
        
       				Record: map[string]interface{}{

     
···

       715
       715
        
       			Kind: "commit",

     

       716
       716
        
       			Commit: &jetstream.CommitEvent{

     

       717
       717
        
       				Operation:  "create",

     

       718
       718
       -
       				Collection: "social.coves.feed.comment",

     

       718
       718
       +
       				Collection: "social.coves.community.comment",

     

       719
       719
        
       				RKey:       generateTID(),

     

       720
       720
        
       				CID:        "bafyinvalid3",

     

       721
       721
        
       				Record: map[string]interface{}{

     
···

       747
       747
        
       			Kind: "commit",

     

       748
       748
        
       			Commit: &jetstream.CommitEvent{

     

       749
       749
        
       				Operation:  "create",

     

       750
       750
       -
       				Collection: "social.coves.feed.comment",

     

       750
       750
       +
       				Collection: "social.coves.community.comment",

     

       751
       751
        
       				RKey:       generateTID(),

     

       752
       752
        
       				CID:        "bafyinvalid4",

     

       753
       753
        
       				Record: map[string]interface{}{

     
···

       779
       779
        
       			Kind: "commit",

     

       780
       780
        
       			Commit: &jetstream.CommitEvent{

     

       781
       781
        
       				Operation:  "create",

     

       782
       782
       -
       				Collection: "social.coves.feed.comment",

     

       782
       782
       +
       				Collection: "social.coves.community.comment",

     

       783
       783
        
       				RKey:       generateTID(),

     

       784
       784
        
       				CID:        "bafytoobig",

     

       785
       785
        
       				Record: map[string]interface{}{

     
···

       814
       814
        
       			Kind: "commit",

     

       815
       815
        
       			Commit: &jetstream.CommitEvent{

     

       816
       816
        
       				Operation:  "create",

     

       817
       817
       -
       				Collection: "social.coves.feed.comment",

     

       817
       817
       +
       				Collection: "social.coves.community.comment",

     

       818
       818
        
       				RKey:       generateTID(),

     

       819
       819
        
       				CID:        "bafymalformed",

     

       820
       820
        
       				Record: map[string]interface{}{

     
···

       849
       849
        
       			Kind: "commit",

     

       850
       850
        
       			Commit: &jetstream.CommitEvent{

     

       851
       851
        
       				Operation:  "create",

     

       852
       852
       -
       				Collection: "social.coves.feed.comment",

     

       852
       852
       +
       				Collection: "social.coves.community.comment",

     

       853
       853
        
       				RKey:       generateTID(),

     

       854
       854
        
       				CID:        "bafymalformed2",

     

       855
       855
        
       				Record: map[string]interface{}{

     
···

       911
       911
        
       	//  |- Comment 4

     

       912
       912
        
       

     

       913
       913
        
       	comment1 := &comments.Comment{

     

       914
       914
       -
       		URI:          fmt.Sprintf("at://%s/social.coves.feed.comment/1", testUser.DID),

     

       914
       914
       +
       		URI:          fmt.Sprintf("at://%s/social.coves.community.comment/1", testUser.DID),

     

       915
       915
        
       		CID:          "bafyc1",

     

       916
       916
        
       		RKey:         "1",

     

       917
       917
        
       		CommenterDID: testUser.DID,

     
···

       925
       925
        
       	}

     

       926
       926
        
       

     

       927
       927
        
       	comment2 := &comments.Comment{

     

       928
       928
       -
       		URI:          fmt.Sprintf("at://%s/social.coves.feed.comment/2", testUser.DID),

     

       928
       928
       +
       		URI:          fmt.Sprintf("at://%s/social.coves.community.comment/2", testUser.DID),

     

       929
       929
        
       		CID:          "bafyc2",

     

       930
       930
        
       		RKey:         "2",

     

       931
       931
        
       		CommenterDID: testUser.DID,

     
···

       939
       939
        
       	}

     

       940
       940
        
       

     

       941
       941
        
       	comment3 := &comments.Comment{

     

       942
       942
       -
       		URI:          fmt.Sprintf("at://%s/social.coves.feed.comment/3", testUser.DID),

     

       942
       942
       +
       		URI:          fmt.Sprintf("at://%s/social.coves.community.comment/3", testUser.DID),

     

       943
       943
        
       		CID:          "bafyc3",

     

       944
       944
        
       		RKey:         "3",

     

       945
       945
        
       		CommenterDID: testUser.DID,

     
···

       953
       953
        
       	}

     

       954
       954
        
       

     

       955
       955
        
       	comment4 := &comments.Comment{

     

       956
       956
       -
       		URI:          fmt.Sprintf("at://%s/social.coves.feed.comment/4", testUser.DID),

     

       956
       956
       +
       		URI:          fmt.Sprintf("at://%s/social.coves.community.comment/4", testUser.DID),

     

       957
       957
        
       		CID:          "bafyc4",

     

       958
       958
        
       		RKey:         "4",

     

       959
       959
        
       		CommenterDID: testUser.DID,

     
···

       1074
       1074
        
       		//           When C1 finally arrives, its reply_count should be 1, not 0

     

       1075
       1075
        
       

     

       1076
       1076
        
       		parentRkey := generateTID()

     

       1077
       1077
       -
       		parentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, parentRkey)

     

       1077
       1077
       +
       		parentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, parentRkey)

     

       1078
       1078
        
       

     

       1079
       1079
        
       		childRkey := generateTID()

     

       1080
       1080
       -
       		childURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, childRkey)

     

       1080
       1080
       +
       		childURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, childRkey)

     

       1081
       1081
        
       

     

       1082
       1082
        
       		// Step 1: Index child FIRST (before parent exists)

     

       1083
       1083
        
       		childEvent := &jetstream.JetstreamEvent{

     
···

       1086
       1086
        
       			Commit: &jetstream.CommitEvent{

     

       1087
       1087
        
       				Rev:        "child-rev",

     

       1088
       1088
        
       				Operation:  "create",

     

       1089
       1089
       -
       				Collection: "social.coves.feed.comment",

     

       1089
       1089
       +
       				Collection: "social.coves.community.comment",

     

       1090
       1090
        
       				RKey:       childRkey,

     

       1091
       1091
        
       				CID:        "bafychild",

     

       1092
       1092
        
       				Record: map[string]interface{}{

     

       1093
       1093
       -
       					"$type":   "social.coves.feed.comment",

     

       1093
       1093
       +
       					"$type":   "social.coves.community.comment",

     

       1094
       1094
        
       					"content": "This is a reply to a comment that doesn't exist yet!",

     

       1095
       1095
        
       					"reply": map[string]interface{}{

     

       1096
       1096
        
       						"root": map[string]interface{}{

     
···

       1128
       1128
        
       			Commit: &jetstream.CommitEvent{

     

       1129
       1129
        
       				Rev:        "parent-rev",

     

       1130
       1130
        
       				Operation:  "create",

     

       1131
       1131
       -
       				Collection: "social.coves.feed.comment",

     

       1131
       1131
       +
       				Collection: "social.coves.community.comment",

     

       1132
       1132
        
       				RKey:       parentRkey,

     

       1133
       1133
        
       				CID:        "bafyparent",

     

       1134
       1134
        
       				Record: map[string]interface{}{

     

       1135
       1135
       -
       					"$type":   "social.coves.feed.comment",

     

       1135
       1135
       +
       					"$type":   "social.coves.community.comment",

     

       1136
       1136
        
       					"content": "This is the parent comment arriving late",

     

       1137
       1137
        
       					"reply": map[string]interface{}{

     

       1138
       1138
        
       						"root": map[string]interface{}{

     
···

       1178
       1178
        
       

     

       1179
       1179
        
       	t.Run("Multiple children arrive before parent", func(t *testing.T) {

     

       1180
       1180
        
       		parentRkey := generateTID()

     

       1181
       1181
       -
       		parentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, parentRkey)

     

       1181
       1181
       +
       		parentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, parentRkey)

     

       1182
       1182
        
       

     

       1183
       1183
        
       		// Index 3 children before parent

     

       1184
       1184
        
       		for i := 1; i <= 3; i++ {

     
···

       1189
       1189
        
       				Commit: &jetstream.CommitEvent{

     

       1190
       1190
        
       					Rev:        fmt.Sprintf("child-%d-rev", i),

     

       1191
       1191
        
       					Operation:  "create",

     

       1192
       1192
       -
       					Collection: "social.coves.feed.comment",

     

       1192
       1192
       +
       					Collection: "social.coves.community.comment",

     

       1193
       1193
        
       					RKey:       childRkey,

     

       1194
       1194
        
       					CID:        fmt.Sprintf("bafychild%d", i),

     

       1195
       1195
        
       					Record: map[string]interface{}{

     

       1196
       1196
       -
       						"$type":   "social.coves.feed.comment",

     

       1196
       1196
       +
       						"$type":   "social.coves.community.comment",

     

       1197
       1197
        
       						"content": fmt.Sprintf("Reply %d before parent", i),

     

       1198
       1198
        
       						"reply": map[string]interface{}{

     

       1199
       1199
        
       							"root": map[string]interface{}{

     
···

       1223
       1223
        
       			Commit: &jetstream.CommitEvent{

     

       1224
       1224
        
       				Rev:        "parent2-rev",

     

       1225
       1225
        
       				Operation:  "create",

     

       1226
       1226
       -
       				Collection: "social.coves.feed.comment",

     

       1226
       1226
       +
       				Collection: "social.coves.community.comment",

     

       1227
       1227
        
       				RKey:       parentRkey,

     

       1228
       1228
        
       				CID:        "bafyparent2",

     

       1229
       1229
        
       				Record: map[string]interface{}{

     

       1230
       1230
       -
       					"$type":   "social.coves.feed.comment",

     

       1230
       1230
       +
       					"$type":   "social.coves.community.comment",

     

       1231
       1231
        
       					"content": "Parent with 3 pre-existing children",

     

       1232
       1232
        
       					"reply": map[string]interface{}{

     

       1233
       1233
        
       						"root": map[string]interface{}{

     
···

       1283
       1283
        
       	postURI := createTestPost(t, db, testCommunity, testUser.DID, "Resurrection Test", 0, time.Now())

     

       1284
       1284
        
       

     

       1285
       1285
        
       	rkey := generateTID()

     

       1286
       1286
       -
       	commentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, rkey)

     

       1286
       1286
       +
       	commentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, rkey)

     

       1287
       1287
        
       

     

       1288
       1288
        
       	t.Run("Recreate deleted comment with same rkey", func(t *testing.T) {

     

       1289
       1289
        
       		// Step 1: Create initial comment

     
···

       1293
       1293
        
       			Commit: &jetstream.CommitEvent{

     

       1294
       1294
        
       				Rev:        "v1",

     

       1295
       1295
        
       				Operation:  "create",

     

       1296
       1296
       -
       				Collection: "social.coves.feed.comment",

     

       1296
       1296
       +
       				Collection: "social.coves.community.comment",

     

       1297
       1297
        
       				RKey:       rkey,

     

       1298
       1298
        
       				CID:        "bafyoriginal",

     

       1299
       1299
        
       				Record: map[string]interface{}{

     

       1300
       1300
       -
       					"$type":   "social.coves.feed.comment",

     

       1300
       1300
       +
       					"$type":   "social.coves.community.comment",

     

       1301
       1301
        
       					"content": "Original comment content",

     

       1302
       1302
        
       					"reply": map[string]interface{}{

     

       1303
       1303
        
       						"root": map[string]interface{}{

     
···

       1338
       1338
        
       			Commit: &jetstream.CommitEvent{

     

       1339
       1339
        
       				Rev:        "v2",

     

       1340
       1340
        
       				Operation:  "delete",

     

       1341
       1341
       -
       				Collection: "social.coves.feed.comment",

     

       1341
       1341
       +
       				Collection: "social.coves.community.comment",

     

       1342
       1342
        
       				RKey:       rkey,

     

       1343
       1343
        
       			},

     

       1344
       1344
        
       		}

     
···

       1365
       1365
        
       			Commit: &jetstream.CommitEvent{

     

       1366
       1366
        
       				Rev:        "v3",

     

       1367
       1367
        
       				Operation:  "create",

     

       1368
       1368
       -
       				Collection: "social.coves.feed.comment",

     

       1368
       1368
       +
       				Collection: "social.coves.community.comment",

     

       1369
       1369
        
       				RKey:       rkey, // Same rkey!

     

       1370
       1370
        
       				CID:        "bafyresurrected",

     

       1371
       1371
        
       				Record: map[string]interface{}{

     

       1372
       1372
       -
       					"$type":   "social.coves.feed.comment",

     

       1372
       1372
       +
       					"$type":   "social.coves.community.comment",

     

       1373
       1373
        
       					"content": "Resurrected comment with new content",

     

       1374
       1374
        
       					"reply": map[string]interface{}{

     

       1375
       1375
        
       						"root": map[string]interface{}{

     
···

       1424
       1424
        
       		post2URI := createTestPost(t, db, testCommunity, testUser.DID, "Post 2", 0, time.Now())

     

       1425
       1425
        
       

     

       1426
       1426
        
       		rkey2 := generateTID()

     

       1427
       1427
       -
       		commentURI2 := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, rkey2)

     

       1427
       1427
       +
       		commentURI2 := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, rkey2)

     

       1428
       1428
        
       

     

       1429
       1429
        
       		// Step 1: Create comment on Post 1

     

       1430
       1430
        
       		createEvent := &jetstream.JetstreamEvent{

     
···

       1433
       1433
        
       			Commit: &jetstream.CommitEvent{

     

       1434
       1434
        
       				Rev:        "v1",

     

       1435
       1435
        
       				Operation:  "create",

     

       1436
       1436
       -
       				Collection: "social.coves.feed.comment",

     

       1436
       1436
       +
       				Collection: "social.coves.community.comment",

     

       1437
       1437
        
       				RKey:       rkey2,

     

       1438
       1438
        
       				CID:        "bafyv1",

     

       1439
       1439
        
       				Record: map[string]interface{}{

     

       1440
       1440
       -
       					"$type":   "social.coves.feed.comment",

     

       1440
       1440
       +
       					"$type":   "social.coves.community.comment",

     

       1441
       1441
        
       					"content": "Original on Post 1",

     

       1442
       1442
        
       					"reply": map[string]interface{}{

     

       1443
       1443
        
       						"root": map[string]interface{}{

     
···

       1476
       1476
        
       			Commit: &jetstream.CommitEvent{

     

       1477
       1477
        
       				Rev:        "v2",

     

       1478
       1478
        
       				Operation:  "delete",

     

       1479
       1479
       -
       				Collection: "social.coves.feed.comment",

     

       1479
       1479
       +
       				Collection: "social.coves.community.comment",

     

       1480
       1480
        
       				RKey:       rkey2,

     

       1481
       1481
        
       			},

     

       1482
       1482
        
       		}

     
···

       1502
       1502
        
       			Commit: &jetstream.CommitEvent{

     

       1503
       1503
        
       				Rev:        "v3",

     

       1504
       1504
        
       				Operation:  "create",

     

       1505
       1505
       -
       				Collection: "social.coves.feed.comment",

     

       1505
       1505
       +
       				Collection: "social.coves.community.comment",

     

       1506
       1506
        
       				RKey:       rkey2, // Same rkey!

     

       1507
       1507
        
       				CID:        "bafyv3",

     

       1508
       1508
        
       				Record: map[string]interface{}{

     

       1509
       1509
       -
       					"$type":   "social.coves.feed.comment",

     

       1509
       1509
       +
       					"$type":   "social.coves.community.comment",

     

       1510
       1510
        
       					"content": "New comment on Post 2",

     

       1511
       1511
        
       					"reply": map[string]interface{}{

     

       1512
       1512
        
       						"root": map[string]interface{}{

     
···

       1588
       1588
        
       	postURI2 := createTestPost(t, db, testCommunity, testUser.DID, "Post 2", 0, time.Now())

     

       1589
       1589
        
       

     

       1590
       1590
        
       	rkey := generateTID()

     

       1591
       1591
       -
       	commentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, rkey)

     

       1591
       1591
       +
       	commentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, rkey)

     

       1592
       1592
        
       

     

       1593
       1593
        
       	t.Run("Reject UPDATE that changes parent URI", func(t *testing.T) {

     

       1594
       1594
        
       		// Create comment on Post 1

     
···

       1598
       1598
        
       			Commit: &jetstream.CommitEvent{

     

       1599
       1599
        
       				Rev:        "v1",

     

       1600
       1600
        
       				Operation:  "create",

     

       1601
       1601
       -
       				Collection: "social.coves.feed.comment",

     

       1601
       1601
       +
       				Collection: "social.coves.community.comment",

     

       1602
       1602
        
       				RKey:       rkey,

     

       1603
       1603
        
       				CID:        "bafycomment1",

     

       1604
       1604
        
       				Record: map[string]interface{}{

     

       1605
       1605
       -
       					"$type":   "social.coves.feed.comment",

     

       1605
       1605
       +
       					"$type":   "social.coves.community.comment",

     

       1606
       1606
        
       					"content": "Comment on Post 1",

     

       1607
       1607
        
       					"reply": map[string]interface{}{

     

       1608
       1608
        
       						"root": map[string]interface{}{

     
···

       1631
       1631
        
       			Commit: &jetstream.CommitEvent{

     

       1632
       1632
        
       				Rev:        "v2",

     

       1633
       1633
        
       				Operation:  "update",

     

       1634
       1634
       -
       				Collection: "social.coves.feed.comment",

     

       1634
       1634
       +
       				Collection: "social.coves.community.comment",

     

       1635
       1635
        
       				RKey:       rkey,

     

       1636
       1636
        
       				CID:        "bafycomment2",

     

       1637
       1637
        
       				Record: map[string]interface{}{

     

       1638
       1638
       -
       					"$type":   "social.coves.feed.comment",

     

       1638
       1638
       +
       					"$type":   "social.coves.community.comment",

     

       1639
       1639
        
       					"content": "Trying to hijack this comment to Post 2",

     

       1640
       1640
        
       					"reply": map[string]interface{}{

     

       1641
       1641
        
       						"root": map[string]interface{}{

     
···

       1679
       1679
        
       

     

       1680
       1680
        
       	t.Run("Allow UPDATE that only changes content (threading unchanged)", func(t *testing.T) {

     

       1681
       1681
        
       		rkey2 := generateTID()

     

       1682
       1682
       -
       		commentURI2 := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, rkey2)

     

       1682
       1682
       +
       		commentURI2 := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, rkey2)

     

       1683
       1683
        
       

     

       1684
       1684
        
       		// Create comment

     

       1685
       1685
        
       		createEvent := &jetstream.JetstreamEvent{

     
···

       1688
       1688
        
       			Commit: &jetstream.CommitEvent{

     

       1689
       1689
        
       				Rev:        "v1",

     

       1690
       1690
        
       				Operation:  "create",

     

       1691
       1691
       -
       				Collection: "social.coves.feed.comment",

     

       1691
       1691
       +
       				Collection: "social.coves.community.comment",

     

       1692
       1692
        
       				RKey:       rkey2,

     

       1693
       1693
        
       				CID:        "bafycomment3",

     

       1694
       1694
        
       				Record: map[string]interface{}{

     

       1695
       1695
       -
       					"$type":   "social.coves.feed.comment",

     

       1695
       1695
       +
       					"$type":   "social.coves.community.comment",

     

       1696
       1696
        
       					"content": "Original content",

     

       1697
       1697
        
       					"reply": map[string]interface{}{

     

       1698
       1698
        
       						"root": map[string]interface{}{

     
···

       1721
       1721
        
       			Commit: &jetstream.CommitEvent{

     

       1722
       1722
        
       				Rev:        "v2",

     

       1723
       1723
        
       				Operation:  "update",

     

       1724
       1724
       -
       				Collection: "social.coves.feed.comment",

     

       1724
       1724
       +
       				Collection: "social.coves.community.comment",

     

       1725
       1725
        
       				RKey:       rkey2,

     

       1726
       1726
        
       				CID:        "bafycomment4",

     

       1727
       1727
        
       				Record: map[string]interface{}{

     

       1728
       1728
       -
       					"$type":   "social.coves.feed.comment",

     

       1728
       1728
       +
       					"$type":   "social.coves.community.comment",

     

       1729
       1729
        
       					"content": "Updated content",

     

       1730
       1730
        
       					"reply": map[string]interface{}{

     

       1731
       1731
        
       						"root": map[string]interface{}{

+6 -6

tests/integration/comment_query_test.go

···

       538
       538
        
       	commentURIs := make([]string, 5)

     

       539
       539
        
       	for i := 0; i < 5; i++ {

     

       540
       540
        
       		rkey := generateTID()

     

       541
       541
       -
       		uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, rkey)

     

       541
       541
       +
       		uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, rkey)

     

       542
       542
        
       		commentURIs[i] = uri

     

       543
       543
        
       

     

       544
       544
        
       		event := &jetstream.JetstreamEvent{

     
···

       546
       546
        
       			Kind: "commit",

     

       547
       547
        
       			Commit: &jetstream.CommitEvent{

     

       548
       548
        
       				Operation:  "create",

     

       549
       549
       -
       				Collection: "social.coves.feed.comment",

     

       549
       549
       +
       				Collection: "social.coves.community.comment",

     

       550
       550
        
       				RKey:       rkey,

     

       551
       551
        
       				CID:        fmt.Sprintf("bafyc%d", i),

     

       552
       552
        
       				Record: map[string]interface{}{

     

       553
       553
       -
       					"$type":   "social.coves.feed.comment",

     

       553
       553
       +
       					"$type":   "social.coves.community.comment",

     

       554
       554
        
       					"content": fmt.Sprintf("Comment %d", i),

     

       555
       555
        
       					"reply": map[string]interface{}{

     

       556
       556
        
       						"root": map[string]interface{}{

     
···

       576
       576
        
       		Kind: "commit",

     

       577
       577
        
       		Commit: &jetstream.CommitEvent{

     

       578
       578
        
       			Operation:  "delete",

     

       579
       579
       -
       			Collection: "social.coves.feed.comment",

     

       579
       579
       +
       			Collection: "social.coves.community.comment",

     

       580
       580
        
       			RKey:       strings.Split(commentURIs[1], "/")[4],

     

       581
       581
        
       		},

     

       582
       582
        
       	}

     
···

       587
       587
        
       		Kind: "commit",

     

       588
       588
        
       		Commit: &jetstream.CommitEvent{

     

       589
       589
        
       			Operation:  "delete",

     

       590
       590
       -
       			Collection: "social.coves.feed.comment",

     

       590
       590
       +
       			Collection: "social.coves.community.comment",

     

       591
       591
        
       			RKey:       strings.Split(commentURIs[3], "/")[4],

     

       592
       592
        
       		},

     

       593
       593
        
       	}

     
···

       794
       794
        
       

     

       795
       795
        
       	ctx := context.Background()

     

       796
       796
        
       	rkey := generateTID()

     

       797
       797
       -
       	uri := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", commenterDID, rkey)

     

       797
       797
       +
       	uri := fmt.Sprintf("at://%s/social.coves.community.comment/%s", commenterDID, rkey)

     

       798
       798
        
       

     

       799
       799
        
       	// Insert comment directly for speed

     

       800
       800
        
       	_, err := db.ExecContext(ctx, `

+15 -15

tests/integration/comment_vote_test.go

···

       43
       43
        
       	t.Run("Upvote on comment increments count", func(t *testing.T) {

     

       44
       44
        
       		// Create a comment

     

       45
       45
        
       		commentRKey := generateTID()

     

       46
       46
       -
       		commentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, commentRKey)

     

       46
       46
       +
       		commentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, commentRKey)

     

       47
       47
        
       		commentCID := "bafycomment123"

     

       48
       48
        
       

     

       49
       49
        
       		commentEvent := &jetstream.JetstreamEvent{

     
···

       52
       52
        
       			Commit: &jetstream.CommitEvent{

     

       53
       53
        
       				Rev:        "test-rev",

     

       54
       54
        
       				Operation:  "create",

     

       55
       55
       -
       				Collection: "social.coves.feed.comment",

     

       55
       55
       +
       				Collection: "social.coves.community.comment",

     

       56
       56
        
       				RKey:       commentRKey,

     

       57
       57
        
       				CID:        commentCID,

     

       58
       58
        
       				Record: map[string]interface{}{

     

       59
       59
       -
       					"$type":   "social.coves.feed.comment",

     

       59
       59
       +
       					"$type":   "social.coves.community.comment",

     

       60
       60
        
       					"content": "Comment to vote on",

     

       61
       61
        
       					"reply": map[string]interface{}{

     

       62
       62
        
       						"root": map[string]interface{}{

     
···

       143
       143
        
       	t.Run("Downvote on comment increments downvote count", func(t *testing.T) {

     

       144
       144
        
       		// Create a comment

     

       145
       145
        
       		commentRKey := generateTID()

     

       146
       146
       -
       		commentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, commentRKey)

     

       146
       146
       +
       		commentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, commentRKey)

     

       147
       147
        
       		commentCID := "bafycomment456"

     

       148
       148
        
       

     

       149
       149
        
       		commentEvent := &jetstream.JetstreamEvent{

     
···

       152
       152
        
       			Commit: &jetstream.CommitEvent{

     

       153
       153
        
       				Rev:        "test-rev",

     

       154
       154
        
       				Operation:  "create",

     

       155
       155
       -
       				Collection: "social.coves.feed.comment",

     

       155
       155
       +
       				Collection: "social.coves.community.comment",

     

       156
       156
        
       				RKey:       commentRKey,

     

       157
       157
        
       				CID:        commentCID,

     

       158
       158
        
       				Record: map[string]interface{}{

     

       159
       159
       -
       					"$type":   "social.coves.feed.comment",

     

       159
       159
       +
       					"$type":   "social.coves.community.comment",

     

       160
       160
        
       					"content": "Comment to downvote",

     

       161
       161
        
       					"reply": map[string]interface{}{

     

       162
       162
        
       						"root": map[string]interface{}{

     
···

       221
       221
        
       	t.Run("Delete vote decrements comment counts", func(t *testing.T) {

     

       222
       222
        
       		// Create comment

     

       223
       223
        
       		commentRKey := generateTID()

     

       224
       224
       -
       		commentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, commentRKey)

     

       224
       224
       +
       		commentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, commentRKey)

     

       225
       225
        
       		commentCID := "bafycomment789"

     

       226
       226
        
       

     

       227
       227
        
       		commentEvent := &jetstream.JetstreamEvent{

     
···

       230
       230
        
       			Commit: &jetstream.CommitEvent{

     

       231
       231
        
       				Rev:        "test-rev",

     

       232
       232
        
       				Operation:  "create",

     

       233
       233
       -
       				Collection: "social.coves.feed.comment",

     

       233
       233
       +
       				Collection: "social.coves.community.comment",

     

       234
       234
        
       				RKey:       commentRKey,

     

       235
       235
        
       				CID:        commentCID,

     

       236
       236
        
       				Record: map[string]interface{}{

     

       237
       237
       -
       					"$type":   "social.coves.feed.comment",

     

       237
       237
       +
       					"$type":   "social.coves.community.comment",

     

       238
       238
        
       					"content": "Comment for vote deletion test",

     

       239
       239
        
       					"reply": map[string]interface{}{

     

       240
       240
        
       						"root": map[string]interface{}{

     
···

       353
       353
        
       	t.Run("Viewer with vote sees vote state", func(t *testing.T) {

     

       354
       354
        
       		// Create comment

     

       355
       355
        
       		commentRKey := generateTID()

     

       356
       356
       -
       		commentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, commentRKey)

     

       356
       356
       +
       		commentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, commentRKey)

     

       357
       357
        
       		commentCID := "bafycomment111"

     

       358
       358
        
       

     

       359
       359
        
       		commentEvent := &jetstream.JetstreamEvent{

     
···

       362
       362
        
       			Commit: &jetstream.CommitEvent{

     

       363
       363
        
       				Rev:        "test-rev",

     

       364
       364
        
       				Operation:  "create",

     

       365
       365
       -
       				Collection: "social.coves.feed.comment",

     

       365
       365
       +
       				Collection: "social.coves.community.comment",

     

       366
       366
        
       				RKey:       commentRKey,

     

       367
       367
        
       				CID:        commentCID,

     

       368
       368
        
       				Record: map[string]interface{}{

     

       369
       369
       -
       					"$type":   "social.coves.feed.comment",

     

       369
       369
       +
       					"$type":   "social.coves.community.comment",

     

       370
       370
        
       					"content": "Comment with viewer vote",

     

       371
       371
        
       					"reply": map[string]interface{}{

     

       372
       372
        
       						"root": map[string]interface{}{

     
···

       465
       465
        
       	t.Run("Viewer without vote sees empty state", func(t *testing.T) {

     

       466
       466
        
       		// Create comment (no vote)

     

       467
       467
        
       		commentRKey := generateTID()

     

       468
       468
       -
       		commentURI := fmt.Sprintf("at://%s/social.coves.feed.comment/%s", testUser.DID, commentRKey)

     

       468
       468
       +
       		commentURI := fmt.Sprintf("at://%s/social.coves.community.comment/%s", testUser.DID, commentRKey)

     

       469
       469
        
       

     

       470
       470
        
       		commentEvent := &jetstream.JetstreamEvent{

     

       471
       471
        
       			Did:  testUser.DID,

     
···

       473
       473
        
       			Commit: &jetstream.CommitEvent{

     

       474
       474
        
       				Rev:        "test-rev",

     

       475
       475
        
       				Operation:  "create",

     

       476
       476
       -
       				Collection: "social.coves.feed.comment",

     

       476
       476
       +
       				Collection: "social.coves.community.comment",

     

       477
       477
        
       				RKey:       commentRKey,

     

       478
       478
        
       				CID:        "bafycomment222",

     

       479
       479
        
       				Record: map[string]interface{}{

     

       480
       480
       -
       					"$type":   "social.coves.feed.comment",

     

       480
       480
       +
       					"$type":   "social.coves.community.comment",

     

       481
       481
        
       					"content": "Comment without viewer vote",

     

       482
       482
        
       					"reply": map[string]interface{}{

     

       483
       483
        
       						"root": map[string]interface{}{

+1 -1

tests/lexicon-test-data/interaction/comment-invalid-content.json

···

       1
       1
        
       {

     

       2
       2
       -
         "$type": "social.coves.feed.comment",

     

       2
       2
       +
         "$type": "social.coves.community.comment",

     

       3
       3
        
         "reply": {

     

       4
       4
        
           "root": {

     

       5
       5
        
             "uri": "at://did:plc:test123/social.coves.community.post/3k7a3dmb5bk2c",

+1 -1

tests/lexicon-test-data/interaction/comment-valid-sticker.json

···

       1
       1
        
       {

     

       2
       2
       -
         "$type": "social.coves.feed.comment",

     

       2
       2
       +
         "$type": "social.coves.community.comment",

     

       3
       3
        
         "reply": {

     

       4
       4
        
           "root": {

     

       5
       5
        
             "uri": "at://did:plc:test123/social.coves.community.post/3k7a3dmb5bk2c",

+1 -1

tests/lexicon-test-data/interaction/comment-valid-text.json

···

       1
       1
        
       {

     

       2
       2
       -
         "$type": "social.coves.feed.comment",

     

       2
       2
       +
         "$type": "social.coves.community.comment",

     

       3
       3
        
         "reply": {

     

       4
       4
        
           "root": {

     

       5
       5
        
             "uri": "at://did:plc:test123/social.coves.community.post/3k7a3dmb5bk2c",