909 lines
29 KiB
Go
909 lines
29 KiB
Go
package gateway
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"slices"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/messaging"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
"github.com/samcharles93/archie-core/internal/domain/presence"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
|
|
)
|
|
|
|
// postgresSessionStore is the PostgreSQL SessionStore. Appends to one session
|
|
// are serialised by an advisory lock, so message timestamps stay strictly
|
|
// increasing; ClaimTurn is decided by INSERT ... ON CONFLICT DO NOTHING.
|
|
type postgresSessionStore struct {
|
|
pool *pgxpool.Pool
|
|
}
|
|
|
|
// NewPostgresSessionStore returns a SessionStore backed by pool. The pool must
|
|
// already have the gateway schema applied (postgres.Migrations). The returned
|
|
// store owns the pool: Close closes it.
|
|
func NewPostgresSessionStore(pool *pgxpool.Pool) SessionStore {
|
|
return &postgresSessionStore{pool: pool}
|
|
}
|
|
|
|
func (s *postgresSessionStore) Close() error {
|
|
s.pool.Close()
|
|
return nil
|
|
}
|
|
|
|
// ── Sessions ────────────────────────────────────────────────────────────────
|
|
|
|
// sessionSaver is the one query Save needs.
|
|
type sessionSaver interface {
|
|
SaveSession(context.Context, postgresdb.SaveSessionParams) (int64, error)
|
|
}
|
|
|
|
func (s *postgresSessionStore) Save(ctx context.Context, sc SessionContext) error {
|
|
return saveSession(ctx, postgresdb.New(s.pool), sc)
|
|
}
|
|
|
|
// saveSession writes sc for the caller's org. Visibility (sessionVisible) is a
|
|
// read rule: the SaveSession upsert already refuses a row owned by another org
|
|
// or an existing conversation with a different source, so a write needs no
|
|
// visibility check and no platform may be excluded from creating its session.
|
|
func saveSession(ctx context.Context, q sessionSaver, sc SessionContext) error {
|
|
saved, err := q.SaveSession(ctx, postgresdb.SaveSessionParams{
|
|
SessionID: sc.SessionID,
|
|
Platform: sc.Source.Platform,
|
|
BotUser: sc.Source.BotUser,
|
|
ChannelID: sc.Source.ChannelID,
|
|
ThreadID: sc.Source.ThreadID,
|
|
Title: sc.Title,
|
|
ParentSessionID: sc.ParentSessionID,
|
|
BranchName: sc.BranchName,
|
|
CreatedAt: sc.CreatedAt.UnixMilli(),
|
|
LastActiveAt: sc.LastActiveAt.UnixMilli(),
|
|
OrgID: callerOrg(ctx),
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: save: %w", err)
|
|
}
|
|
if saved == 0 {
|
|
return ErrSessionNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) Get(ctx context.Context, sessionID string) (*SessionContext, error) {
|
|
q := postgresdb.New(s.pool)
|
|
row, err := q.SessionByID(ctx, postgresdb.SessionByIDParams{SessionID: sessionID, OrgID: callerOrg(ctx)})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sessionstore: get: %w", err)
|
|
}
|
|
sc := sessionFromRow(row)
|
|
if !sessionVisible(ctx, sc) {
|
|
return nil, nil
|
|
}
|
|
return &sc, nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) GetByChannel(ctx context.Context, platform, channelID string) ([]SessionContext, error) {
|
|
q := postgresdb.New(s.pool)
|
|
rows, err := q.SessionsByChannel(ctx, postgresdb.SessionsByChannelParams{
|
|
Platform: platform, ChannelID: channelID, OrgID: callerOrg(ctx),
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sessionstore: get by channel: %w", err)
|
|
}
|
|
return visibleSessions(ctx, sessionsFromRows(rows)), nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) Delete(ctx context.Context, sessionID string) error {
|
|
if err := s.mayWrite(ctx, sessionID); err != nil {
|
|
return err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: delete: begin: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
|
|
q := postgresdb.New(tx)
|
|
if err := q.DeleteSessionMessages(ctx, sessionID); err != nil {
|
|
return fmt.Errorf("sessionstore: delete messages: %w", err)
|
|
}
|
|
if err := q.DeleteSessionTurns(ctx, sessionID); err != nil {
|
|
return fmt.Errorf("sessionstore: delete turns: %w", err)
|
|
}
|
|
if err := q.DeleteSession(ctx, sessionID); err != nil {
|
|
return fmt.Errorf("sessionstore: delete session: %w", err)
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return fmt.Errorf("sessionstore: delete: commit: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) Touch(ctx context.Context, sessionID string) error {
|
|
if err := s.mayWrite(ctx, sessionID); err != nil {
|
|
return err
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
err := q.TouchSession(ctx, postgresdb.TouchSessionParams{
|
|
SessionID: sessionID, LastActiveAt: time.Now().UTC().UnixMilli(),
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: touch: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) List(ctx context.Context) ([]SessionContext, error) {
|
|
q := postgresdb.New(s.pool)
|
|
rows, err := q.ListSessions(ctx, callerOrg(ctx))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sessionstore: list: %w", err)
|
|
}
|
|
return visibleSessions(ctx, sessionsFromRows(rows)), nil
|
|
}
|
|
|
|
func sessionFromRow(row postgresdb.Session) SessionContext {
|
|
return SessionContext{
|
|
SessionID: row.SessionID,
|
|
Source: SessionSource{Platform: row.Platform, BotUser: row.BotUser, ChannelID: row.ChannelID, ThreadID: row.ThreadID},
|
|
Title: row.Title,
|
|
ParentSessionID: row.ParentSessionID,
|
|
BranchName: row.BranchName,
|
|
CreatedAt: time.UnixMilli(row.CreatedAt).UTC(),
|
|
LastActiveAt: time.UnixMilli(row.LastActiveAt).UTC(),
|
|
}
|
|
}
|
|
|
|
func sessionsFromRows(rows []postgresdb.Session) []SessionContext {
|
|
out := make([]SessionContext, 0, len(rows))
|
|
for _, row := range rows {
|
|
out = append(out, sessionFromRow(row))
|
|
}
|
|
return out
|
|
}
|
|
|
|
// ── Messages ────────────────────────────────────────────────────────────────
|
|
|
|
func (s *postgresSessionStore) SaveMessage(ctx context.Context, sessionID string, msg messaging.Message) error {
|
|
if err := s.mayWrite(ctx, sessionID); err != nil {
|
|
return err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: save message: begin: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
|
|
q := postgresdb.New(tx)
|
|
if err := q.LockSessionMessages(ctx, sessionID); err != nil {
|
|
return fmt.Errorf("sessionstore: lock session messages: %w", err)
|
|
}
|
|
if _, err := saveMessagePG(ctx, q, sessionID, msg, true); err != nil {
|
|
return err
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return fmt.Errorf("sessionstore: save message: commit: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) SaveMessages(ctx context.Context, sessionID string, msgs []messaging.Message) error {
|
|
if err := s.mayWrite(ctx, sessionID); err != nil {
|
|
return err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: save messages: begin: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
|
|
q := postgresdb.New(tx)
|
|
if err := q.LockSessionMessages(ctx, sessionID); err != nil {
|
|
return fmt.Errorf("sessionstore: lock session messages: %w", err)
|
|
}
|
|
for _, msg := range msgs {
|
|
if _, err := saveMessagePG(ctx, q, sessionID, msg, true); err != nil {
|
|
return fmt.Errorf("sessionstore: save messages: %w", err)
|
|
}
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return fmt.Errorf("sessionstore: save messages: commit: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// saveMessage persists one message through q and reports the canonical ID it
|
|
// was stored under (or was already stored under, for a redelivered message).
|
|
// The clamp parameter selects the append path's monotonic clamp, mirroring the
|
|
// SQLite store's saveMessageAt.
|
|
func saveMessagePG(ctx context.Context, q *postgresdb.Queries, sessionID string, msg messaging.Message, clamp bool) (string, error) {
|
|
id := string(msg.ID)
|
|
legacyID := ""
|
|
if msg.SourceID == "" {
|
|
if id == "" {
|
|
id = newMessageID(sessionID, "")
|
|
}
|
|
} else {
|
|
currentID, compatibleLegacyID := canonicalMessageIDs(sessionID, msg.SourceID)
|
|
if id == "" {
|
|
id = currentID
|
|
}
|
|
if id == currentID {
|
|
legacyID = compatibleLegacyID
|
|
}
|
|
}
|
|
role := string(msg.Role)
|
|
if role == "" {
|
|
role = string(messaging.RoleUser)
|
|
}
|
|
if legacyID != "" {
|
|
existingID, err := q.MessageID(ctx, postgresdb.MessageIDParams{
|
|
SessionID: sessionID, MessageID: legacyID,
|
|
})
|
|
switch {
|
|
case err == nil:
|
|
return existingID, nil
|
|
case !errors.Is(err, pgx.ErrNoRows):
|
|
return "", fmt.Errorf("sessionstore: read legacy message identity: %w", err)
|
|
}
|
|
}
|
|
at := stamp(msg)
|
|
mediaJSON, err := marshalMediaMeta(msg.Media)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if clamp {
|
|
err := q.InsertMessageClamped(ctx, postgresdb.InsertMessageClampedParams{
|
|
MessageID: id, SessionID: sessionID, SourceID: msg.SourceID,
|
|
Sender: msg.Sender, SenderID: msg.SenderID, Role: role, Text: msg.Text,
|
|
Media: mediaJSON,
|
|
Ts: at.UnixMilli(),
|
|
})
|
|
if err != nil {
|
|
return "", fmt.Errorf("sessionstore: save message: %w", err)
|
|
}
|
|
return id, nil
|
|
}
|
|
|
|
existingID, err := q.MessageID(ctx, postgresdb.MessageIDParams{
|
|
SessionID: sessionID, MessageID: id,
|
|
})
|
|
switch {
|
|
case err == nil:
|
|
return existingID, nil
|
|
case !errors.Is(err, pgx.ErrNoRows):
|
|
return "", fmt.Errorf("sessionstore: read existing message: %w", err)
|
|
}
|
|
|
|
err = q.InsertMessageAt(ctx, postgresdb.InsertMessageAtParams{
|
|
MessageID: id, SessionID: sessionID, SourceID: msg.SourceID,
|
|
Sender: msg.Sender, SenderID: msg.SenderID, Role: role, Text: msg.Text,
|
|
Media: mediaJSON,
|
|
Ts: at.UnixMilli(),
|
|
})
|
|
if err != nil {
|
|
return "", fmt.Errorf("sessionstore: save message: %w", err)
|
|
}
|
|
return id, nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) ReplaceMessages(
|
|
ctx context.Context,
|
|
sessionID string,
|
|
msgs []messaging.Message,
|
|
superseded []string,
|
|
) error {
|
|
if err := s.mayWrite(ctx, sessionID); err != nil {
|
|
return err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: replace messages: begin: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
|
|
q := postgresdb.New(tx)
|
|
survivors := make(map[string]struct{}, len(msgs))
|
|
for _, msg := range msgs {
|
|
// No clamp: the caller has already decided where each record belongs.
|
|
id, err := saveMessagePG(ctx, q, sessionID, msg, false)
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: replace messages: %w", err)
|
|
}
|
|
survivors[id] = struct{}{}
|
|
}
|
|
|
|
doomed := make([]string, 0, len(superseded))
|
|
for _, id := range superseded {
|
|
if _, kept := survivors[id]; kept {
|
|
continue
|
|
}
|
|
doomed = append(doomed, id)
|
|
}
|
|
if len(doomed) > 0 {
|
|
if err := q.DeleteMessagesByID(ctx, postgresdb.DeleteMessagesByIDParams{
|
|
SessionID: sessionID, Ids: doomed,
|
|
}); err != nil {
|
|
return fmt.Errorf("sessionstore: replace messages: delete old: %w", err)
|
|
}
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return fmt.Errorf("sessionstore: replace messages: commit: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) FindPriorReply(ctx context.Context, sessionID, sourceID, identity string) (string, error) {
|
|
if err := s.mayRead(ctx, sessionID); err != nil {
|
|
return "", err
|
|
}
|
|
if sourceID == "" {
|
|
return "", nil
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
|
|
currentID, legacyID := canonicalMessageIDs(sessionID, sourceID)
|
|
ts, err := q.SourceMessageTs(ctx, postgresdb.SourceMessageTsParams{
|
|
SessionID: sessionID, MessageID: currentID, MessageID_2: legacyID,
|
|
})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return "", nil
|
|
}
|
|
if err != nil {
|
|
return "", fmt.Errorf("sessionstore: find source message: %w", err)
|
|
}
|
|
|
|
next, err := q.NextReplyAfterTs(ctx, postgresdb.NextReplyAfterTsParams{
|
|
SessionID: sessionID, Ts: ts,
|
|
})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return "", nil
|
|
}
|
|
if err != nil {
|
|
return "", fmt.Errorf("sessionstore: find prior reply: %w", err)
|
|
}
|
|
if next.Sender != identity || isCompressionSummary(next.Text) {
|
|
return "", nil
|
|
}
|
|
return next.Text, nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) RecentMessages(ctx context.Context, sessionID string, n int) ([]messaging.Message, error) {
|
|
if err := s.mayRead(ctx, sessionID); err != nil {
|
|
return nil, err
|
|
}
|
|
if n <= 0 {
|
|
return nil, nil
|
|
}
|
|
if n > math.MaxInt32 {
|
|
return nil, fmt.Errorf("sessionstore: recent messages: limit exceeds max int32")
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
rows, err := q.RecentMessages(ctx, postgresdb.RecentMessagesParams{
|
|
SessionID: sessionID, Limit: int32(n),
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sessionstore: recent messages: %w", err)
|
|
}
|
|
return recentMessagesFromRows(rows), nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) DeleteRecentMessages(ctx context.Context, sessionID string, n int) (int, error) {
|
|
if err := s.mayWrite(ctx, sessionID); err != nil {
|
|
return 0, err
|
|
}
|
|
if n <= 0 {
|
|
return 0, nil
|
|
}
|
|
if n > math.MaxInt32 {
|
|
return 0, fmt.Errorf("sessionstore: delete recent messages: limit exceeds max int32")
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
deleted, err := q.DeleteRecentMessages(ctx, postgresdb.DeleteRecentMessagesParams{
|
|
SessionID: sessionID, Limit: int32(n),
|
|
})
|
|
if err != nil {
|
|
return 0, fmt.Errorf("sessionstore: delete recent messages: %w", err)
|
|
}
|
|
return int(deleted), nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) MessageCount(ctx context.Context, sessionID string) (int, error) {
|
|
if err := s.mayRead(ctx, sessionID); err != nil {
|
|
return 0, err
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
n, err := q.CountMessages(ctx, sessionID)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("sessionstore: message count: %w", err)
|
|
}
|
|
return int(n), nil
|
|
}
|
|
|
|
func recentMessagesFromRows(rows []postgresdb.RecentMessagesRow) []messaging.Message {
|
|
out := make([]messaging.Message, 0, len(rows))
|
|
for _, row := range rows {
|
|
out = append(out, rowMessage(messaging.Message{
|
|
ID: messaging.MessageID(row.MessageID),
|
|
SourceID: row.SourceID,
|
|
Sender: row.Sender,
|
|
SenderID: row.SenderID,
|
|
Role: messaging.Role(row.Role),
|
|
Text: row.Text,
|
|
At: time.UnixMilli(row.Ts).UTC(),
|
|
ConversationID: messaging.ConversationID{
|
|
ChannelID: row.ChannelID, ThreadID: row.ThreadID,
|
|
},
|
|
}, row.Media))
|
|
}
|
|
return out
|
|
}
|
|
|
|
// stripMediaBytes returns attachments without their in-memory bytes.
|
|
func stripMediaBytes(media []messaging.MediaAttachment) []messaging.MediaAttachment {
|
|
if len(media) == 0 {
|
|
return nil
|
|
}
|
|
stripped := make([]messaging.MediaAttachment, len(media))
|
|
for i, att := range media {
|
|
stripped[i] = att
|
|
stripped[i].Data = nil
|
|
}
|
|
return stripped
|
|
}
|
|
|
|
// marshalMediaMeta serialises a message's attachment metadata for the
|
|
// database JSON column.
|
|
func marshalMediaMeta(media []messaging.MediaAttachment) ([]byte, error) {
|
|
if len(media) == 0 {
|
|
return []byte("[]"), nil
|
|
}
|
|
encoded, err := json.Marshal(stripMediaBytes(media))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sessionstore: marshal message media: %w", err)
|
|
}
|
|
return encoded, nil
|
|
}
|
|
|
|
// unmarshalMediaMeta decodes the media JSON column a message row carries.
|
|
func unmarshalMediaMeta(raw string) ([]messaging.MediaAttachment, error) {
|
|
if raw == "" || raw == "[]" {
|
|
return nil, nil
|
|
}
|
|
var media []messaging.MediaAttachment
|
|
if err := json.Unmarshal([]byte(raw), &media); err != nil {
|
|
return nil, fmt.Errorf("sessionstore: unmarshal message media: %w", err)
|
|
}
|
|
return media, nil
|
|
}
|
|
|
|
// rowMessage attaches a message row's decoded media to its base record;
|
|
// a row's media column can only fail to decode through corruption, which
|
|
// is surfaced rather than silently dropping the attachments.
|
|
func rowMessage(base messaging.Message, mediaRaw string) messaging.Message {
|
|
media, err := unmarshalMediaMeta(mediaRaw)
|
|
if err != nil {
|
|
base.Text += " [unreadable media metadata]"
|
|
return base
|
|
}
|
|
base.Media = media
|
|
return base
|
|
}
|
|
|
|
// SearchMessages full-text searches a session's message text and sender with
|
|
// plainto_tsquery. Truncated is always false.
|
|
func (s *postgresSessionStore) SearchMessages(ctx context.Context, sessionID string, q MessageQuery) (MessagePage, error) {
|
|
if err := s.mayRead(ctx, sessionID); err != nil {
|
|
return MessagePage{}, err
|
|
}
|
|
query := strings.TrimSpace(q.Query)
|
|
if query == "" {
|
|
return MessagePage{}, nil
|
|
}
|
|
if len(query) > MaxMessageSearchQueryBytes {
|
|
return MessagePage{}, fmt.Errorf("sessionstore: search query exceeds %d bytes", MaxMessageSearchQueryBytes)
|
|
}
|
|
if terms := len(strings.Fields(query)); terms > MaxMessageSearchQueryTerms {
|
|
return MessagePage{}, fmt.Errorf("sessionstore: search query exceeds %d terms", MaxMessageSearchQueryTerms)
|
|
}
|
|
limit := q.Limit
|
|
if limit <= 0 {
|
|
limit = DefaultMessagePageSize
|
|
}
|
|
limit = min(limit, MaxMessagePageSize)
|
|
offset := max(q.Offset, 0)
|
|
|
|
dbq := postgresdb.New(s.pool)
|
|
total, err := dbq.SearchMessagesCount(ctx, postgresdb.SearchMessagesCountParams{
|
|
SessionID: sessionID, PlaintoTsquery: query,
|
|
})
|
|
if err != nil {
|
|
return MessagePage{}, fmt.Errorf("sessionstore: search messages: count: %w", err)
|
|
}
|
|
if offset >= int(total) {
|
|
return MessagePage{}, nil
|
|
}
|
|
|
|
rows, err := dbq.SearchMessagesPage(ctx, postgresdb.SearchMessagesPageParams{
|
|
SessionID: sessionID, PlaintoTsquery: query, Limit: int32(limit), Offset: int32(offset),
|
|
})
|
|
if err != nil {
|
|
return MessagePage{}, fmt.Errorf("sessionstore: search messages: %w", err)
|
|
}
|
|
|
|
msgs := make([]messaging.Message, 0, len(rows))
|
|
for _, row := range rows {
|
|
msgs = append(msgs, rowMessage(messaging.Message{
|
|
ID: messaging.MessageID(row.MessageID),
|
|
SourceID: row.SourceID,
|
|
Sender: row.Sender,
|
|
SenderID: row.SenderID,
|
|
Role: messaging.Role(row.Role),
|
|
Text: row.Text,
|
|
At: time.UnixMilli(row.Ts).UTC(),
|
|
ConversationID: messaging.ConversationID{
|
|
ChannelID: row.ChannelID, ThreadID: row.ThreadID,
|
|
},
|
|
}, row.Media))
|
|
}
|
|
|
|
next := offset + len(msgs)
|
|
return MessagePage{
|
|
Messages: msgs,
|
|
NextOffset: next,
|
|
HasMore: next < int(total),
|
|
Truncated: false,
|
|
}, nil
|
|
}
|
|
|
|
// ── Turns ───────────────────────────────────────────────────────────────────
|
|
|
|
func (s *postgresSessionStore) ClaimTurn(ctx context.Context, initial TurnRecord) (TurnRecord, TurnClaim, error) {
|
|
initial, initialToolCalls, err := prepareInitialTurn(initial, time.Now().UTC())
|
|
if err != nil {
|
|
return TurnRecord{}, "", err
|
|
}
|
|
if err := s.mayWrite(ctx, initial.SessionID); err != nil {
|
|
return TurnRecord{}, "", err
|
|
}
|
|
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return TurnRecord{}, "", fmt.Errorf("sessionstore: claim turn: begin: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
|
|
q := postgresdb.New(tx)
|
|
inserted, err := insertInitialTurnPG(ctx, q, initial, initialToolCalls)
|
|
if err != nil {
|
|
return TurnRecord{}, "", err
|
|
}
|
|
if inserted {
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return TurnRecord{}, "", fmt.Errorf("sessionstore: claim turn: commit: %w", err)
|
|
}
|
|
return initial, TurnClaimOwned, nil
|
|
}
|
|
|
|
turn, err := q.TurnByID(ctx, initial.TurnID)
|
|
if err != nil {
|
|
return TurnRecord{}, "", fmt.Errorf("sessionstore: read turn: %w", err)
|
|
}
|
|
record, err := turnFromRow(turn)
|
|
if err != nil {
|
|
return TurnRecord{}, "", err
|
|
}
|
|
return claimExistingTurnPG(ctx, q, tx, record, initial)
|
|
}
|
|
|
|
func insertInitialTurnPG(ctx context.Context, q *postgresdb.Queries, initial TurnRecord, toolCallsJSON string) (bool, error) {
|
|
affected, err := q.InsertTurn(ctx, postgresdb.InsertTurnParams{
|
|
TurnID: initial.TurnID,
|
|
SessionID: initial.SessionID,
|
|
SourceID: initial.SourceID,
|
|
Status: string(initial.Status),
|
|
Attempt: int64(initial.Attempt),
|
|
OwnerID: initial.OwnerID,
|
|
InputMessageID: initial.InputMessageID,
|
|
AssistantMessageID: initial.AssistantMessageID,
|
|
PartialText: initial.PartialText,
|
|
ResponseText: initial.ResponseText,
|
|
ToolCalls: toolCallsJSON,
|
|
Error: initial.Error,
|
|
CreatedAt: initial.CreatedAt.UnixMilli(),
|
|
UpdatedAt: initial.UpdatedAt.UnixMilli(),
|
|
})
|
|
if err != nil {
|
|
return false, fmt.Errorf("sessionstore: claim turn: insert: %w", err)
|
|
}
|
|
return affected == 1, nil
|
|
}
|
|
|
|
func claimExistingTurnPG(ctx context.Context, q *postgresdb.Queries, tx pgx.Tx, turn, initial TurnRecord) (TurnRecord, TurnClaim, error) {
|
|
switch turn.Status {
|
|
case TurnStatusCompleted:
|
|
return turn, TurnClaimCompleted, nil
|
|
case TurnStatusAccepted, TurnStatusRunning, TurnStatusPartial:
|
|
return turn, TurnClaimInProgress, nil
|
|
case TurnStatusFailed, TurnStatusCancelled:
|
|
if turn.AssistantMessageID != "" {
|
|
affected, err := q.FinalizeTurn(ctx, postgresdb.FinalizeTurnParams{
|
|
TurnID: turn.TurnID,
|
|
Status: string(TurnStatusCompleted),
|
|
Error: "",
|
|
UpdatedAt: time.Now().UTC().UnixMilli(),
|
|
Attempt: int64(turn.Attempt),
|
|
OwnerID: turn.OwnerID,
|
|
})
|
|
if err != nil {
|
|
return TurnRecord{}, "", fmt.Errorf("sessionstore: finalize turn: %w", err)
|
|
}
|
|
if affected != 1 {
|
|
return TurnRecord{}, "", fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID)
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return TurnRecord{}, "", fmt.Errorf("sessionstore: finalize turn: commit: %w", err)
|
|
}
|
|
turn.Status = TurnStatusCompleted
|
|
turn.Error = ""
|
|
return turn, TurnClaimCompleted, nil
|
|
}
|
|
oldOwner, oldAttempt := turn.OwnerID, turn.Attempt
|
|
turn.Status = TurnStatusRunning
|
|
turn.Attempt++
|
|
turn.OwnerID = initial.OwnerID
|
|
turn.Error = ""
|
|
turn.UpdatedAt = time.Now().UTC()
|
|
affected, err := q.RetryTurn(ctx, postgresdb.RetryTurnParams{
|
|
TurnID: turn.TurnID,
|
|
Status: string(turn.Status),
|
|
Attempt: int64(turn.Attempt),
|
|
OwnerID: turn.OwnerID,
|
|
Error: turn.Error,
|
|
UpdatedAt: turn.UpdatedAt.UnixMilli(),
|
|
Attempt_2: int64(oldAttempt),
|
|
OwnerID_2: oldOwner,
|
|
})
|
|
if err != nil {
|
|
return TurnRecord{}, "", fmt.Errorf("sessionstore: retry turn: %w", err)
|
|
}
|
|
if affected != 1 {
|
|
return TurnRecord{}, "", fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID)
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return TurnRecord{}, "", fmt.Errorf("sessionstore: retry turn: commit: %w", err)
|
|
}
|
|
return turn, TurnClaimOwned, nil
|
|
default:
|
|
return turn, TurnClaimInProgress, nil
|
|
}
|
|
}
|
|
|
|
func (s *postgresSessionStore) RecoverTurns(ctx context.Context, ownerID string) error {
|
|
if ownerID == "" {
|
|
return fmt.Errorf("sessionstore: recovery owner ID is required")
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
err := q.RecoverTurns(ctx, postgresdb.RecoverTurnsParams{
|
|
UpdatedAt: time.Now().UTC().UnixMilli(), OwnerID: ownerID,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: recover turns: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) GetTurn(ctx context.Context, turnID string) (TurnRecord, bool, error) {
|
|
if turnID == "" {
|
|
return TurnRecord{}, false, nil
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
turn, err := q.TurnByID(ctx, turnID)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return TurnRecord{}, false, nil
|
|
}
|
|
if err != nil {
|
|
return TurnRecord{}, false, fmt.Errorf("sessionstore: get turn: %w", err)
|
|
}
|
|
record, err := turnFromRow(turn)
|
|
if err != nil {
|
|
return TurnRecord{}, false, err
|
|
}
|
|
if err := s.mayRead(ctx, record.SessionID); errors.Is(err, ErrSessionNotFound) {
|
|
return TurnRecord{}, false, nil
|
|
} else if err != nil {
|
|
return TurnRecord{}, false, err
|
|
}
|
|
return record, true, nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) RecentTurns(ctx context.Context, sessionID string, n int) ([]TurnRecord, error) {
|
|
if err := s.mayRead(ctx, sessionID); err != nil {
|
|
return nil, err
|
|
}
|
|
if n <= 0 {
|
|
return []TurnRecord{}, nil
|
|
}
|
|
if n > 500 {
|
|
n = 500
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
rows, err := q.RecentTurns(ctx, postgresdb.RecentTurnsParams{
|
|
SessionID: sessionID, Limit: int32(n),
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sessionstore: recent turns: %w", err)
|
|
}
|
|
// RecentTurns orders newest-first; the contract returns oldest-first.
|
|
out := make([]TurnRecord, 0, len(rows))
|
|
for _, row := range slices.Backward(rows) {
|
|
record, err := turnFromRow(row)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, record)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) SaveTurn(ctx context.Context, turn TurnRecord) error {
|
|
if turn.TurnID == "" {
|
|
return fmt.Errorf("sessionstore: turn ID is required")
|
|
}
|
|
if err := s.mayWrite(ctx, turn.SessionID); err != nil {
|
|
return err
|
|
}
|
|
q := postgresdb.New(s.pool)
|
|
current, err := q.TurnAttemptOwner(ctx, turn.TurnID)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return fmt.Errorf("sessionstore: save turn: turn not found")
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: save turn: read: %w", err)
|
|
}
|
|
if int(current.Attempt) != turn.Attempt || current.OwnerID != turn.OwnerID {
|
|
return fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID)
|
|
}
|
|
if turn.UpdatedAt.IsZero() {
|
|
turn.UpdatedAt = time.Now().UTC()
|
|
}
|
|
toolCallsJSON, err := marshalToolCalls(turn.ToolCalls)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, err := q.SaveTurn(ctx, postgresdb.SaveTurnParams{
|
|
TurnID: turn.TurnID,
|
|
SessionID: turn.SessionID,
|
|
SourceID: turn.SourceID,
|
|
Status: string(turn.Status),
|
|
Attempt: int64(turn.Attempt),
|
|
OwnerID: turn.OwnerID,
|
|
InputMessageID: turn.InputMessageID,
|
|
AssistantMessageID: turn.AssistantMessageID,
|
|
PartialText: turn.PartialText,
|
|
ResponseText: turn.ResponseText,
|
|
ToolCalls: toolCallsJSON,
|
|
Error: turn.Error,
|
|
CreatedAt: turn.CreatedAt.UnixMilli(),
|
|
UpdatedAt: turn.UpdatedAt.UnixMilli(),
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("sessionstore: save turn: %w", err)
|
|
}
|
|
if affected != 1 {
|
|
return fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *postgresSessionStore) ListRecoverableTurns(ctx context.Context) ([]TurnRecord, error) {
|
|
q := postgresdb.New(s.pool)
|
|
rows, err := q.ListRecoverableTurns(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("sessionstore: list recoverable turns: %w", err)
|
|
}
|
|
out := make([]TurnRecord, 0, len(rows))
|
|
for _, row := range rows {
|
|
record, err := turnFromRow(row)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, record)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func turnFromRow(row postgresdb.Turn) (TurnRecord, error) {
|
|
toolCalls, err := unmarshalToolCalls(row.ToolCalls)
|
|
if err != nil {
|
|
return TurnRecord{}, err
|
|
}
|
|
return TurnRecord{
|
|
TurnID: row.TurnID,
|
|
SessionID: row.SessionID,
|
|
SourceID: row.SourceID,
|
|
Status: TurnStatus(row.Status),
|
|
Attempt: int(row.Attempt),
|
|
OwnerID: row.OwnerID,
|
|
InputMessageID: row.InputMessageID,
|
|
AssistantMessageID: row.AssistantMessageID,
|
|
PartialText: row.PartialText,
|
|
ResponseText: row.ResponseText,
|
|
ToolCalls: toolCalls,
|
|
Error: row.Error,
|
|
CreatedAt: time.UnixMilli(row.CreatedAt).UTC(),
|
|
UpdatedAt: time.UnixMilli(row.UpdatedAt).UTC(),
|
|
}, nil
|
|
}
|
|
|
|
// ErrSessionNotFound is a session the caller's org does not own. Another
|
|
// org's session is indistinguishable from one that does not exist.
|
|
var ErrSessionNotFound = errors.New("sessionstore: session not found")
|
|
|
|
func callerOrg(ctx context.Context) string { return string(org.OrgFromContext(ctx)) }
|
|
|
|
// mayRead allows a read of sessionID when the caller's org owns it. Messages
|
|
// with no session row predate orgs and belong to the system org.
|
|
func (s *postgresSessionStore) mayRead(ctx context.Context, sessionID string) error {
|
|
owner, err := postgresdb.New(s.pool).SessionOrg(ctx, sessionID)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
owner = string(org.DefaultOrgID)
|
|
} else if err != nil {
|
|
return fmt.Errorf("sessionstore: session org: %w", err)
|
|
}
|
|
if _, ok := access.PrincipalFromContext(ctx); ok {
|
|
session, err := s.Get(ctx, sessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if session == nil {
|
|
return ErrSessionNotFound
|
|
}
|
|
}
|
|
if owner != callerOrg(ctx) {
|
|
return ErrSessionNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// mayWrite allows a write to sessionID when the caller's org owns it, making
|
|
// the caller's org the owner of a session nobody has written yet.
|
|
func (s *postgresSessionStore) mayWrite(ctx context.Context, sessionID string) error {
|
|
q := postgresdb.New(s.pool)
|
|
if err := q.ClaimSession(ctx, postgresdb.ClaimSessionParams{SessionID: sessionID, OrgID: callerOrg(ctx)}); err != nil {
|
|
return fmt.Errorf("sessionstore: claim session: %w", err)
|
|
}
|
|
return s.mayRead(ctx, sessionID)
|
|
}
|
|
|
|
// Service-owned curation has no person principal. Signed-in callers only
|
|
// see their own web conversations, including through tools and slash commands.
|
|
// The Messaging Service speaks for an org's agent and sees that org's channel
|
|
// conversations, never a person's web ones.
|
|
func sessionVisible(ctx context.Context, session SessionContext) bool {
|
|
p, ok := access.PrincipalFromContext(ctx)
|
|
if !ok {
|
|
return true
|
|
}
|
|
if access.SourceFromContext(ctx) == presence.Messaging {
|
|
return session.Source.Platform != "web"
|
|
}
|
|
return session.Source.Platform == "web" && session.Source.ThreadID == string(p.IdentityID)
|
|
}
|
|
|
|
func visibleSessions(ctx context.Context, sessions []SessionContext) []SessionContext {
|
|
return slices.DeleteFunc(sessions, func(session SessionContext) bool { return !sessionVisible(ctx, session) })
|
|
}
|