core/server/store/postgres/note.go

package postgres

import (
	"context"
	"database/sql"
	"encoding/json"
	"fmt"
	"strings"

	"git.gobha.me/xcaliber/chat-switchboard/models"
	"git.gobha.me/xcaliber/chat-switchboard/store"

	"github.com/lib/pq"
)

type NoteStore struct{}

func NewNoteStore() *NoteStore { return &NoteStore{} }

func (s *NoteStore) Create(ctx context.Context, n *models.Note) error {
	return DB.QueryRowContext(ctx, `
		INSERT INTO notes (user_id, title, content, folder_path, tags, metadata, source_channel_id, team_id)
		VALUES ($1,$2,$3,$4,$5,$6,$7,$8)
		RETURNING id, created_at, updated_at`,
		n.UserID, n.Title, n.Content, n.FolderPath,
		pq.Array(n.Tags), ToJSON(n.Metadata),
		models.NullString(n.SourceChannelID), models.NullString(n.TeamID),
	).Scan(&n.ID, &n.CreatedAt, &n.UpdatedAt)
}

func (s *NoteStore) GetByID(ctx context.Context, id string) (*models.Note, error) {
	var n models.Note
	var sourceChannelID, teamID sql.NullString
	var metadataJSON []byte
	err := DB.QueryRowContext(ctx, `
		SELECT id, user_id, title, content, folder_path, tags, metadata,
			source_channel_id, team_id, created_at, updated_at
		FROM notes WHERE id = $1`, id).Scan(
		&n.ID, &n.UserID, &n.Title, &n.Content, &n.FolderPath,
		pq.Array(&n.Tags), &metadataJSON,
		&sourceChannelID, &teamID, &n.CreatedAt, &n.UpdatedAt,
	)
	if err != nil {
		return nil, err
	}
	n.SourceChannelID = NullableStringPtr(sourceChannelID)
	n.TeamID = NullableStringPtr(teamID)
	json.Unmarshal(metadataJSON, &n.Metadata)
	return &n, nil
}

func (s *NoteStore) Update(ctx context.Context, id string, fields map[string]interface{}) error {
	b := NewUpdate("notes")
	for k, v := range fields {
		if k == "metadata" {
			b.SetJSON(k, v)
		} else if k == "tags" {
			if tags, ok := v.([]string); ok {
				b.Set(k, pq.Array(tags))
			}
		} else {
			b.Set(k, v)
		}
	}
	if !b.HasSets() {
		return nil
	}
	b.Where("id", id)
	_, err := b.Exec(DB)
	return err
}

func (s *NoteStore) Delete(ctx context.Context, id string) error {
	_, err := DB.ExecContext(ctx, "DELETE FROM notes WHERE id = $1", id)
	return err
}

func (s *NoteStore) ListForUser(ctx context.Context, userID string, opts store.NoteListOptions) ([]models.Note, int, error) {
	b := NewSelect(
		"id, user_id, title, content, folder_path, tags, metadata, source_channel_id, team_id, created_at, updated_at",
		"notes",
	).Where("user_id = ?", userID)

	if opts.FolderPath != "" {
		b.Where("folder_path = ?", opts.FolderPath)
	}
	if opts.Tag != "" {
		b.Where("? = ANY(tags)", opts.Tag)
	}
	if opts.TeamID != "" {
		b.Where("team_id = ?", opts.TeamID)
	}

	// Count
	countQ, countArgs := b.CountBuild()
	var total int
	DB.QueryRowContext(ctx, countQ, countArgs...).Scan(&total)

	if opts.Sort == "" {
		b.OrderBy("updated_at", "DESC")
	}
	b.Paginate(opts.ListOptions)

	q, args := b.Build()
	rows, err := DB.QueryContext(ctx, q, args...)
	if err != nil {
		return nil, 0, err
	}
	defer rows.Close()

	var result []models.Note
	for rows.Next() {
		var n models.Note
		var sourceChannelID, teamID sql.NullString
		var metadataJSON []byte
		err := rows.Scan(&n.ID, &n.UserID, &n.Title, &n.Content, &n.FolderPath,
			pq.Array(&n.Tags), &metadataJSON,
			&sourceChannelID, &teamID, &n.CreatedAt, &n.UpdatedAt)
		if err != nil {
			return nil, 0, err
		}
		n.SourceChannelID = NullableStringPtr(sourceChannelID)
		n.TeamID = NullableStringPtr(teamID)
		json.Unmarshal(metadataJSON, &n.Metadata)
		result = append(result, n)
	}
	return result, total, rows.Err()
}

func (s *NoteStore) Search(ctx context.Context, userID, query string, opts store.ListOptions) ([]models.Note, int, error) {
	tsQuery := strings.Join(strings.Fields(query), " & ")

	b := NewSelect(
		"id, user_id, title, content, folder_path, tags, metadata, source_channel_id, team_id, created_at, updated_at",
		"notes",
	).Where("user_id = ?", userID).Where("search_vector @@ to_tsquery('english', ?)", tsQuery)
	b.OrderBy("ts_rank(search_vector, to_tsquery('english', '"+tsQuery+"'))", "DESC")
	b.Paginate(opts)

	var total int
	DB.QueryRowContext(ctx,
		"SELECT COUNT(*) FROM notes WHERE user_id = $1 AND search_vector @@ to_tsquery('english', $2)",
		userID, tsQuery).Scan(&total)

	q, args := b.Build()
	rows, err := DB.QueryContext(ctx, q, args...)
	if err != nil {
		return nil, 0, err
	}
	defer rows.Close()

	var result []models.Note
	for rows.Next() {
		var n models.Note
		var sourceChannelID, teamID sql.NullString
		var metadataJSON []byte
		err := rows.Scan(&n.ID, &n.UserID, &n.Title, &n.Content, &n.FolderPath,
			pq.Array(&n.Tags), &metadataJSON,
			&sourceChannelID, &teamID, &n.CreatedAt, &n.UpdatedAt)
		if err != nil {
			return nil, 0, err
		}
		n.SourceChannelID = NullableStringPtr(sourceChannelID)
		n.TeamID = NullableStringPtr(teamID)
		json.Unmarshal(metadataJSON, &n.Metadata)
		result = append(result, n)
	}
	return result, total, rows.Err()
}

func (s *NoteStore) BulkDelete(ctx context.Context, ids []string, userID string) (int, error) {
	if len(ids) == 0 {
		return 0, nil
	}
	placeholders := make([]string, len(ids))
	args := make([]interface{}, 0, len(ids)+1)
	args = append(args, userID)
	for i, id := range ids {
		placeholders[i] = fmt.Sprintf("$%d", i+2)
		args = append(args, id)
	}
	result, err := DB.ExecContext(ctx,
		fmt.Sprintf("DELETE FROM notes WHERE user_id = $1 AND id IN (%s)",
			strings.Join(placeholders, ",")),
		args...)
	if err != nil {
		return 0, err
	}
	n, _ := result.RowsAffected()
	return int(n), nil
}