Files
mtusi2026lab4/internal/transport/rest/handler.go
T
2026-10-21 21:22:42 +03:00

407 lines
9.5 KiB
Go

package rest
import (
"bytes"
"context"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"fmt"
"net/http"
"time"
"github.com/google/uuid"
"mtusi-messenger/internal/domain"
"mtusi-messenger/internal/transport/rest/internal/oas"
)
type UserService interface {
Register(ctx context.Context, draft domain.UserDraft) (domain.User, error)
GetByID(ctx context.Context, id uuid.UUID) (domain.User, error)
}
type ChatService interface {
Create(ctx context.Context, draft domain.ChatDraft) (domain.Chat, error)
Get(ctx context.Context, callerID, chatID uuid.UUID) (domain.Chat, error)
List(
ctx context.Context,
callerID uuid.UUID,
after *domain.Cursor,
limit int,
) (domain.Page[domain.Chat], error)
}
type MessageService interface {
Send(ctx context.Context, draft domain.MessageDraft) (domain.Message, error)
History(
ctx context.Context,
callerID, chatID uuid.UUID,
after *domain.Cursor,
limit int,
) (domain.Page[domain.Message], error)
}
type HealthChecker interface {
Ping(ctx context.Context) error
}
type SessionService interface {
Create(ctx context.Context, user domain.User) (domain.Session, error)
Revoke(ctx context.Context, userID uuid.UUID, token string) error
}
type Handler struct {
oas.UnimplementedHandler
users UserService
chats ChatService
messages MessageService
health HealthChecker
sessions SessionService
}
var noCursor *domain.Cursor
func NewHandler(
users UserService,
chats ChatService,
messages MessageService,
health HealthChecker,
sessions SessionService,
) *Handler {
return &Handler{
users: users,
chats: chats,
messages: messages,
health: health,
sessions: sessions,
}
}
func (h *Handler) CreateSession(ctx context.Context) (oas.CreateSessionRes, error) {
user, ok := ctx.Value(credentialsKey{}).(domain.User)
if !ok {
return nil, domain.ErrUnauthenticated
}
created, err := h.sessions.Create(ctx, user)
if err != nil {
return nil, err
}
return &oas.SessionHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: oas.Session{
Token: created.Token, TokenType: "Bearer", ExpiresAt: created.ExpiresAt, User: userResponse(created.User),
},
}, nil
}
func (h *Handler) RevokeSession(ctx context.Context) (oas.RevokeSessionRes, error) {
token, ok := ctx.Value(tokenKey{}).(string)
if !ok {
return nil, domain.ErrUnauthenticated
}
if err := h.sessions.Revoke(ctx, caller(ctx), token); err != nil {
return nil, err
}
return &oas.RevokeSessionNoContent{XRequestID: oas.NewOptString(requestIDFromContext(ctx))}, nil
}
func (h *Handler) Liveness(ctx context.Context) (oas.LivenessRes, error) {
return &oas.HealthHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: oas.Health{Status: oas.HealthStatusOk},
}, nil
}
func (h *Handler) Readiness(ctx context.Context) (oas.ReadinessRes, error) {
if h.health == nil || h.health.Ping(ctx) == nil {
return &oas.HealthHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: oas.Health{Status: oas.HealthStatusOk},
}, nil
}
requestID := requestIDFromContext(ctx)
return &oas.ReadinessServiceUnavailable{
XRequestID: oas.NewOptString(requestID),
Response: oas.Error{Error: oas.ErrorError{
Code: oas.ErrorErrorCodeUnavailable,
Message: http.StatusText(http.StatusServiceUnavailable),
RequestID: requestID,
}},
}, nil
}
func (h *Handler) RegisterUser(ctx context.Context, req *oas.CreateUser) (oas.RegisterUserRes, error) {
user, err := h.users.Register(ctx, domain.UserDraft{
Username: req.Username,
DisplayName: req.DisplayName,
Password: req.Password,
})
if err != nil {
return nil, err
}
return &oas.UserHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: userResponse(user),
}, nil
}
func (h *Handler) CurrentUser(ctx context.Context) (oas.CurrentUserRes, error) {
callerID := caller(ctx)
user, err := h.users.GetByID(ctx, callerID)
if err != nil {
return nil, err
}
return &oas.UserHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: userResponse(user),
}, nil
}
func (h *Handler) CreateChat(ctx context.Context, req *oas.CreateChat) (oas.CreateChatRes, error) {
callerID := caller(ctx)
chat, err := h.chats.Create(ctx, domain.ChatDraft{
Title: req.Title,
MemberIDs: req.MemberIds,
CallerID: callerID,
})
if err != nil {
return nil, err
}
return &oas.ChatHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: chatResponse(chat),
}, nil
}
func (h *Handler) GetChat(ctx context.Context, params oas.GetChatParams) (oas.GetChatRes, error) {
callerID := caller(ctx)
chat, err := h.chats.Get(ctx, callerID, params.ChatID)
if err != nil {
return nil, err
}
return &oas.ChatHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: chatResponse(chat),
}, nil
}
func (h *Handler) ListChats(ctx context.Context, params oas.ListChatsParams) (oas.ListChatsRes, error) {
callerID := caller(ctx)
after, err := parseCursor(params.Cursor)
if err != nil {
return nil, err
}
page, err := h.chats.List(ctx, callerID, after, limitOrDefault(params.Limit))
if err != nil {
return nil, err
}
items := make([]oas.Chat, 0, len(page.Items))
for _, chat := range page.Items {
items = append(items, chatResponse(chat))
}
return &oas.ChatPageHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: oas.ChatPage{
Items: items,
NextCursor: encodeCursor(page.Next),
},
}, nil
}
func (h *Handler) CreateMessage(
ctx context.Context,
req *oas.CreateMessage,
params oas.CreateMessageParams,
) (oas.CreateMessageRes, error) {
callerID := caller(ctx)
fingerprint, err := messageFingerprint(req)
if err != nil {
return nil, err
}
message, err := h.messages.Send(ctx, domain.MessageDraft{
ChatID: params.ChatID,
SenderID: callerID,
Text: req.Text,
Idempotency: domain.MessageIdempotency{
Key: params.IdempotencyKey,
RequestHash: fingerprint,
},
})
if err != nil {
return nil, err
}
return &oas.MessageHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: messageResponse(message),
}, nil
}
// messageFingerprint canonicalises the create-message payload so that the key
// order of the client JSON cannot change the fingerprint, while a different
// payload with the same Idempotency-Key can (contract 1.3.0).
func messageFingerprint(req *oas.CreateMessage) ([sha256.Size]byte, error) {
payload, err := json.Marshal(struct {
Text string `json:"text"`
}{Text: req.Text})
if err != nil {
return [sha256.Size]byte{}, fmt.Errorf("encode message payload: %w", err)
}
return sha256.Sum256(payload), nil
}
func (h *Handler) ListMessages(ctx context.Context, params oas.ListMessagesParams) (oas.ListMessagesRes, error) {
callerID := caller(ctx)
after, err := parseCursor(params.Cursor)
if err != nil {
return nil, err
}
page, err := h.messages.History(ctx, callerID, params.ChatID, after, limitOrDefault(params.Limit))
if err != nil {
return nil, err
}
items := make([]oas.Message, 0, len(page.Items))
for _, message := range page.Items {
items = append(items, messageResponse(message))
}
return &oas.MessagePageHeaders{
XRequestID: oas.NewOptString(requestIDFromContext(ctx)),
Response: oas.MessagePage{
Items: items,
NextCursor: encodeCursor(page.Next),
},
}, nil
}
func parseCursor(raw oas.OptString) (*domain.Cursor, error) {
encoded, ok := raw.Get()
if !ok {
return noCursor, nil
}
cursor, err := decodeCursor(encoded)
if err != nil {
return nil, err
}
return &cursor, nil
}
func encodeCursor(next *domain.Cursor) oas.NilString {
var out oas.NilString
if next == nil {
out.SetToNull()
return out
}
out.SetTo(encodeCursorValue(*next))
return out
}
type cursorWire struct {
Scope uuid.UUID `json:"scope"`
CreatedAt time.Time `json:"created_at"`
ID uuid.UUID `json:"id"`
}
func encodeCursorValue(cursor domain.Cursor) string {
payload, err := json.Marshal(cursorWire{
Scope: cursor.Scope,
CreatedAt: cursor.CreatedAt.UTC(),
ID: cursor.ID,
})
if err != nil {
return ""
}
return base64.RawURLEncoding.EncodeToString(payload)
}
func decodeCursor(encoded string) (domain.Cursor, error) {
payload, err := base64.RawURLEncoding.DecodeString(encoded)
if err != nil {
return domain.Cursor{}, fmt.Errorf("decode cursor: %w", domain.ErrInvalidCursor)
}
decoder := json.NewDecoder(bytes.NewReader(payload))
decoder.DisallowUnknownFields()
var wire cursorWire
if err := decoder.Decode(&wire); err != nil {
return domain.Cursor{}, fmt.Errorf("parse cursor: %w", domain.ErrInvalidCursor)
}
if wire.ID == uuid.Nil {
return domain.Cursor{}, fmt.Errorf("cursor id is empty: %w", domain.ErrInvalidCursor)
}
return domain.Cursor{
Scope: wire.Scope,
CreatedAt: wire.CreatedAt.UTC(),
ID: wire.ID,
}, nil
}
func limitOrDefault(limit oas.OptInt) int {
if value, ok := limit.Get(); ok {
return value
}
return domain.DefaultPageLimit
}
func userResponse(user domain.User) oas.User {
return oas.User{
ID: user.ID,
Username: user.Username,
DisplayName: user.DisplayName,
CreatedAt: user.CreatedAt,
}
}
func chatResponse(chat domain.Chat) oas.Chat {
return oas.Chat{
ID: chat.ID,
Title: chat.Title,
MemberIds: chat.MemberIDs,
CreatedAt: chat.CreatedAt,
}
}
func messageResponse(message domain.Message) oas.Message {
return oas.Message{
ID: message.ID,
ChatID: message.ChatID,
SenderID: message.SenderID,
Text: message.Text,
CreatedAt: message.CreatedAt,
}
}