promoted: remove prisma from postgres store

Author: Jeff Yanta

promoted/postgres/model.go

@@ -0,0 +1,90 @@
+package postgres
+
+import (
+	"context"
+	"time"
+
+	"github.com/georgysavva/scany/v2/pgxscan"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	commonpb "github.com/code-payments/flipchat-protobuf-api/generated/go/common/v1"
+
+	pg "github.com/code-payments/flipchat-server/database/postgres"
+	"github.com/code-payments/flipchat-server/promoted"
+)
+
+const (
+	promotedChatsTableName = "flipchat_promotedchats"
+	allPromotedChatFields  = `"chatId", "topic", "score", "createdAt", "updatedAt"`
+)
+
+type model struct {
+	ChatID    string    `db:"chatId"`
+	Topic     string    `db:"topic"`
+	Score     int       `db:"score"`
+	CreatedAt time.Time `db:"createdAt"`
+	UpdatedAt time.Time `db:"updatedAt"`
+}
+
+func toModel(promotedChat *promoted.PromotedChat) (*model, error) {
+	return &model{
+		ChatID: pg.Encode(promotedChat.ChatID.Value),
+		Topic:  promotedChat.Topic,
+		Score:  promotedChat.Score,
+	}, nil
+}
+
+func fromModel(m *model) (*promoted.PromotedChat, error) {
+	decodedChatID, err := pg.Decode(m.ChatID)
+	if err != nil {
+		return nil, err
+	}
+	return &promoted.PromotedChat{
+		ChatID: &commonpb.ChatId{Value: decodedChatID},
+		Topic:  m.Topic,
+		Score:  m.Score,
+	}, nil
+}
+
+func (m *model) dbUpsert(ctx context.Context, pool *pgxpool.Pool) error {
+	query := `INSERT INTO ` + promotedChatsTableName + ` (` + allPromotedChatFields + `) VALUES ($1, $2, $3, NOW(), NOW()) ON CONFLICT ("chatId", "topic") DO UPDATE SET "score" = $3 WHERE ` + promotedChatsTableName + `."chatId" = $1 AND ` + promotedChatsTableName + `."topic" = $2 RETURNING` + allPromotedChatFields
+	return pgxscan.Get(
+		ctx,
+		pool,
+		m,
+		query,
+		m.ChatID,
+		m.Topic,
+		m.Score,
+	)
+}
+
+func dbGetPromotedChats(ctx context.Context, pool *pgxpool.Pool, topic string) ([]*model, error) {
+	var res []*model
+	query := `SELECT ` + allPromotedChatFields + ` FROM ` + promotedChatsTableName + ` WHERE "topic" = $1 ORDER BY "score" DESC`
+	err := pgxscan.Select(
+		ctx,
+		pool,
+		&res,
+		query,
+		topic,
+	)
+	if err != nil {
+		if pgxscan.NotFound(err) {
+			return nil, promoted.ErrNotFound
+		}
+		return nil, err
+	}
+	return res, nil
+}
+
+func dbDemoteChat(ctx context.Context, pool *pgxpool.Pool, chatID *commonpb.ChatId, topic string) error {
+	query := `DELETE FROM ` + promotedChatsTableName + ` WHERE "chatId" = $1 AND "topic" = $2`
+	_, err := pool.Exec(
+		ctx,
+		query,
+		pg.Encode(chatID.Value),
+		topic,
+	)
+	return err
+}

promoted/postgres/server_test.go

@@ -10,7 +10,6 @@ import (
 
 	account "github.com/code-payments/flipchat-server/account/postgres"
 	chat "github.com/code-payments/flipchat-server/chat/postgres"
-	prismatest "github.com/code-payments/flipchat-server/database/prisma/test"
 
 	"github.com/code-payments/flipchat-server/promoted/tests"
 
@@ -23,12 +22,9 @@ func TestPromoted_PostgresServer(t *testing.T) {
 	require.NoError(t, err)
 	defer pool.Close()
 
-	client, disconnect := prismatest.NewTestClient(testEnv.DatabaseUrl, t)
-	defer disconnect()
-
 	accountStore := account.NewInPostgres(pool)
 	chatStore := chat.NewInPostgres(pool)
-	testStore := NewInPostgres(client)
+	testStore := NewInPostgres(pool)
 	teardown := func() {
 		testStore.(*store).reset()
 	}

promoted/postgres/store.go

@@ -3,70 +3,43 @@ package postgres
 import (
 	"context"
 
+	"github.com/jackc/pgx/v5/pgxpool"
+
 	commonpb "github.com/code-payments/flipchat-protobuf-api/generated/go/common/v1"
-	pg "github.com/code-payments/flipchat-server/database/postgres"
 
-	"github.com/code-payments/flipchat-server/database/prisma/db"
 	"github.com/code-payments/flipchat-server/promoted"
 )
 
 type store struct {
-	client *db.PrismaClient
-}
-
-// reset clears the PromotedChat table (used for testing).
-func (s *store) reset() {
-	ctx := context.Background()
-
-	promotedChats := s.client.PromotedChat.FindMany().Delete().Tx()
-	err := s.client.Prisma.Transaction(promotedChats).Exec(ctx)
-	if err != nil {
-		panic(err)
-	}
+	pool *pgxpool.Pool
 }
 
 // NewInPostgres creates a new PostgreSQL store for Promoted Chats.
-func NewInPostgres(client *db.PrismaClient) promoted.Store {
+func NewInPostgres(pool *pgxpool.Pool) promoted.Store {
 	return &store{
-		client: client,
+		pool: pool,
 	}
 }
 
 // GetPromotedChats retrieves promoted chats by topic from PostgreSQL.
 func (s *store) GetPromotedChats(ctx context.Context, topic string) ([]*promoted.PromotedChat, error) {
-
-	prChats, err := s.client.PromotedChat.FindMany(
-		db.PromotedChat.Topic.Equals(topic),
-	).OrderBy(
-		db.PromotedChat.Score.Order(db.SortOrderDesc),
-	).Exec(ctx)
+	models, err := dbGetPromotedChats(ctx, s.pool, topic)
 	if err != nil {
 		return nil, err
 	}
 
-	var chats []*promoted.PromotedChat
-	for _, prChat := range prChats {
-
-		decodedChatID, err := pg.Decode(prChat.ChatID)
+	res := make([]*promoted.PromotedChat, len(models))
+	for i, model := range models {
+		res[i], err = fromModel(model)
 		if err != nil {
 			return nil, err
 		}
-
-		chats = append(chats, &promoted.PromotedChat{
-			ChatID:    &commonpb.ChatId{Value: decodedChatID},
-			Score:     prChat.Score,
-			Topic:     prChat.Topic,
-			CreatedAt: prChat.CreatedAt,
-			UpdatedAt: prChat.UpdatedAt,
-		})
 	}
-
-	return chats, nil
+	return res, nil
 }
 
 // PromoteChat promotes a chat (or updates the score if it already exists).
 func (s *store) PromoteChat(ctx context.Context, chatID *commonpb.ChatId, topic string, score int) error {
-
 	if chatID == nil {
 		return promoted.ErrInvalidChatID
 	}
@@ -79,22 +52,16 @@ func (s *store) PromoteChat(ctx context.Context, chatID *commonpb.ChatId, topic
 		return promoted.ErrInvalidTopic
 	}
 
-	encodedChatID := pg.Encode(chatID.Value)
-
-	_, err := s.client.PromotedChat.UpsertOne(
-		db.PromotedChat.ChatIDTopic(
-			db.PromotedChat.ChatID.Equals(encodedChatID),
-			db.PromotedChat.Topic.Equals(topic),
-		),
-	).Create(
-		db.PromotedChat.Chat.Link(db.Chat.ID.Equals(encodedChatID)),
-		db.PromotedChat.Topic.Set(topic),
-		db.PromotedChat.Score.Set(score),
-	).Update(
-		db.PromotedChat.Score.Set(score),
-	).Exec(ctx)
-
-	return err
+	model, err := toModel(&promoted.PromotedChat{
+		ChatID: chatID,
+		Topic:  topic,
+		Score:  score,
+	})
+	if err != nil {
+		return err
+	}
+
+	return model.dbUpsert(ctx, s.pool)
 }
 
 func (s *store) DemoteChat(ctx context.Context, chatID *commonpb.ChatId, topic string) error {
@@ -106,16 +73,12 @@ func (s *store) DemoteChat(ctx context.Context, chatID *commonpb.ChatId, topic s
 		return promoted.ErrInvalidTopic
 	}
 
-	encodedChatID := pg.Encode(chatID.Value)
-
-	_, err := s.client.PromotedChat.FindMany(
-		db.PromotedChat.ChatID.Equals(encodedChatID),
-		db.PromotedChat.Topic.Equals(topic),
-	).Delete().Exec(ctx)
+	return dbDemoteChat(ctx, s.pool, chatID, topic)
+}
 
+func (s *store) reset() {
+	_, err := s.pool.Exec(context.Background(), "DELETE FROM "+promotedChatsTableName)
 	if err != nil {
-		return promoted.ErrNotFound
+		panic(err)
 	}
-
-	return nil
 }

promoted/postgres/store_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	chat "github.com/code-payments/flipchat-server/chat/postgres"
-	prismatest "github.com/code-payments/flipchat-server/database/prisma/test"
 
 	"github.com/code-payments/flipchat-server/promoted/tests"
 
@@ -22,11 +21,8 @@ func TestPromoted_PostgresStore(t *testing.T) {
 	require.NoError(t, err)
 	defer pool.Close()
 
-	client, disconnect := prismatest.NewTestClient(testEnv.DatabaseUrl, t)
-	defer disconnect()
-
 	chatStore := chat.NewInPostgres(pool)
-	testStore := NewInPostgres(client)
+	testStore := NewInPostgres(pool)
 	teardown := func() {
 		testStore.(*store).reset()
 	}