407 lines
9.5 KiB
Go
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,
|
|
}
|
|
}
|