Implement account.Update w/ follow logic

Author: theandrew168

backend/command/follow.go

@@ -13,7 +13,33 @@ func (cmd *Command) FollowBlog(accountID uuid.UUID, blogID uuid.UUID) error {
 			return err
 		}
 
-		err = account.FollowBlog(blogID)
+		blog, err := tx.Blog().Read(blogID)
+		if err != nil {
+			return err
+		}
+
+		err = account.FollowBlog(blog)
+		if err != nil {
+			return err
+		}
+
+		return tx.Account().Update(account)
+	})
+}
+
+func (cmd *Command) UnfollowBlog(accountID uuid.UUID, blogID uuid.UUID) error {
+	return cmd.repo.WithTransaction(func(tx *repository.Repository) error {
+		account, err := tx.Account().Read(accountID)
+		if err != nil {
+			return err
+		}
+
+		blog, err := tx.Blog().Read(blogID)
+		if err != nil {
+			return err
+		}
+
+		err = account.UnfollowBlog(blog)
 		if err != nil {
 			return err
 		}

backend/model/account.go

@@ -68,21 +68,22 @@ func (a *Account) FollowedBlogIDs() []uuid.UUID {
 	return a.followedBlogIDs
 }
 
-func (a *Account) FollowBlog(blogID uuid.UUID) error {
-	if slices.Contains(a.followedBlogIDs, blogID) {
+func (a *Account) FollowBlog(blog *Blog) error {
+	if slices.Contains(a.followedBlogIDs, blog.ID()) {
 		return nil
 	}
 
-	a.followedBlogIDs = append(a.followedBlogIDs, blogID)
+	a.followedBlogIDs = append(a.followedBlogIDs, blog.ID())
 	return nil
 }
 
-func (a *Account) UnfollowBlog(blogID uuid.UUID) error {
-	if !slices.Contains(a.followedBlogIDs, blogID) {
+func (a *Account) UnfollowBlog(blog *Blog) error {
+	index := slices.Index(a.followedBlogIDs, blog.ID())
+	if index == -1 {
 		return nil
 	}
 
-	a.followedBlogIDs = slices.Delete(a.followedBlogIDs, slices.Index(a.followedBlogIDs, blogID), slices.Index(a.followedBlogIDs, blogID)+1)
+	a.followedBlogIDs = slices.Delete(a.followedBlogIDs, index, index+1)
 	return nil
 }
 

backend/repository/account.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
+	"slices"
 	"time"
 
 	"github.com/google/uuid"
@@ -229,8 +230,59 @@ func (r *AccountRepository) List(limit, offset int) ([]*model.Account, error) {
 
 func (r *AccountRepository) Update(account *model.Account) error {
 	// List blogs currently being followed in the database.
+	stmt := `
+		SELECT
+			account_blog.blog_id
+		FROM account_blog
+		WHERE account_blog.account_id = $1`
+
+	rows, err := QueryWithTimeout(r.conn, stmt, account.ID())
+	if err != nil {
+		return err
+	}
+
+	followedBlogIDs, err := pgx.CollectRows(rows, pgx.RowTo[uuid.UUID])
+	if err != nil {
+		return postgres.CheckListError(err)
+	}
+
 	// Set diff to find which blogs to add or remove.
+	var blogsToFollow []uuid.UUID
+	for _, blogID := range account.FollowedBlogIDs() {
+		if !slices.Contains(followedBlogIDs, blogID) {
+			blogsToFollow = append(blogsToFollow, blogID)
+		}
+	}
+
+	var blogsToUnfollow []uuid.UUID
+	for _, blogID := range followedBlogIDs {
+		if !slices.Contains(account.FollowedBlogIDs(), blogID) {
+			blogsToUnfollow = append(blogsToUnfollow, blogID)
+		}
+	}
+
 	// Add and remove blogs as necessary.
+	stmtFollow := `
+		INSERT INTO account_blog
+			(account_id, blog_id)
+		VALUES ($1, $2)`
+	for _, blogID := range blogsToFollow {
+		err = ExecWithTimeout(r.conn, stmtFollow, account.ID(), blogID)
+		if err != nil {
+			return postgres.CheckCreateError(err)
+		}
+	}
+
+	stmtUnfollow := `
+		DELETE FROM account_blog
+		WHERE account_id = $1 AND blog_id = $2`
+	for _, blogID := range blogsToUnfollow {
+		err = ExecWithTimeout(r.conn, stmtUnfollow, account.ID(), blogID)
+		if err != nil {
+			return postgres.CheckDeleteError(err)
+		}
+	}
+
 	return nil
 }
 

backend/repository/account_test.go

@@ -90,6 +90,33 @@ func TestAccountList(t *testing.T) {
 	test.AssertEqual(t, len(accounts), limit)
 }
 
+func TestAccountUpdate(t *testing.T) {
+	t.Parallel()
+
+	repo, closer := test.NewRepository(t)
+	defer closer()
+
+	account := test.CreateAccount(t, repo)
+	blog := test.CreateBlog(t, repo)
+
+	account.FollowBlog(blog)
+	err := repo.Account().Update(account)
+	test.AssertNilError(t, err)
+
+	updatedAccount, err := repo.Account().Read(account.ID())
+	test.AssertNilError(t, err)
+
+	test.AssertSliceContains(t, updatedAccount.FollowedBlogIDs(), blog.ID())
+
+	account.UnfollowBlog(blog)
+	err = repo.Account().Update(account)
+	test.AssertNilError(t, err)
+
+	updatedAccount, err = repo.Account().Read(account.ID())
+	test.AssertNilError(t, err)
+	test.AssertSliceDoesNotContain(t, updatedAccount.FollowedBlogIDs(), blog.ID())
+}
+
 func TestAccountDelete(t *testing.T) {
 	t.Parallel()
 

backend/repository/repository.go

@@ -3,6 +3,8 @@ package repository
 import (
 	"context"
 
+	"github.com/jackc/pgx/v5"
+
 	"github.com/theandrew168/bloggulus/backend/postgres"
 )
 
@@ -100,3 +102,19 @@ func (r *Repository) WithTransaction(operation func(repo *Repository) error) err
 
 	return nil
 }
+
+func QueryWithTimeout(conn postgres.Conn, stmt string, args ...any) (pgx.Rows, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), postgres.Timeout)
+	defer cancel()
+
+	rows, err := conn.Query(ctx, stmt, args...)
+	return rows, err
+}
+
+func ExecWithTimeout(conn postgres.Conn, stmt string, args ...any) error {
+	ctx, cancel := context.WithTimeout(context.Background(), postgres.Timeout)
+	defer cancel()
+
+	_, err := conn.Exec(ctx, stmt, args...)
+	return err
+}

backend/test/assert.go

@@ -48,6 +48,14 @@ func AssertSliceContains[T comparable](t *testing.T, got []T, want T) {
 	}
 }
 
+func AssertSliceDoesNotContain[T comparable](t *testing.T, got []T, want T) {
+	t.Helper()
+
+	if slices.Contains(got, want) {
+		t.Fatalf("got %v; should not contain: %v", got, want)
+	}
+}
+
 func AssertNilError(t *testing.T, got error) {
 	t.Helper()