fix(api): persist new unread threads

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: bf00a0ac-e11f-4015-b295-3cdd9b491229

Author: AchoArnold

api/pkg/repositories/gorm_message_thread_repository.go

@@ -111,7 +111,24 @@ func (repository *gormMessageThreadRepository) Store(ctx context.Context, thread
 	ctx, span := repository.tracer.Start(ctx)
 	defer span.End()
 
-	if err := repository.db.WithContext(ctx).Clauses(clause.OnConflict{DoNothing: true}).Create(thread).Error; err != nil {
+	isRead := thread.IsRead
+	err := repository.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		result := tx.Clauses(clause.OnConflict{DoNothing: true}).Create(thread)
+		thread.IsRead = isRead
+		if result.Error != nil {
+			return result.Error
+		}
+		if result.RowsAffected == 0 || isRead {
+			return nil
+		}
+
+		return tx.Model(&entities.MessageThread{}).
+			Where("user_id = ?", thread.UserID).
+			Where("id = ?", thread.ID).
+			UpdateColumn("is_read", false).
+			Error
+	})
+	if err != nil {
 		msg := fmt.Sprintf("cannot save message thread with ID [%s]", thread.ID)
 		return repository.tracer.WrapErrorSpan(span, stacktrace.Propagate(err, msg))
 	}

api/pkg/repositories/gorm_message_thread_repository_test.go

@@ -1,14 +1,108 @@
 package repositories
 
 import (
+	"context"
+	"database/sql"
+	"database/sql/driver"
+	"errors"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/NdoleStudio/httpsms/pkg/entities"
+	"github.com/NdoleStudio/httpsms/pkg/telemetry"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/otel/trace"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
 )
 
+type messageThreadTestStatement struct {
+	query string
+	args  []any
+}
+
+type messageThreadTestConnPool struct {
+	statements []messageThreadTestStatement
+}
+
+func (messageThreadTestConnPool) PrepareContext(context.Context, string) (*sql.Stmt, error) {
+	return nil, errors.New("unexpected PrepareContext")
+}
+
+func (pool *messageThreadTestConnPool) ExecContext(_ context.Context, query string, args ...any) (sql.Result, error) {
+	pool.statements = append(pool.statements, messageThreadTestStatement{
+		query: query,
+		args:  append([]any(nil), args...),
+	})
+	return driver.RowsAffected(1), nil
+}
+
+func (messageThreadTestConnPool) QueryContext(context.Context, string, ...any) (*sql.Rows, error) {
+	return nil, errors.New("unexpected QueryContext")
+}
+
+func (messageThreadTestConnPool) QueryRowContext(context.Context, string, ...any) *sql.Row {
+	return &sql.Row{}
+}
+
+func (pool *messageThreadTestConnPool) BeginTx(context.Context, *sql.TxOptions) (gorm.ConnPool, error) {
+	return pool, nil
+}
+
+func (*messageThreadTestConnPool) Commit() error {
+	return nil
+}
+
+func (*messageThreadTestConnPool) Rollback() error {
+	return nil
+}
+
+type messageThreadTestLogger struct{}
+
+func (logger *messageThreadTestLogger) Error(error)                         {}
+func (logger *messageThreadTestLogger) WithService(string) telemetry.Logger { return logger }
+
+func (logger *messageThreadTestLogger) WithString(string, string) telemetry.Logger { return logger }
+
+func (logger *messageThreadTestLogger) WithSpan(trace.SpanContext) telemetry.Logger { return logger }
+func (logger *messageThreadTestLogger) Trace(string)                                {}
+func (logger *messageThreadTestLogger) Info(string)                                 {}
+func (logger *messageThreadTestLogger) Warn(error)                                  {}
+func (logger *messageThreadTestLogger) Debug(string)                                {}
+func (logger *messageThreadTestLogger) Fatal(error)                                 {}
+func (logger *messageThreadTestLogger) Printf(string, ...interface{})               {}
+
+func TestMessageThreadStorePreservesExplicitUnreadState(t *testing.T) {
+	pool := &messageThreadTestConnPool{}
+	db, err := gorm.Open(
+		postgres.New(postgres.Config{
+			Conn:             pool,
+			WithoutReturning: true,
+		}),
+		&gorm.Config{DisableAutomaticPing: true},
+	)
+	require.NoError(t, err)
+
+	logger := &messageThreadTestLogger{}
+	repository := NewGormMessageThreadRepository(logger, telemetry.NewOtelLogger("test", logger), db)
+	thread := &entities.MessageThread{
+		ID:     uuid.New(),
+		IsRead: false,
+	}
+
+	require.NoError(t, repository.Store(context.Background(), thread))
+	assert.False(t, thread.IsRead)
+
+	require.NotEmpty(t, pool.statements)
+	update := pool.statements[len(pool.statements)-1]
+	assert.True(t, strings.HasPrefix(update.query, `UPDATE "message_threads"`))
+	assert.Contains(t, update.query, `"is_read"=$1`)
+	assert.Contains(t, update.args, false)
+}
+
 func TestMessageThreadActivityUpdatesOwnOnlyMessageColumns(t *testing.T) {
 	messageID := uuid.New()
 	updates := messageThreadActivityUpdates(MessageThreadActivityUpdate{