+20 -23

appview/db/follow.go

··· 6 6 "strings" 7 7 "time" 8 8 9 9 + "github.com/bluesky-social/indigo/atproto/syntax" 9 10 "tangled.org/core/appview/models" 10 11 "tangled.org/core/orm" 11 12 ) ··· 16 17 return err 17 18 } 18 19 19 19 - // Get a follow record 20 20 - func GetFollow(e Execer, userDid, subjectDid string) (*models.Follow, error) { 21 21 - query := `select did, subject_did, created, rkey from follows where did = ? and subject_did = ?` 22 22 - row := e.QueryRow(query, userDid, subjectDid) 23 23 - 24 24 - var follow models.Follow 25 25 - var followedAt string 26 26 - err := row.Scan(&follow.UserDid, &follow.SubjectDid, &followedAt, &follow.Rkey) 20 20 + // Remove a follow 21 21 + func DeleteFollow(e Execer, did, subjectDid syntax.DID) ([]syntax.ATURI, error) { 22 22 + var deleted []syntax.ATURI 23 23 + rows, err := e.Query( 24 24 + `delete from follows 25 25 + where did = ? and subject_did = ? 26 26 + returning at_uri`, 27 27 + did, 28 28 + subjectDid, 29 29 + ) 27 30 if err != nil { 28 28 - return nil, err 31 31 + return nil, fmt.Errorf("deleting stars: %w", err) 29 32 } 33 33 + defer rows.Close() 30 34 31 31 - followedAtTime, err := time.Parse(time.RFC3339, followedAt) 32 32 - if err != nil { 33 33 - log.Println("unable to determine followed at time") 34 34 - follow.FollowedAt = time.Now() 35 35 - } else { 36 36 - follow.FollowedAt = followedAtTime 35 35 + for rows.Next() { 36 36 + var aturi syntax.ATURI 37 37 + if err := rows.Scan(&aturi); err != nil { 38 38 + return nil, fmt.Errorf("scanning at_uri: %w", err) 39 39 + } 40 40 + deleted = append(deleted, aturi) 37 41 } 38 38 - 39 39 - return &follow, nil 40 40 - } 41 41 - 42 42 - // Remove a follow 43 43 - func DeleteFollow(e Execer, userDid, subjectDid string) error { 44 44 - _, err := e.Exec(`delete from follows where did = ? and subject_did = ?`, userDid, subjectDid) 45 45 - return err 42 42 + return deleted, nil 46 43 } 47 44 48 45 // Remove a follow

+24 -3

appview/db/reaction.go

··· 1 1 package db 2 2 3 3 import ( 4 4 + "fmt" 4 5 "log" 5 6 "time" 6 7 ··· 41 42 } 42 43 43 44 // Remove a reaction 44 44 - func DeleteReaction(e Execer, did string, subjectAt syntax.ATURI, kind models.ReactionKind) error { 45 45 - _, err := e.Exec(`delete from reactions where did = ? and subject_at = ? and kind = ?`, did, subjectAt, kind) 46 46 - return err 45 45 + func DeleteReaction(e Execer, did syntax.DID, subjectAt syntax.ATURI, kind models.ReactionKind) ([]syntax.ATURI, error) { 46 46 + var deleted []syntax.ATURI 47 47 + rows, err := e.Query( 48 48 + `delete from reactions 49 49 + where did = ? and subject_at = ? and kind = ? 50 50 + returning at_uri`, 51 51 + did, 52 52 + subjectAt, 53 53 + kind, 54 54 + ) 55 55 + if err != nil { 56 56 + return nil, fmt.Errorf("deleting stars: %w", err) 57 57 + } 58 58 + defer rows.Close() 59 59 + 60 60 + for rows.Next() { 61 61 + var aturi syntax.ATURI 62 62 + if err := rows.Scan(&aturi); err != nil { 63 63 + return nil, fmt.Errorf("scanning at_uri: %w", err) 64 64 + } 65 65 + deleted = append(deleted, aturi) 66 66 + } 67 67 + return deleted, nil 47 68 } 48 69 49 70 // Remove a reaction

+19 -27

appview/db/star.go

··· 4 4 "database/sql" 5 5 "errors" 6 6 "fmt" 7 7 - "log" 8 7 "slices" 9 8 "strings" 10 9 "time" ··· 25 24 return err 26 25 } 27 26 28 28 - // Get a star record 29 29 - func GetStar(e Execer, did string, subjectAt syntax.ATURI) (*models.Star, error) { 30 30 - query := ` 31 31 - select did, subject_at, created, rkey 32 32 - from stars 33 33 - where did = ? and subject_at = ?` 34 34 - row := e.QueryRow(query, did, subjectAt) 35 35 - 36 36 - var star models.Star 37 37 - var created string 38 38 - err := row.Scan(&star.Did, &star.RepoAt, &created, &star.Rkey) 27 27 + // Remove a star 28 28 + func DeleteStar(tx *sql.Tx, did syntax.DID, subjectAt syntax.ATURI) ([]syntax.ATURI, error) { 29 29 + var deleted []syntax.ATURI 30 30 + rows, err := tx.Query( 31 31 + `delete from stars 32 32 + where did = ? and subject_at = ? 33 33 + returning at_uri`, 34 34 + did, 35 35 + subjectAt, 36 36 + ) 39 37 if err != nil { 40 40 - return nil, err 38 38 + return nil, fmt.Errorf("deleting stars: %w", err) 41 39 } 40 40 + defer rows.Close() 42 41 43 43 - createdAtTime, err := time.Parse(time.RFC3339, created) 44 44 - if err != nil { 45 45 - log.Println("unable to determine followed at time") 46 46 - star.Created = time.Now() 47 47 - } else { 48 48 - star.Created = createdAtTime 42 42 + for rows.Next() { 43 43 + var aturi syntax.ATURI 44 44 + if err := rows.Scan(&aturi); err != nil { 45 45 + return nil, fmt.Errorf("scanning at_uri: %w", err) 46 46 + } 47 47 + deleted = append(deleted, aturi) 49 48 } 50 50 - 51 51 - return &star, nil 52 52 - } 53 53 - 54 54 - // Remove a star 55 55 - func DeleteStar(e Execer, did string, subjectAt syntax.ATURI) error { 56 56 - _, err := e.Exec(`delete from stars where did = ? and subject_at = ?`, did, subjectAt) 57 57 - return err 49 49 + return deleted, nil 58 50 } 59 51 60 52 // Remove a star

+32 -15

appview/state/follow.go

··· 6 6 "time" 7 7 8 8 comatproto "github.com/bluesky-social/indigo/api/atproto" 9 9 + "github.com/bluesky-social/indigo/atproto/syntax" 9 10 lexutil "github.com/bluesky-social/indigo/lex/util" 10 11 "tangled.org/core/api/tangled" 11 12 "tangled.org/core/appview/db" ··· 88 89 89 90 return 90 91 case http.MethodDelete: 91 91 - // find the record in the db 92 92 - follow, err := db.GetFollow(s.db, currentUser.Active.Did, subjectIdent.DID.String()) 92 92 + tx, err := s.db.BeginTx(r.Context(), nil) 93 93 if err != nil { 94 94 - log.Println("failed to get follow relationship") 94 94 + s.logger.Error("failed to start transaction", "err", err) 95 95 + } 96 96 + defer tx.Rollback() 97 97 + 98 98 + follows, err := db.DeleteFollow(tx, syntax.DID(currentUser.Active.Did), subjectIdent.DID) 99 99 + if err != nil { 100 100 + s.logger.Error("failed to delete follows from db", "err", err) 95 101 return 96 102 } 97 103 98 98 - _, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{ 99 99 - Collection: tangled.GraphFollowNSID, 100 100 - Repo: currentUser.Active.Did, 101 101 - Rkey: follow.Rkey, 104 104 + var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem 105 105 + for _, followAt := range follows { 106 106 + writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{ 107 107 + RepoApplyWrites_Delete: &comatproto.RepoApplyWrites_Delete{ 108 108 + Collection: tangled.GraphFollowNSID, 109 109 + Rkey: followAt.RecordKey().String(), 110 110 + }, 111 111 + }) 112 112 + } 113 113 + _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{ 114 114 + Repo: currentUser.Active.Did, 115 115 + Writes: writes, 102 116 }) 103 103 - 104 117 if err != nil { 105 105 - log.Println("failed to unfollow") 118 118 + s.logger.Error("failed to delete follows from PDS", "err", err) 106 119 return 107 120 } 108 121 109 109 - err = db.DeleteFollowByRkey(s.db, currentUser.Active.Did, follow.Rkey) 110 110 - if err != nil { 111 111 - log.Println("failed to delete follow from DB") 112 112 - // this is not an issue, the firehose event might have already done this 122 122 + if err := tx.Commit(); err != nil { 123 123 + s.logger.Error("failed to commit transaction", "err", err) 124 124 + // DB op failed but record is created in PDS. Ingester will backfill the missed operation 113 125 } 126 126 + 127 127 + s.notifier.DeleteFollow(r.Context(), &models.Follow{ 128 128 + UserDid: currentUser.Active.Did, 129 129 + SubjectDid: subjectIdent.DID.String(), 130 130 + // Rkey 131 131 + // FollowedAt 132 132 + }) 114 133 115 134 followStats, err := db.GetFollowerFollowingCount(s.db, subjectIdent.DID.String()) 116 135 if err != nil { ··· 122 141 FollowStatus: models.IsNotFollowing, 123 142 FollowersCount: followStats.Followers, 124 143 }) 125 125 - 126 126 - s.notifier.DeleteFollow(r.Context(), follow) 127 144 128 145 return 129 146 }

+24 -12

appview/state/reaction.go

··· 87 87 88 88 return 89 89 case http.MethodDelete: 90 90 - reaction, err := db.GetReaction(s.db, currentUser.Active.Did, subjectUri, reactionKind) 90 90 + tx, err := s.db.BeginTx(r.Context(), nil) 91 91 + if err != nil { 92 92 + s.logger.Error("failed to start transaction", "err", err) 93 93 + } 94 94 + defer tx.Rollback() 95 95 + 96 96 + reactions, err := db.DeleteReaction(tx, syntax.DID(currentUser.Active.Did), subjectUri, reactionKind) 91 97 if err != nil { 92 92 - log.Println("failed to get reaction relationship for", currentUser.Active.Did, subjectUri) 98 98 + s.logger.Error("failed to delete reactions from db", "err", err) 93 99 return 94 100 } 95 101 96 96 - _, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{ 97 97 - Collection: tangled.FeedReactionNSID, 98 98 - Repo: currentUser.Active.Did, 99 99 - Rkey: reaction.Rkey, 102 102 + var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem 103 103 + for _, reactionAt := range reactions { 104 104 + writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{ 105 105 + RepoApplyWrites_Delete: &comatproto.RepoApplyWrites_Delete{ 106 106 + Collection: tangled.FeedReactionNSID, 107 107 + Rkey: reactionAt.RecordKey().String(), 108 108 + }, 109 109 + }) 110 110 + } 111 111 + _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{ 112 112 + Repo: currentUser.Active.Did, 113 113 + Writes: writes, 100 114 }) 101 101 - 102 115 if err != nil { 103 103 - log.Println("failed to remove reaction") 116 116 + s.logger.Error("failed to delete reactions from PDS", "err", err) 104 117 return 105 118 } 106 119 107 107 - err = db.DeleteReactionByRkey(s.db, currentUser.Active.Did, reaction.Rkey) 108 108 - if err != nil { 109 109 - log.Println("failed to delete reaction from DB") 110 110 - // this is not an issue, the firehose event might have already done this 120 120 + if err := tx.Commit(); err != nil { 121 121 + s.logger.Error("failed to commit transaction", "err", err) 122 122 + // DB op failed but record is created in PDS. Ingester will backfill the missed operation 111 123 } 112 124 113 125 reactionMap, err := db.GetReactionMap(s.db, 20, subjectUri)

+31 -15

appview/state/star.go

··· 83 83 84 84 return 85 85 case http.MethodDelete: 86 86 - // find the record in the db 87 87 - star, err := db.GetStar(s.db, currentUser.Active.Did, subjectUri) 86 86 + tx, err := s.db.BeginTx(r.Context(), nil) 88 87 if err != nil { 89 89 - log.Println("failed to get star relationship") 88 88 + s.logger.Error("failed to start transaction", "err", err) 89 89 + } 90 90 + defer tx.Rollback() 91 91 + 92 92 + stars, err := db.DeleteStar(tx, syntax.DID(currentUser.Active.Did), subjectUri) 93 93 + if err != nil { 94 94 + s.logger.Error("failed to delete stars from db", "err", err) 90 95 return 91 96 } 92 97 93 93 - _, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{ 94 94 - Collection: tangled.FeedStarNSID, 95 95 - Repo: currentUser.Active.Did, 96 96 - Rkey: star.Rkey, 98 98 + var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem 99 99 + for _, starAt := range stars { 100 100 + writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{ 101 101 + RepoApplyWrites_Delete: &comatproto.RepoApplyWrites_Delete{ 102 102 + Collection: tangled.FeedStarNSID, 103 103 + Rkey: starAt.RecordKey().String(), 104 104 + }, 105 105 + }) 106 106 + } 107 107 + _, err = comatproto.RepoApplyWrites(r.Context(), client, &comatproto.RepoApplyWrites_Input{ 108 108 + Repo: currentUser.Active.Did, 109 109 + Writes: writes, 97 110 }) 98 98 - 99 111 if err != nil { 100 100 - log.Println("failed to unstar") 112 112 + s.logger.Error("failed to delete stars from PDS", "err", err) 101 113 return 102 114 } 103 115 104 104 - err = db.DeleteStarByRkey(s.db, currentUser.Active.Did, star.Rkey) 105 105 - if err != nil { 106 106 - log.Println("failed to delete star from DB") 107 107 - // this is not an issue, the firehose event might have already done this 116 116 + if err := tx.Commit(); err != nil { 117 117 + s.logger.Error("failed to commit transaction", "err", err) 118 118 + // DB op failed but record is created in PDS. Ingester will backfill the missed operation 108 119 } 109 120 121 121 + s.notifier.DeleteStar(r.Context(), &models.Star{ 122 122 + Did: currentUser.Active.Did, 123 123 + RepoAt: subjectUri, 124 124 + // Rkey 125 125 + // Created 126 126 + }) 127 127 + 110 128 starCount, err := db.GetStarCount(s.db, subjectUri) 111 129 if err != nil { 112 130 log.Println("failed to get star count for ", subjectUri) 113 131 return 114 132 } 115 115 - 116 116 - s.notifier.DeleteStar(r.Context(), star) 117 133 118 134 s.pages.StarBtnFragment(w, pages.StarBtnFragmentParams{ 119 135 IsStarred: false,