chore: port lab 2 solution
This commit is contained in:
+6
-6
@@ -1,13 +1,13 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
MAX_INFLIGHT_REQUESTS=0
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
|
||||
LOG_LEVEL=INFO
|
||||
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
FROM golang:1.27.1 AS build
|
||||
WORKDIR /src
|
||||
|
||||
COPY go.mod go.sum ./
|
||||
RUN go mod download
|
||||
|
||||
COPY . .
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -o /out/server ./cmd/server
|
||||
|
||||
FROM gcr.io/distroless/static-debian12:nonroot
|
||||
WORKDIR /app
|
||||
COPY --from=build /out/server .
|
||||
COPY contracts ./contracts
|
||||
COPY web/swagger ./web/swagger
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD ["/app/server", "healthcheck"]
|
||||
|
||||
ENTRYPOINT ["/app/server"]
|
||||
@@ -0,0 +1,8 @@
|
||||
FROM golang:1.27.1-alpine3.24 AS build
|
||||
ENV CGO_ENABLED=0
|
||||
RUN go install github.com/pressly/goose/v3/cmd/goose@v3.28.0
|
||||
|
||||
FROM alpine:3.24
|
||||
COPY --from=build /go/bin/goose /usr/local/bin/goose
|
||||
COPY db/migrations /migrations
|
||||
ENTRYPOINT ["sh", "-c", "goose -dir /migrations postgres \"$(cat /run/secrets/database_url)\" up"]
|
||||
@@ -28,3 +28,5 @@ test-persistence:
|
||||
test-failover:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
-include student.mk
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"log"
|
||||
"os"
|
||||
|
||||
"mtusi2026-messenger/internal/app"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if len(os.Args) > 1 && os.Args[1] == "healthcheck" {
|
||||
os.Exit(app.Healthcheck())
|
||||
}
|
||||
|
||||
if err := app.Run(); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
-- +goose Up
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL UNIQUE
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name text NOT NULL
|
||||
CONSTRAINT users_display_name_not_blank CHECK (display_name ~ '\S'),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash text PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
expires_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX idx_sessions_expires_at ON sessions (expires_at);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL
|
||||
CONSTRAINT chats_title_not_blank CHECK (title ~ '\S'),
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE INDEX idx_chat_members_user_id ON chat_members (user_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT,
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE INDEX idx_messages_chat_history ON messages (chat_id, created_at, id);
|
||||
|
||||
-- +goose Down
|
||||
DROP TABLE messages;
|
||||
DROP TABLE chat_members;
|
||||
DROP TABLE chats;
|
||||
DROP TABLE sessions;
|
||||
DROP TABLE users;
|
||||
@@ -0,0 +1,73 @@
|
||||
-- name: CreateChat :one
|
||||
INSERT INTO chats (
|
||||
id,
|
||||
title
|
||||
) VALUES (
|
||||
sqlc.arg(id),
|
||||
sqlc.arg(title)
|
||||
)
|
||||
RETURNING *;
|
||||
|
||||
-- name: AddChatMembers :exec
|
||||
INSERT INTO chat_members (
|
||||
chat_id,
|
||||
user_id
|
||||
)
|
||||
SELECT
|
||||
sqlc.arg(chat_id)::uuid,
|
||||
unnest(sqlc.arg(user_ids)::uuid[]);
|
||||
|
||||
-- name: IsChatMember :one
|
||||
SELECT EXISTS (
|
||||
SELECT 1 FROM chat_members
|
||||
WHERE chat_id = sqlc.arg(chat_id)
|
||||
AND user_id = sqlc.arg(user_id)
|
||||
);
|
||||
|
||||
-- name: GetChat :one
|
||||
SELECT
|
||||
c.*,
|
||||
ARRAY(
|
||||
SELECT cm.user_id FROM chat_members cm
|
||||
WHERE cm.chat_id = c.id
|
||||
ORDER BY cm.user_id
|
||||
)::uuid[] AS member_ids
|
||||
FROM chats c
|
||||
WHERE c.id = sqlc.arg(id)
|
||||
AND EXISTS (
|
||||
SELECT 1 FROM chat_members m
|
||||
WHERE m.chat_id = c.id
|
||||
AND m.user_id = sqlc.arg(user_id)
|
||||
);
|
||||
|
||||
-- name: ListChatsFirstPage :many
|
||||
SELECT
|
||||
c.*,
|
||||
ARRAY(
|
||||
SELECT cm.user_id FROM chat_members cm
|
||||
WHERE cm.chat_id = c.id
|
||||
ORDER BY cm.user_id
|
||||
)::uuid[] AS member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members m ON m.chat_id = c.id
|
||||
WHERE m.user_id = sqlc.arg(user_id)
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT sqlc.arg(lim);
|
||||
|
||||
-- name: ListChatsAfter :many
|
||||
SELECT
|
||||
c.*,
|
||||
ARRAY(
|
||||
SELECT cm.user_id FROM chat_members cm
|
||||
WHERE cm.chat_id = c.id
|
||||
ORDER BY cm.user_id
|
||||
)::uuid[] AS member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members m ON m.chat_id = c.id
|
||||
WHERE m.user_id = sqlc.arg(user_id)
|
||||
AND (c.created_at, c.id) > (
|
||||
sqlc.arg(after_created_at)::timestamptz,
|
||||
sqlc.arg(after_id)::uuid
|
||||
)
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT sqlc.arg(lim);
|
||||
@@ -0,0 +1,34 @@
|
||||
-- name: CreateMessage :one
|
||||
INSERT INTO messages (
|
||||
id,
|
||||
chat_id,
|
||||
sender_id,
|
||||
text
|
||||
)
|
||||
SELECT
|
||||
sqlc.arg(id)::uuid,
|
||||
sqlc.arg(chat_id)::uuid,
|
||||
sqlc.arg(sender_id)::uuid,
|
||||
sqlc.arg(text)::text
|
||||
WHERE EXISTS (
|
||||
SELECT 1 FROM chat_members
|
||||
WHERE chat_id = sqlc.arg(chat_id)
|
||||
AND user_id = sqlc.arg(sender_id)
|
||||
)
|
||||
RETURNING *;
|
||||
|
||||
-- name: ListMessagesFirstPage :many
|
||||
SELECT * FROM messages
|
||||
WHERE chat_id = sqlc.arg(chat_id)
|
||||
ORDER BY created_at, id
|
||||
LIMIT sqlc.arg(lim);
|
||||
|
||||
-- name: ListMessagesAfter :many
|
||||
SELECT * FROM messages
|
||||
WHERE chat_id = sqlc.arg(chat_id)
|
||||
AND (created_at, id) > (
|
||||
sqlc.arg(after_created_at)::timestamptz,
|
||||
sqlc.arg(after_id)::uuid
|
||||
)
|
||||
ORDER BY created_at, id
|
||||
LIMIT sqlc.arg(lim);
|
||||
@@ -0,0 +1,24 @@
|
||||
-- name: CreateSession :exec
|
||||
INSERT INTO sessions (
|
||||
token_hash,
|
||||
user_id,
|
||||
expires_at
|
||||
) VALUES (
|
||||
sqlc.arg(token_hash),
|
||||
sqlc.arg(user_id),
|
||||
sqlc.arg(expires_at)
|
||||
);
|
||||
|
||||
-- name: GetActiveSession :one
|
||||
SELECT user_id, expires_at FROM sessions
|
||||
WHERE token_hash = sqlc.arg(token_hash)
|
||||
AND expires_at > now();
|
||||
|
||||
-- name: DeleteSession :execrows
|
||||
DELETE FROM sessions
|
||||
WHERE token_hash = sqlc.arg(token_hash)
|
||||
AND expires_at > now();
|
||||
|
||||
-- name: DeleteExpiredSessions :execrows
|
||||
DELETE FROM sessions
|
||||
WHERE expires_at <= now();
|
||||
@@ -0,0 +1,21 @@
|
||||
-- name: CreateUser :one
|
||||
INSERT INTO users (
|
||||
id,
|
||||
username,
|
||||
display_name,
|
||||
password_hash
|
||||
) VALUES (
|
||||
sqlc.arg(id),
|
||||
sqlc.arg(username),
|
||||
sqlc.arg(display_name),
|
||||
sqlc.arg(password_hash)
|
||||
)
|
||||
RETURNING id, username, display_name, created_at;
|
||||
|
||||
-- name: GetUser :one
|
||||
SELECT id, username, display_name, created_at FROM users
|
||||
WHERE id = sqlc.arg(id);
|
||||
|
||||
-- name: GetUserByUsername :one
|
||||
SELECT * FROM users
|
||||
WHERE username = sqlc.arg(username);
|
||||
@@ -0,0 +1,68 @@
|
||||
services:
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
image: mtusi-messenger:lab2
|
||||
ports:
|
||||
- "127.0.0.1:8080:${APP_PORT}"
|
||||
env_file:
|
||||
- .env
|
||||
secrets:
|
||||
- database_url
|
||||
- cache_url
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
restart: unless-stopped
|
||||
|
||||
postgres:
|
||||
image: postgres:18.6
|
||||
ports:
|
||||
- "127.0.0.1:5432:5432"
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets:
|
||||
- postgres_password
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -h 127.0.0.1 -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
migrate:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile.migrate
|
||||
secrets:
|
||||
- database_url
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
|
||||
redis:
|
||||
image: redis:8.8.3-alpine3.23
|
||||
command: ["redis-server", "--save", "", "--appendonly", "no"]
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password.txt
|
||||
database_url:
|
||||
file: ./secrets/database_url.txt
|
||||
cache_url:
|
||||
file: ./secrets/cache_url.txt
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,23 @@
|
||||
module mtusi2026-messenger
|
||||
|
||||
go 1.26.0
|
||||
|
||||
require (
|
||||
github.com/go-chi/chi/v5 v5.5.0
|
||||
github.com/google/uuid v1.6.0
|
||||
github.com/jackc/pgx/v5 v5.11.0
|
||||
github.com/joho/godotenv v1.5.1
|
||||
github.com/redis/go-redis/v9 v9.23.0
|
||||
golang.org/x/crypto v0.58.0
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/cespare/xxhash/v2 v2.3.0 // indirect
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.2 // indirect
|
||||
go.uber.org/atomic v1.12.0 // indirect
|
||||
golang.org/x/sync v0.24.0 // indirect
|
||||
golang.org/x/sys v0.49.0 // indirect
|
||||
golang.org/x/text v0.43.0 // indirect
|
||||
)
|
||||
@@ -0,0 +1,47 @@
|
||||
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
|
||||
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
|
||||
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
|
||||
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
|
||||
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
|
||||
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/go-chi/chi/v5 v5.5.0 h1:xdKQ1dJmVJsmgahrXSKhUx8NyVPzpwdlyrrQFpMPJgg=
|
||||
github.com/go-chi/chi/v5 v5.5.0/go.mod h1:d1IG7GtKPSjPyBP365PH8sAGVHk3qfB/IhjFNRH1wWM=
|
||||
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
|
||||
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||
github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg=
|
||||
github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
|
||||
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
|
||||
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
|
||||
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
|
||||
github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
|
||||
github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s=
|
||||
github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
|
||||
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
|
||||
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
|
||||
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
|
||||
go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE=
|
||||
go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk=
|
||||
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
|
||||
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
|
||||
golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
|
||||
golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
|
||||
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
|
||||
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
|
||||
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
|
||||
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
|
||||
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
@@ -0,0 +1,123 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/joho/godotenv"
|
||||
|
||||
"mtusi2026-messenger/internal/config"
|
||||
"mtusi2026-messenger/internal/db"
|
||||
"mtusi2026-messenger/internal/logger"
|
||||
"mtusi2026-messenger/internal/postgres"
|
||||
"mtusi2026-messenger/internal/redis"
|
||||
"mtusi2026-messenger/internal/service"
|
||||
)
|
||||
|
||||
func Run() error {
|
||||
if err := godotenv.Load(); err != nil && !os.IsNotExist(err) {
|
||||
return err
|
||||
}
|
||||
|
||||
cfg := config.Load()
|
||||
|
||||
log := logger.New(cfg.Logging.Level)
|
||||
|
||||
dbURL, err := cfg.Database.URL()
|
||||
if err != nil {
|
||||
log.Error("read database url", "error", err)
|
||||
return err
|
||||
}
|
||||
|
||||
pool, err := postgres.New(context.Background(), dbURL)
|
||||
if err != nil {
|
||||
log.Error("connect to database", "error", err)
|
||||
return err
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
queries := db.New(pool)
|
||||
|
||||
cacheURL, err := cfg.Redis.URL()
|
||||
if err != nil {
|
||||
log.Error("read redis url", "error", err)
|
||||
return err
|
||||
}
|
||||
|
||||
rdb, err := redis.New(context.Background(), log, cacheURL)
|
||||
if err != nil {
|
||||
log.Error("create redis client", "error", err)
|
||||
return err
|
||||
}
|
||||
defer rdb.Close()
|
||||
|
||||
cleanupCtx, stopCleanup := context.WithCancel(context.Background())
|
||||
cleanupDone := make(chan struct{})
|
||||
go func() {
|
||||
defer close(cleanupDone)
|
||||
runSessionCleanup(cleanupCtx, log, queries, sessionCleanupInterval)
|
||||
}()
|
||||
defer func() {
|
||||
stopCleanup()
|
||||
<-cleanupDone
|
||||
}()
|
||||
|
||||
authService := service.NewAuthService(queries, rdb, cfg.Server.SessionTTL, log)
|
||||
userService := service.NewUserService(queries)
|
||||
chatService := service.NewChatService(pool, queries)
|
||||
messageService := service.NewMessageService(queries)
|
||||
|
||||
router := NewRouter(
|
||||
log,
|
||||
cfg.Server.MaxInflightRequests,
|
||||
pool,
|
||||
authService,
|
||||
userService,
|
||||
chatService,
|
||||
messageService,
|
||||
)
|
||||
|
||||
server := &http.Server{
|
||||
Addr: cfg.Server.Host + ":" + cfg.Server.Port,
|
||||
Handler: router,
|
||||
}
|
||||
|
||||
serverErrors := make(chan error, 1)
|
||||
|
||||
go func() {
|
||||
log.Info("server starting", "addr", server.Addr)
|
||||
serverErrors <- server.ListenAndServe()
|
||||
}()
|
||||
|
||||
signalCh := make(chan os.Signal, 1)
|
||||
signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM)
|
||||
defer signal.Stop(signalCh)
|
||||
|
||||
select {
|
||||
case err := <-serverErrors:
|
||||
if err == http.ErrServerClosed {
|
||||
return nil
|
||||
}
|
||||
|
||||
log.Error("server failed", "error", err)
|
||||
return err
|
||||
|
||||
case sig := <-signalCh:
|
||||
log.Info("shutdown signal received", "signal", sig.String())
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
|
||||
if err := server.Shutdown(ctx); err != nil {
|
||||
log.Error("server shutdown failed", "error", err)
|
||||
return err
|
||||
}
|
||||
|
||||
log.Info("server stopped")
|
||||
return nil
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log/slog"
|
||||
"time"
|
||||
)
|
||||
|
||||
const sessionCleanupInterval = time.Hour
|
||||
|
||||
type sessionCleaner interface {
|
||||
DeleteExpiredSessions(ctx context.Context) (int64, error)
|
||||
}
|
||||
|
||||
func runSessionCleanup(ctx context.Context, log *slog.Logger, q sessionCleaner, interval time.Duration) {
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
n, err := q.DeleteExpiredSessions(ctx)
|
||||
if err != nil {
|
||||
if ctx.Err() == nil {
|
||||
log.Error("delete expired sessions", "error", err)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if n > 0 {
|
||||
log.Info("expired sessions deleted", "count", n)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"mtusi2026-messenger/internal/config"
|
||||
|
||||
"github.com/joho/godotenv"
|
||||
)
|
||||
|
||||
func Healthcheck() int {
|
||||
if err := godotenv.Load(); err != nil && !os.IsNotExist(err) {
|
||||
fmt.Fprintln(os.Stderr, "healthcheck: load env:", err)
|
||||
return 1
|
||||
}
|
||||
|
||||
cfg := config.Load()
|
||||
url := fmt.Sprintf("http://localhost:%s/health/ready", cfg.Server.Port)
|
||||
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
||||
defer cancel()
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "healthcheck: build request:", err)
|
||||
return 1
|
||||
}
|
||||
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "healthcheck: request failed:", err)
|
||||
return 1
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
fmt.Fprintln(os.Stderr, "healthcheck: unexpected status", resp.StatusCode)
|
||||
return 1
|
||||
}
|
||||
|
||||
return 0
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
|
||||
"mtusi2026-messenger/internal/handler"
|
||||
"mtusi2026-messenger/internal/middleware"
|
||||
"mtusi2026-messenger/internal/service"
|
||||
)
|
||||
|
||||
func NewRouter(
|
||||
log *slog.Logger,
|
||||
maxInflightRequests int,
|
||||
db handler.Pinger,
|
||||
authService *service.AuthService,
|
||||
userService *service.UserService,
|
||||
chatService *service.ChatService,
|
||||
messageService *service.MessageService,
|
||||
) http.Handler {
|
||||
router := chi.NewRouter()
|
||||
|
||||
healthHandler := handler.NewHealthHandler(log, db)
|
||||
authHandler := handler.NewAuthHandler(authService)
|
||||
userHandler := handler.NewUserHandler(userService)
|
||||
chatHandler := handler.NewChatHandler(chatService)
|
||||
messageHandler := handler.NewMessageHandler(messageService)
|
||||
|
||||
router.Use(middleware.RequestTimeout(5 * time.Second))
|
||||
router.Use(middleware.RequestID)
|
||||
router.Use(middleware.Logging(log))
|
||||
router.Use(middleware.ConcurrencyLimit(maxInflightRequests))
|
||||
|
||||
router.Get("/health/live", healthHandler.Live)
|
||||
router.Get("/health/ready", healthHandler.Ready)
|
||||
|
||||
router.Post("/api/v1/users", userHandler.Create)
|
||||
|
||||
router.Post("/api/v1/auth/sessions", authHandler.CreateSession)
|
||||
router.Delete("/api/v1/auth/sessions/current", authHandler.RevokeSession)
|
||||
|
||||
router.Group(func(r chi.Router) {
|
||||
r.Use(middleware.Auth(authService))
|
||||
|
||||
r.Get("/api/v1/users/me", userHandler.Me)
|
||||
|
||||
r.Post("/api/v1/chats", chatHandler.Create)
|
||||
r.Get("/api/v1/chats", chatHandler.List)
|
||||
r.Get("/api/v1/chats/{chat_id}", chatHandler.Get)
|
||||
|
||||
r.Post("/api/v1/chats/{chat_id}/messages", messageHandler.Create)
|
||||
r.Get("/api/v1/chats/{chat_id}/messages", messageHandler.List)
|
||||
})
|
||||
|
||||
router.Handle("/swagger/*", http.StripPrefix("/swagger/", http.FileServer(http.Dir("web/swagger"))))
|
||||
router.Handle("/contracts/*", http.StripPrefix("/contracts/", http.FileServer(http.Dir("contracts"))))
|
||||
|
||||
return router
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"log/slog"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Config struct {
|
||||
Server ServerConfig
|
||||
Logging LoggingConfig
|
||||
Database DatabaseConfig
|
||||
Redis RedisConfig
|
||||
}
|
||||
|
||||
type ServerConfig struct {
|
||||
Host string
|
||||
Port string
|
||||
MaxInflightRequests int
|
||||
SessionTTL time.Duration
|
||||
}
|
||||
|
||||
type LoggingConfig struct {
|
||||
Level slog.Level
|
||||
}
|
||||
|
||||
type DatabaseConfig struct {
|
||||
URLFile string
|
||||
}
|
||||
|
||||
func (c DatabaseConfig) URL() (string, error) {
|
||||
return readSecretFile(c.URLFile)
|
||||
}
|
||||
|
||||
type RedisConfig struct {
|
||||
URLFile string
|
||||
}
|
||||
|
||||
func (c RedisConfig) URL() (string, error) {
|
||||
return readSecretFile(c.URLFile)
|
||||
}
|
||||
|
||||
func Load() Config {
|
||||
return Config{
|
||||
Server: ServerConfig{
|
||||
Host: getEnv("APP_HOST", "0.0.0.0"),
|
||||
Port: getEnv("APP_PORT", "8080"),
|
||||
MaxInflightRequests: getEnvNonNegativeInt("MAX_INFLIGHT_REQUESTS", 0),
|
||||
SessionTTL: time.Duration(getEnvPositiveInt("SESSION_TTL_SECONDS", 3600)) * time.Second,
|
||||
},
|
||||
|
||||
Logging: LoggingConfig{
|
||||
Level: getEnvLogLevel("LOG_LEVEL", slog.LevelInfo),
|
||||
},
|
||||
|
||||
Database: DatabaseConfig{
|
||||
URLFile: getEnv("DATABASE_URL_FILE", "/run/secrets/database_url"),
|
||||
},
|
||||
|
||||
Redis: RedisConfig{
|
||||
URLFile: getEnv("CACHE_URL_FILE", "/run/secrets/cache_url"),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func getEnv(key, def string) string {
|
||||
value := os.Getenv(key)
|
||||
if value == "" {
|
||||
return def
|
||||
}
|
||||
|
||||
return value
|
||||
}
|
||||
|
||||
func getEnvNonNegativeInt(key string, def int) int {
|
||||
v := os.Getenv(key)
|
||||
if v == "" {
|
||||
return def
|
||||
}
|
||||
|
||||
value, err := strconv.Atoi(v)
|
||||
if err != nil || value < 0 {
|
||||
log.Printf("invalid non-negative int for %s=%q, using default %d", key, v, def)
|
||||
return def
|
||||
}
|
||||
|
||||
return value
|
||||
}
|
||||
|
||||
func getEnvPositiveInt(key string, def int) int {
|
||||
v := os.Getenv(key)
|
||||
if v == "" {
|
||||
return def
|
||||
}
|
||||
|
||||
value, err := strconv.Atoi(v)
|
||||
if err != nil || value <= 0 {
|
||||
log.Printf("invalid positive int for %s=%q, using default %d", key, v, def)
|
||||
return def
|
||||
}
|
||||
|
||||
return value
|
||||
}
|
||||
|
||||
func getEnvLogLevel(key string, def slog.Level) slog.Level {
|
||||
v := os.Getenv(key)
|
||||
|
||||
switch v {
|
||||
case "DEBUG":
|
||||
return slog.LevelDebug
|
||||
case "INFO":
|
||||
return slog.LevelInfo
|
||||
case "WARN":
|
||||
return slog.LevelWarn
|
||||
case "ERROR":
|
||||
return slog.LevelError
|
||||
case "":
|
||||
return def
|
||||
default:
|
||||
log.Printf("invalid log level for %s=%q, using default %s", key, v, def)
|
||||
return def
|
||||
}
|
||||
}
|
||||
|
||||
func readSecretFile(path string) (string, error) {
|
||||
b, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("read secret file %s: %w", path, err)
|
||||
}
|
||||
|
||||
value := strings.TrimSpace(string(b))
|
||||
if value == "" {
|
||||
return "", fmt.Errorf("secret file %s is empty", path)
|
||||
}
|
||||
|
||||
return value, nil
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
package credentials
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
|
||||
"golang.org/x/crypto/bcrypt"
|
||||
)
|
||||
|
||||
const tokenSize = 32
|
||||
|
||||
var ErrPasswordMismatch = errors.New("password mismatch")
|
||||
|
||||
func prehash(plain string) []byte {
|
||||
sum := sha256.Sum256([]byte(plain))
|
||||
return []byte(base64.StdEncoding.EncodeToString(sum[:]))
|
||||
}
|
||||
|
||||
func HashPassword(plain string) (string, error) {
|
||||
hash, err := bcrypt.GenerateFromPassword(prehash(plain), bcrypt.DefaultCost)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
return string(hash), nil
|
||||
}
|
||||
|
||||
func VerifyPassword(hash, plain string) error {
|
||||
err := bcrypt.CompareHashAndPassword([]byte(hash), prehash(plain))
|
||||
if errors.Is(err, bcrypt.ErrMismatchedHashAndPassword) {
|
||||
return ErrPasswordMismatch
|
||||
}
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func NewToken() string {
|
||||
raw := make([]byte, tokenSize)
|
||||
_, _ = rand.Read(raw) // never returns an error since Go 1.24
|
||||
|
||||
return base64.RawURLEncoding.EncodeToString(raw)
|
||||
}
|
||||
|
||||
func HashToken(token string) string {
|
||||
sum := sha256.Sum256([]byte(token))
|
||||
|
||||
return hex.EncodeToString(sum[:])
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
// source: chats.sql
|
||||
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const addChatMembers = `-- name: AddChatMembers :exec
|
||||
INSERT INTO chat_members (
|
||||
chat_id,
|
||||
user_id
|
||||
)
|
||||
SELECT
|
||||
$1::uuid,
|
||||
unnest($2::uuid[])
|
||||
`
|
||||
|
||||
type AddChatMembersParams struct {
|
||||
ChatID uuid.UUID
|
||||
UserIds []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) AddChatMembers(ctx context.Context, arg AddChatMembersParams) error {
|
||||
_, err := q.db.Exec(ctx, addChatMembers, arg.ChatID, arg.UserIds)
|
||||
return err
|
||||
}
|
||||
|
||||
const createChat = `-- name: CreateChat :one
|
||||
INSERT INTO chats (
|
||||
id,
|
||||
title
|
||||
) VALUES (
|
||||
$1,
|
||||
$2
|
||||
)
|
||||
RETURNING id, title, created_at
|
||||
`
|
||||
|
||||
type CreateChatParams struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
}
|
||||
|
||||
func (q *Queries) CreateChat(ctx context.Context, arg CreateChatParams) (Chat, error) {
|
||||
row := q.db.QueryRow(ctx, createChat, arg.ID, arg.Title)
|
||||
var i Chat
|
||||
err := row.Scan(&i.ID, &i.Title, &i.CreatedAt)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const getChat = `-- name: GetChat :one
|
||||
SELECT
|
||||
c.id, c.title, c.created_at,
|
||||
ARRAY(
|
||||
SELECT cm.user_id FROM chat_members cm
|
||||
WHERE cm.chat_id = c.id
|
||||
ORDER BY cm.user_id
|
||||
)::uuid[] AS member_ids
|
||||
FROM chats c
|
||||
WHERE c.id = $1
|
||||
AND EXISTS (
|
||||
SELECT 1 FROM chat_members m
|
||||
WHERE m.chat_id = c.id
|
||||
AND m.user_id = $2
|
||||
)
|
||||
`
|
||||
|
||||
type GetChatParams struct {
|
||||
ID uuid.UUID
|
||||
UserID uuid.UUID
|
||||
}
|
||||
|
||||
type GetChatRow struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
CreatedAt time.Time
|
||||
MemberIds []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) GetChat(ctx context.Context, arg GetChatParams) (GetChatRow, error) {
|
||||
row := q.db.QueryRow(ctx, getChat, arg.ID, arg.UserID)
|
||||
var i GetChatRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.Title,
|
||||
&i.CreatedAt,
|
||||
&i.MemberIds,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const isChatMember = `-- name: IsChatMember :one
|
||||
SELECT EXISTS (
|
||||
SELECT 1 FROM chat_members
|
||||
WHERE chat_id = $1
|
||||
AND user_id = $2
|
||||
)
|
||||
`
|
||||
|
||||
type IsChatMemberParams struct {
|
||||
ChatID uuid.UUID
|
||||
UserID uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) IsChatMember(ctx context.Context, arg IsChatMemberParams) (bool, error) {
|
||||
row := q.db.QueryRow(ctx, isChatMember, arg.ChatID, arg.UserID)
|
||||
var exists bool
|
||||
err := row.Scan(&exists)
|
||||
return exists, err
|
||||
}
|
||||
|
||||
const listChatsAfter = `-- name: ListChatsAfter :many
|
||||
SELECT
|
||||
c.id, c.title, c.created_at,
|
||||
ARRAY(
|
||||
SELECT cm.user_id FROM chat_members cm
|
||||
WHERE cm.chat_id = c.id
|
||||
ORDER BY cm.user_id
|
||||
)::uuid[] AS member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members m ON m.chat_id = c.id
|
||||
WHERE m.user_id = $1
|
||||
AND (c.created_at, c.id) > (
|
||||
$2::timestamptz,
|
||||
$3::uuid
|
||||
)
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $4
|
||||
`
|
||||
|
||||
type ListChatsAfterParams struct {
|
||||
UserID uuid.UUID
|
||||
AfterCreatedAt time.Time
|
||||
AfterID uuid.UUID
|
||||
Lim int32
|
||||
}
|
||||
|
||||
type ListChatsAfterRow struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
CreatedAt time.Time
|
||||
MemberIds []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) ListChatsAfter(ctx context.Context, arg ListChatsAfterParams) ([]ListChatsAfterRow, error) {
|
||||
rows, err := q.db.Query(ctx, listChatsAfter,
|
||||
arg.UserID,
|
||||
arg.AfterCreatedAt,
|
||||
arg.AfterID,
|
||||
arg.Lim,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListChatsAfterRow{}
|
||||
for rows.Next() {
|
||||
var i ListChatsAfterRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.Title,
|
||||
&i.CreatedAt,
|
||||
&i.MemberIds,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listChatsFirstPage = `-- name: ListChatsFirstPage :many
|
||||
SELECT
|
||||
c.id, c.title, c.created_at,
|
||||
ARRAY(
|
||||
SELECT cm.user_id FROM chat_members cm
|
||||
WHERE cm.chat_id = c.id
|
||||
ORDER BY cm.user_id
|
||||
)::uuid[] AS member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members m ON m.chat_id = c.id
|
||||
WHERE m.user_id = $1
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $2
|
||||
`
|
||||
|
||||
type ListChatsFirstPageParams struct {
|
||||
UserID uuid.UUID
|
||||
Lim int32
|
||||
}
|
||||
|
||||
type ListChatsFirstPageRow struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
CreatedAt time.Time
|
||||
MemberIds []uuid.UUID
|
||||
}
|
||||
|
||||
func (q *Queries) ListChatsFirstPage(ctx context.Context, arg ListChatsFirstPageParams) ([]ListChatsFirstPageRow, error) {
|
||||
rows, err := q.db.Query(ctx, listChatsFirstPage, arg.UserID, arg.Lim)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListChatsFirstPageRow{}
|
||||
for rows.Next() {
|
||||
var i ListChatsFirstPageRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.Title,
|
||||
&i.CreatedAt,
|
||||
&i.MemberIds,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
)
|
||||
|
||||
type DBTX interface {
|
||||
Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
|
||||
Query(context.Context, string, ...interface{}) (pgx.Rows, error)
|
||||
QueryRow(context.Context, string, ...interface{}) pgx.Row
|
||||
}
|
||||
|
||||
func New(db DBTX) *Queries {
|
||||
return &Queries{db: db}
|
||||
}
|
||||
|
||||
type Queries struct {
|
||||
db DBTX
|
||||
}
|
||||
|
||||
func (q *Queries) WithTx(tx pgx.Tx) *Queries {
|
||||
return &Queries{
|
||||
db: tx,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
// source: messages.sql
|
||||
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const createMessage = `-- name: CreateMessage :one
|
||||
INSERT INTO messages (
|
||||
id,
|
||||
chat_id,
|
||||
sender_id,
|
||||
text
|
||||
)
|
||||
SELECT
|
||||
$1::uuid,
|
||||
$2::uuid,
|
||||
$3::uuid,
|
||||
$4::text
|
||||
WHERE EXISTS (
|
||||
SELECT 1 FROM chat_members
|
||||
WHERE chat_id = $2
|
||||
AND user_id = $3
|
||||
)
|
||||
RETURNING id, chat_id, sender_id, text, created_at
|
||||
`
|
||||
|
||||
type CreateMessageParams struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
}
|
||||
|
||||
func (q *Queries) CreateMessage(ctx context.Context, arg CreateMessageParams) (Message, error) {
|
||||
row := q.db.QueryRow(ctx, createMessage,
|
||||
arg.ID,
|
||||
arg.ChatID,
|
||||
arg.SenderID,
|
||||
arg.Text,
|
||||
)
|
||||
var i Message
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.SenderID,
|
||||
&i.Text,
|
||||
&i.CreatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const listMessagesAfter = `-- name: ListMessagesAfter :many
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = $1
|
||||
AND (created_at, id) > (
|
||||
$2::timestamptz,
|
||||
$3::uuid
|
||||
)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4
|
||||
`
|
||||
|
||||
type ListMessagesAfterParams struct {
|
||||
ChatID uuid.UUID
|
||||
AfterCreatedAt time.Time
|
||||
AfterID uuid.UUID
|
||||
Lim int32
|
||||
}
|
||||
|
||||
func (q *Queries) ListMessagesAfter(ctx context.Context, arg ListMessagesAfterParams) ([]Message, error) {
|
||||
rows, err := q.db.Query(ctx, listMessagesAfter,
|
||||
arg.ChatID,
|
||||
arg.AfterCreatedAt,
|
||||
arg.AfterID,
|
||||
arg.Lim,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []Message{}
|
||||
for rows.Next() {
|
||||
var i Message
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.SenderID,
|
||||
&i.Text,
|
||||
&i.CreatedAt,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listMessagesFirstPage = `-- name: ListMessagesFirstPage :many
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2
|
||||
`
|
||||
|
||||
type ListMessagesFirstPageParams struct {
|
||||
ChatID uuid.UUID
|
||||
Lim int32
|
||||
}
|
||||
|
||||
func (q *Queries) ListMessagesFirstPage(ctx context.Context, arg ListMessagesFirstPageParams) ([]Message, error) {
|
||||
rows, err := q.db.Query(ctx, listMessagesFirstPage, arg.ChatID, arg.Lim)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []Message{}
|
||||
for rows.Next() {
|
||||
var i Message
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ChatID,
|
||||
&i.SenderID,
|
||||
&i.Text,
|
||||
&i.CreatedAt,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
|
||||
package db
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type Chat struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
type ChatMember struct {
|
||||
ChatID uuid.UUID
|
||||
UserID uuid.UUID
|
||||
}
|
||||
|
||||
type Message struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
type Session struct {
|
||||
TokenHash string
|
||||
UserID uuid.UUID
|
||||
CreatedAt time.Time
|
||||
ExpiresAt time.Time
|
||||
}
|
||||
|
||||
type User struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
PasswordHash string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
// source: sessions.sql
|
||||
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const createSession = `-- name: CreateSession :exec
|
||||
INSERT INTO sessions (
|
||||
token_hash,
|
||||
user_id,
|
||||
expires_at
|
||||
) VALUES (
|
||||
$1,
|
||||
$2,
|
||||
$3
|
||||
)
|
||||
`
|
||||
|
||||
type CreateSessionParams struct {
|
||||
TokenHash string
|
||||
UserID uuid.UUID
|
||||
ExpiresAt time.Time
|
||||
}
|
||||
|
||||
func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) error {
|
||||
_, err := q.db.Exec(ctx, createSession, arg.TokenHash, arg.UserID, arg.ExpiresAt)
|
||||
return err
|
||||
}
|
||||
|
||||
const deleteExpiredSessions = `-- name: DeleteExpiredSessions :execrows
|
||||
DELETE FROM sessions
|
||||
WHERE expires_at <= now()
|
||||
`
|
||||
|
||||
func (q *Queries) DeleteExpiredSessions(ctx context.Context) (int64, error) {
|
||||
result, err := q.db.Exec(ctx, deleteExpiredSessions)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return result.RowsAffected(), nil
|
||||
}
|
||||
|
||||
const deleteSession = `-- name: DeleteSession :execrows
|
||||
DELETE FROM sessions
|
||||
WHERE token_hash = $1
|
||||
AND expires_at > now()
|
||||
`
|
||||
|
||||
func (q *Queries) DeleteSession(ctx context.Context, tokenHash string) (int64, error) {
|
||||
result, err := q.db.Exec(ctx, deleteSession, tokenHash)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return result.RowsAffected(), nil
|
||||
}
|
||||
|
||||
const getActiveSession = `-- name: GetActiveSession :one
|
||||
SELECT user_id, expires_at FROM sessions
|
||||
WHERE token_hash = $1
|
||||
AND expires_at > now()
|
||||
`
|
||||
|
||||
type GetActiveSessionRow struct {
|
||||
UserID uuid.UUID
|
||||
ExpiresAt time.Time
|
||||
}
|
||||
|
||||
func (q *Queries) GetActiveSession(ctx context.Context, tokenHash string) (GetActiveSessionRow, error) {
|
||||
row := q.db.QueryRow(ctx, getActiveSession, tokenHash)
|
||||
var i GetActiveSessionRow
|
||||
err := row.Scan(&i.UserID, &i.ExpiresAt)
|
||||
return i, err
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.31.1
|
||||
// source: users.sql
|
||||
|
||||
package db
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
const createUser = `-- name: CreateUser :one
|
||||
INSERT INTO users (
|
||||
id,
|
||||
username,
|
||||
display_name,
|
||||
password_hash
|
||||
) VALUES (
|
||||
$1,
|
||||
$2,
|
||||
$3,
|
||||
$4
|
||||
)
|
||||
RETURNING id, username, display_name, created_at
|
||||
`
|
||||
|
||||
type CreateUserParams struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
PasswordHash string
|
||||
}
|
||||
|
||||
type CreateUserRow struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (CreateUserRow, error) {
|
||||
row := q.db.QueryRow(ctx, createUser,
|
||||
arg.ID,
|
||||
arg.Username,
|
||||
arg.DisplayName,
|
||||
arg.PasswordHash,
|
||||
)
|
||||
var i CreateUserRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.Username,
|
||||
&i.DisplayName,
|
||||
&i.CreatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const getUser = `-- name: GetUser :one
|
||||
SELECT id, username, display_name, created_at FROM users
|
||||
WHERE id = $1
|
||||
`
|
||||
|
||||
type GetUserRow struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
func (q *Queries) GetUser(ctx context.Context, id uuid.UUID) (GetUserRow, error) {
|
||||
row := q.db.QueryRow(ctx, getUser, id)
|
||||
var i GetUserRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.Username,
|
||||
&i.DisplayName,
|
||||
&i.CreatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const getUserByUsername = `-- name: GetUserByUsername :one
|
||||
SELECT id, username, display_name, password_hash, created_at FROM users
|
||||
WHERE username = $1
|
||||
`
|
||||
|
||||
func (q *Queries) GetUserByUsername(ctx context.Context, username string) (User, error) {
|
||||
row := q.db.QueryRow(ctx, getUserByUsername, username)
|
||||
var i User
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.Username,
|
||||
&i.DisplayName,
|
||||
&i.PasswordHash,
|
||||
&i.CreatedAt,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package dto
|
||||
|
||||
import (
|
||||
"mtusi2026-messenger/internal/model"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type CreateChatRequest struct {
|
||||
Title string `json:"title"`
|
||||
MemberIDs []uuid.UUID `json:"member_ids"`
|
||||
}
|
||||
|
||||
type ChatResponse struct {
|
||||
ID uuid.UUID `json:"id"`
|
||||
Title string `json:"title"`
|
||||
MemberIDs []uuid.UUID `json:"member_ids"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
type ChatPageResponse struct {
|
||||
Items []ChatResponse `json:"items"`
|
||||
NextCursor *string `json:"next_cursor"`
|
||||
}
|
||||
|
||||
func (r CreateChatRequest) Validate() bool {
|
||||
if strings.TrimSpace(r.Title) == "" ||
|
||||
strings.ContainsRune(r.Title, 0) ||
|
||||
utf8.RuneCountInString(r.Title) > 100 {
|
||||
return false
|
||||
}
|
||||
|
||||
if len(r.MemberIDs) < 1 || len(r.MemberIDs) > 100 {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
func ToChatResponse(c model.Chat) ChatResponse {
|
||||
return ChatResponse{
|
||||
ID: c.ID,
|
||||
Title: c.Title,
|
||||
MemberIDs: c.MemberIDs,
|
||||
CreatedAt: c.CreatedAt,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package dto
|
||||
|
||||
type ErrorCode string
|
||||
|
||||
const (
|
||||
ErrorCodeInvalidRequest ErrorCode = "invalid_request"
|
||||
ErrorCodeUnauthorized ErrorCode = "unauthorized"
|
||||
ErrorCodeNotFound ErrorCode = "not_found"
|
||||
ErrorCodeConflict ErrorCode = "conflict"
|
||||
ErrorCodePayloadTooLarge ErrorCode = "payload_too_large"
|
||||
ErrorCodeUnsupportedMediaType ErrorCode = "unsupported_media_type"
|
||||
ErrorCodeRateLimited ErrorCode = "rate_limited"
|
||||
ErrorCodeUnavailable ErrorCode = "unavailable"
|
||||
ErrorCodeInternalError ErrorCode = "internal_error"
|
||||
)
|
||||
|
||||
type ErrorResponse struct {
|
||||
Error Error `json:"error"`
|
||||
}
|
||||
|
||||
type Error struct {
|
||||
Code ErrorCode `json:"code"`
|
||||
Message string `json:"message"`
|
||||
RequestID string `json:"request_id"`
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package dto
|
||||
|
||||
type HealthResponse struct {
|
||||
Status string `json:"status"`
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package dto
|
||||
|
||||
import (
|
||||
"mtusi2026-messenger/internal/model"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type CreateMessageRequest struct {
|
||||
Text string `json:"text"`
|
||||
}
|
||||
|
||||
type MessageResponse struct {
|
||||
ID uuid.UUID `json:"id"`
|
||||
ChatID uuid.UUID `json:"chat_id"`
|
||||
SenderID uuid.UUID `json:"sender_id"`
|
||||
Text string `json:"text"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
type MessagePageResponse struct {
|
||||
Items []MessageResponse `json:"items"`
|
||||
NextCursor *string `json:"next_cursor"`
|
||||
}
|
||||
|
||||
func (r CreateMessageRequest) Validate() bool {
|
||||
if strings.TrimSpace(r.Text) == "" ||
|
||||
strings.ContainsRune(r.Text, 0) ||
|
||||
utf8.RuneCountInString(r.Text) > 4000 {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
func ToMessageResponse(m model.Message) MessageResponse {
|
||||
return MessageResponse{
|
||||
ID: m.ID,
|
||||
ChatID: m.ChatID,
|
||||
SenderID: m.SenderID,
|
||||
Text: m.Text,
|
||||
CreatedAt: m.CreatedAt,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
package dto
|
||||
|
||||
import "time"
|
||||
|
||||
type SessionResponse struct {
|
||||
Token string `json:"token"`
|
||||
TokenType string `json:"token_type"`
|
||||
ExpiresAt time.Time `json:"expires_at"`
|
||||
User UserResponse `json:"user"`
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package dto
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
|
||||
|
||||
type CreateUserRequest struct {
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
|
||||
type UserResponse struct {
|
||||
ID uuid.UUID `json:"id"`
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
}
|
||||
|
||||
func (r CreateUserRequest) Validate() bool {
|
||||
if !usernamePattern.MatchString(r.Username) {
|
||||
return false
|
||||
}
|
||||
|
||||
displayNameLength := utf8.RuneCountInString(r.DisplayName)
|
||||
if strings.TrimSpace(r.DisplayName) == "" ||
|
||||
displayNameLength > 100 ||
|
||||
strings.ContainsRune(r.DisplayName, 0) {
|
||||
return false
|
||||
}
|
||||
|
||||
if n := utf8.RuneCountInString(r.Password); n < 12 || n > 128 {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
"mtusi2026-messenger/internal/httpx"
|
||||
"mtusi2026-messenger/internal/middleware"
|
||||
"mtusi2026-messenger/internal/service"
|
||||
)
|
||||
|
||||
type AuthHandler struct {
|
||||
service *service.AuthService
|
||||
}
|
||||
|
||||
func NewAuthHandler(s *service.AuthService) *AuthHandler {
|
||||
return &AuthHandler{service: s}
|
||||
}
|
||||
|
||||
func (h *AuthHandler) CreateSession(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
|
||||
username, plain, ok := r.BasicAuth()
|
||||
if !ok {
|
||||
httpx.WriteUnauthorized(w, httpx.BasicChallenge, requestID)
|
||||
return
|
||||
}
|
||||
|
||||
session, err := h.service.Login(r.Context(), username, plain)
|
||||
if errors.Is(err, service.ErrInvalidCredentials) {
|
||||
httpx.WriteUnauthorized(w, httpx.BasicChallenge, requestID)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
httpx.WriteJSON(w, http.StatusCreated, dto.SessionResponse{
|
||||
Token: session.Token,
|
||||
TokenType: "Bearer",
|
||||
ExpiresAt: session.ExpiresAt,
|
||||
User: dto.UserResponse{
|
||||
ID: session.User.ID,
|
||||
Username: session.User.Username,
|
||||
DisplayName: session.User.DisplayName,
|
||||
CreatedAt: session.User.CreatedAt,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
func (h *AuthHandler) RevokeSession(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
|
||||
token, ok := httpx.BearerToken(r)
|
||||
if !ok {
|
||||
httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID)
|
||||
return
|
||||
}
|
||||
|
||||
err := h.service.Logout(r.Context(), token)
|
||||
if errors.Is(err, service.ErrUnauthorized) {
|
||||
httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
"mtusi2026-messenger/internal/httpx"
|
||||
"mtusi2026-messenger/internal/middleware"
|
||||
"mtusi2026-messenger/internal/service"
|
||||
)
|
||||
|
||||
type ChatHandler struct {
|
||||
service *service.ChatService
|
||||
}
|
||||
|
||||
func NewChatHandler(service *service.ChatService) *ChatHandler {
|
||||
return &ChatHandler{service: service}
|
||||
}
|
||||
|
||||
func (h *ChatHandler) Create(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
userID := middleware.GetUserID(r.Context())
|
||||
|
||||
var req dto.CreateChatRequest
|
||||
if !httpx.DecodeJSONBody(w, r, requestID, &req) {
|
||||
return
|
||||
}
|
||||
|
||||
if !req.Validate() {
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"invalid request body",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
chat, err := h.service.Create(r.Context(), userID, req.Title, req.MemberIDs)
|
||||
switch {
|
||||
case errors.Is(err, service.ErrNotChatMember):
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"caller must be a member of member_ids",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
case errors.Is(err, service.ErrDuplicateMember):
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"member_ids contains duplicates",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
case errors.Is(err, service.ErrUnknownMember):
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"member_ids contains unknown user",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
case err != nil:
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
httpx.WriteJSON(w, http.StatusCreated, dto.ToChatResponse(chat))
|
||||
}
|
||||
|
||||
func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
userID := middleware.GetUserID(r.Context())
|
||||
|
||||
chatID, err := uuid.Parse(chi.URLParam(r, "chat_id"))
|
||||
if err != nil {
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"invalid chat_id",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
chat, err := h.service.Get(r.Context(), userID, chatID)
|
||||
switch {
|
||||
case errors.Is(err, service.ErrChatNotFound):
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusNotFound,
|
||||
dto.ErrorCodeNotFound,
|
||||
"chat not found",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
case err != nil:
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
httpx.WriteJSON(w, http.StatusOK, dto.ToChatResponse(chat))
|
||||
}
|
||||
|
||||
func (h *ChatHandler) List(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
userID := middleware.GetUserID(r.Context())
|
||||
|
||||
limit, cursor, ok := httpx.ParsePagination(w, r, requestID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
|
||||
chats, nextCursor, err := h.service.List(r.Context(), userID, limit, cursor)
|
||||
switch {
|
||||
case errors.Is(err, service.ErrInvalidCursor):
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"invalid cursor",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
case err != nil:
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
items := make([]dto.ChatResponse, 0, len(chats))
|
||||
for _, c := range chats {
|
||||
items = append(items, dto.ToChatResponse(c))
|
||||
}
|
||||
|
||||
httpx.WriteJSON(w, http.StatusOK, dto.ChatPageResponse{
|
||||
Items: items,
|
||||
NextCursor: nextCursor,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
"mtusi2026-messenger/internal/httpx"
|
||||
)
|
||||
|
||||
const readyPingTimeout = 2 * time.Second
|
||||
|
||||
type Pinger interface {
|
||||
Ping(ctx context.Context) error
|
||||
}
|
||||
|
||||
type HealthHandler struct {
|
||||
log *slog.Logger
|
||||
db Pinger
|
||||
}
|
||||
|
||||
func NewHealthHandler(log *slog.Logger, db Pinger) *HealthHandler {
|
||||
return &HealthHandler{log: log, db: db}
|
||||
}
|
||||
|
||||
func (h *HealthHandler) Live(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
|
||||
_ = json.NewEncoder(w).Encode(dto.HealthResponse{
|
||||
Status: "ok",
|
||||
})
|
||||
}
|
||||
|
||||
func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) {
|
||||
ctx, cancel := context.WithTimeout(r.Context(), readyPingTimeout)
|
||||
defer cancel()
|
||||
|
||||
if err := h.db.Ping(ctx); err != nil {
|
||||
h.log.ErrorContext(r.Context(), "readiness check failed", "error", err)
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusServiceUnavailable,
|
||||
dto.ErrorCodeUnavailable,
|
||||
"service unavailable",
|
||||
w.Header().Get("X-Request-Id"),
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
|
||||
_ = json.NewEncoder(w).Encode(dto.HealthResponse{
|
||||
Status: "ok",
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"github.com/go-chi/chi/v5"
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
"mtusi2026-messenger/internal/httpx"
|
||||
"mtusi2026-messenger/internal/middleware"
|
||||
"mtusi2026-messenger/internal/service"
|
||||
)
|
||||
|
||||
type MessageHandler struct {
|
||||
service *service.MessageService
|
||||
}
|
||||
|
||||
func NewMessageHandler(service *service.MessageService) *MessageHandler {
|
||||
return &MessageHandler{service: service}
|
||||
}
|
||||
|
||||
func (h *MessageHandler) Create(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
userID := middleware.GetUserID(r.Context())
|
||||
|
||||
chatID, err := uuid.Parse(chi.URLParam(r, "chat_id"))
|
||||
if err != nil {
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"invalid chat_id",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
var req dto.CreateMessageRequest
|
||||
if !httpx.DecodeJSONBody(w, r, requestID, &req) {
|
||||
return
|
||||
}
|
||||
|
||||
if !req.Validate() {
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"invalid request body",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
message, err := h.service.Create(r.Context(), userID, chatID, req.Text)
|
||||
switch {
|
||||
case errors.Is(err, service.ErrMessageChatNotFound):
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusNotFound,
|
||||
dto.ErrorCodeNotFound,
|
||||
"chat not found",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
case err != nil:
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
httpx.WriteJSON(w, http.StatusCreated, dto.ToMessageResponse(message))
|
||||
}
|
||||
|
||||
func (h *MessageHandler) List(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
userID := middleware.GetUserID(r.Context())
|
||||
|
||||
chatID, err := uuid.Parse(chi.URLParam(r, "chat_id"))
|
||||
if err != nil {
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"invalid chat_id",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
limit, cursor, ok := httpx.ParsePagination(w, r, requestID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
|
||||
messages, nextCursor, err := h.service.List(r.Context(), userID, chatID, limit, cursor)
|
||||
switch {
|
||||
case errors.Is(err, service.ErrMessageChatNotFound):
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusNotFound,
|
||||
dto.ErrorCodeNotFound,
|
||||
"chat not found",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
case errors.Is(err, service.ErrInvalidCursor):
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"invalid cursor",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
case err != nil:
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
items := make([]dto.MessageResponse, 0, len(messages))
|
||||
for _, m := range messages {
|
||||
items = append(items, dto.ToMessageResponse(m))
|
||||
}
|
||||
|
||||
httpx.WriteJSON(w, http.StatusOK, dto.MessagePageResponse{
|
||||
Items: items,
|
||||
NextCursor: nextCursor,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
package handler
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
"mtusi2026-messenger/internal/httpx"
|
||||
"mtusi2026-messenger/internal/middleware"
|
||||
"mtusi2026-messenger/internal/service"
|
||||
)
|
||||
|
||||
type UserHandler struct {
|
||||
service *service.UserService
|
||||
}
|
||||
|
||||
func NewUserHandler(service *service.UserService) *UserHandler {
|
||||
return &UserHandler{service: service}
|
||||
}
|
||||
|
||||
func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
|
||||
var req dto.CreateUserRequest
|
||||
if !httpx.DecodeJSONBody(w, r, requestID, &req) {
|
||||
return
|
||||
}
|
||||
|
||||
if !req.Validate() {
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"invalid request body",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
user, err := h.service.Create(
|
||||
r.Context(),
|
||||
req.Username,
|
||||
req.DisplayName,
|
||||
req.Password,
|
||||
)
|
||||
if errors.Is(err, service.ErrUsernameTaken) {
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusConflict,
|
||||
dto.ErrorCodeConflict,
|
||||
"username already taken",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
httpx.WriteJSON(w, http.StatusCreated, dto.UserResponse{
|
||||
ID: user.ID,
|
||||
Username: user.Username,
|
||||
DisplayName: user.DisplayName,
|
||||
CreatedAt: user.CreatedAt,
|
||||
})
|
||||
}
|
||||
|
||||
func (h *UserHandler) Me(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := middleware.GetRequestID(r.Context())
|
||||
userID := middleware.GetUserID(r.Context())
|
||||
|
||||
user, err := h.service.GetByID(r.Context(), userID)
|
||||
if errors.Is(err, service.ErrUserNotFound) {
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusNotFound,
|
||||
dto.ErrorCodeNotFound,
|
||||
"user not found",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
httpx.WriteJSON(w, http.StatusOK, dto.UserResponse{
|
||||
ID: user.ID,
|
||||
Username: user.Username,
|
||||
DisplayName: user.DisplayName,
|
||||
CreatedAt: user.CreatedAt,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
package httpx
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
)
|
||||
|
||||
const (
|
||||
BasicChallenge = `Basic realm="messenger", charset="UTF-8"`
|
||||
BearerChallenge = `Bearer realm="messenger"`
|
||||
)
|
||||
|
||||
func BearerToken(r *http.Request) (string, bool) {
|
||||
const prefix = "Bearer "
|
||||
|
||||
header := r.Header.Get("Authorization")
|
||||
if len(header) <= len(prefix) || !strings.EqualFold(header[:len(prefix)], prefix) {
|
||||
return "", false
|
||||
}
|
||||
|
||||
token := strings.TrimSpace(header[len(prefix):])
|
||||
|
||||
return token, token != ""
|
||||
}
|
||||
|
||||
func WriteUnauthorized(w http.ResponseWriter, challenge, requestID string) {
|
||||
w.Header().Set("WWW-Authenticate", challenge)
|
||||
WriteError(
|
||||
w,
|
||||
http.StatusUnauthorized,
|
||||
dto.ErrorCodeUnauthorized,
|
||||
"unauthorized",
|
||||
requestID,
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package httpx
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strconv"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
)
|
||||
|
||||
func ParsePagination(w http.ResponseWriter, r *http.Request, requestID string) (limit int, cursor *string, ok bool) {
|
||||
q := r.URL.Query()
|
||||
|
||||
limit = 50
|
||||
if raw := q.Get("limit"); raw != "" {
|
||||
v, err := strconv.Atoi(raw)
|
||||
if err != nil || v < 1 || v > 100 {
|
||||
WriteError(
|
||||
w,
|
||||
http.StatusBadRequest,
|
||||
dto.ErrorCodeInvalidRequest,
|
||||
"limit must be an integer between 1 and 100",
|
||||
requestID,
|
||||
)
|
||||
return 0, nil, false
|
||||
}
|
||||
limit = v
|
||||
}
|
||||
|
||||
if raw := q.Get("cursor"); raw != "" {
|
||||
cursor = &raw
|
||||
}
|
||||
|
||||
return limit, cursor, true
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package httpx
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"mime"
|
||||
"net/http"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
)
|
||||
|
||||
func DecodeJSONBody(w http.ResponseWriter, r *http.Request, requestID string, dst any) bool {
|
||||
if ct := r.Header.Get("Content-Type"); ct != "" {
|
||||
mt, _, err := mime.ParseMediaType(ct)
|
||||
if err != nil || mt != "application/json" {
|
||||
WriteError(w, http.StatusUnsupportedMediaType, dto.ErrorCodeUnsupportedMediaType, "expected application/json", requestID)
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
decoder := json.NewDecoder(r.Body)
|
||||
decoder.DisallowUnknownFields()
|
||||
|
||||
if err := decoder.Decode(dst); err != nil {
|
||||
WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid request body", requestID)
|
||||
return false
|
||||
}
|
||||
|
||||
if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
|
||||
WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid request body", requestID)
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
package httpx
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
)
|
||||
|
||||
func WriteJSON(w http.ResponseWriter, status int, body any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(body)
|
||||
}
|
||||
|
||||
func WriteError(w http.ResponseWriter, status int, code dto.ErrorCode, message, requestID string) {
|
||||
WriteJSON(w, status, dto.ErrorResponse{
|
||||
Error: dto.Error{
|
||||
Code: code,
|
||||
Message: message,
|
||||
RequestID: requestID,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
func WriteInternalError(w http.ResponseWriter, requestID string, err error) {
|
||||
if isUnavailable(err) {
|
||||
WriteError(
|
||||
w,
|
||||
http.StatusServiceUnavailable,
|
||||
dto.ErrorCodeUnavailable,
|
||||
"dependency unavailable",
|
||||
requestID,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
WriteError(
|
||||
w,
|
||||
http.StatusInternalServerError,
|
||||
dto.ErrorCodeInternalError,
|
||||
"internal server error",
|
||||
requestID,
|
||||
)
|
||||
}
|
||||
|
||||
func isUnavailable(err error) bool {
|
||||
if errors.Is(err, context.DeadlineExceeded) {
|
||||
return true
|
||||
}
|
||||
|
||||
if _, ok := errors.AsType[net.Error](err); ok {
|
||||
return true
|
||||
}
|
||||
|
||||
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok {
|
||||
return strings.HasPrefix(pgErr.Code, "08") || pgErr.Code == "57P01"
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package logger
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
"os"
|
||||
)
|
||||
|
||||
func New(level slog.Level) *slog.Logger {
|
||||
return slog.New(
|
||||
slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
|
||||
Level: level,
|
||||
}),
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net/http"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026-messenger/internal/httpx"
|
||||
"mtusi2026-messenger/internal/service"
|
||||
)
|
||||
|
||||
type userIDContextKey struct{}
|
||||
|
||||
type authenticator interface {
|
||||
Authenticate(ctx context.Context, token string) (uuid.UUID, error)
|
||||
}
|
||||
|
||||
func Auth(auth authenticator) func(http.Handler) http.Handler {
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := GetRequestID(r.Context())
|
||||
|
||||
token, ok := httpx.BearerToken(r)
|
||||
if !ok {
|
||||
httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID)
|
||||
return
|
||||
}
|
||||
|
||||
userID, err := auth.Authenticate(r.Context(), token)
|
||||
if errors.Is(err, service.ErrUnauthorized) {
|
||||
httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
httpx.WriteInternalError(w, requestID, err)
|
||||
return
|
||||
}
|
||||
|
||||
ctx := context.WithValue(r.Context(), userIDContextKey{}, userID)
|
||||
next.ServeHTTP(w, r.WithContext(ctx))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func GetUserID(ctx context.Context) uuid.UUID {
|
||||
id, _ := ctx.Value(userIDContextKey{}).(uuid.UUID)
|
||||
return id
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
"mtusi2026-messenger/internal/httpx"
|
||||
)
|
||||
|
||||
func ConcurrencyLimit(max int) func(http.Handler) http.Handler {
|
||||
if max <= 0 {
|
||||
return func(next http.Handler) http.Handler {
|
||||
return next
|
||||
}
|
||||
}
|
||||
|
||||
slots := make(chan struct{}, max)
|
||||
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
select {
|
||||
case slots <- struct{}{}:
|
||||
defer func() {
|
||||
<-slots
|
||||
}()
|
||||
|
||||
next.ServeHTTP(w, r)
|
||||
|
||||
default:
|
||||
w.Header().Set("Retry-After", "1")
|
||||
httpx.WriteError(
|
||||
w,
|
||||
http.StatusTooManyRequests,
|
||||
dto.ErrorCodeRateLimited,
|
||||
"too many requests",
|
||||
GetRequestID(r.Context()),
|
||||
)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
type responseWriter struct {
|
||||
http.ResponseWriter
|
||||
status int
|
||||
}
|
||||
|
||||
func (w *responseWriter) WriteHeader(status int) {
|
||||
w.status = status
|
||||
w.ResponseWriter.WriteHeader(status)
|
||||
}
|
||||
|
||||
func Logging(log *slog.Logger) func(http.Handler) http.Handler {
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
start := time.Now()
|
||||
|
||||
writer := &responseWriter{
|
||||
ResponseWriter: w,
|
||||
status: http.StatusOK,
|
||||
}
|
||||
|
||||
next.ServeHTTP(writer, r)
|
||||
|
||||
level := slog.LevelInfo
|
||||
|
||||
switch {
|
||||
case writer.status >= 500:
|
||||
level = slog.LevelError
|
||||
case writer.status >= 400:
|
||||
level = slog.LevelWarn
|
||||
}
|
||||
|
||||
log.Log(r.Context(), level, "http request",
|
||||
"request_id", GetRequestID(r.Context()),
|
||||
"method", r.Method,
|
||||
"path", r.URL.Path,
|
||||
"status", writer.status,
|
||||
"duration_ms", time.Since(start).Milliseconds(),
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type requestIDContextKey struct{}
|
||||
|
||||
func RequestID(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
requestID := r.Header.Get("X-Request-Id")
|
||||
|
||||
if requestID == "" {
|
||||
requestID = uuid.NewString()
|
||||
}
|
||||
|
||||
w.Header().Set("X-Request-Id", requestID)
|
||||
|
||||
ctx := context.WithValue(r.Context(), requestIDContextKey{}, requestID)
|
||||
next.ServeHTTP(w, r.WithContext(ctx))
|
||||
})
|
||||
}
|
||||
|
||||
func GetRequestID(ctx context.Context) string {
|
||||
id, _ := ctx.Value(requestIDContextKey{}).(string)
|
||||
return id
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
func RequestTimeout(d time.Duration) func(http.Handler) http.Handler {
|
||||
return func(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
ctx, cancel := context.WithTimeout(r.Context(), d)
|
||||
defer cancel()
|
||||
next.ServeHTTP(w, r.WithContext(ctx))
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type Chat struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
MemberIDs []uuid.UUID
|
||||
CreatedAt time.Time
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type Message struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package model
|
||||
|
||||
import "time"
|
||||
|
||||
type Session struct {
|
||||
Token string
|
||||
ExpiresAt time.Time
|
||||
User User
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package model
|
||||
|
||||
import (
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
type User struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package postgres
|
||||
|
||||
import (
|
||||
"errors"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
)
|
||||
|
||||
const (
|
||||
CodeUniqueViolation = "23505"
|
||||
CodeForeignKeyViolation = "23503"
|
||||
CodeCheckViolation = "23514"
|
||||
)
|
||||
|
||||
func ErrCode(err error) string {
|
||||
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok {
|
||||
return pgErr.Code
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func IsNotFound(err error) bool {
|
||||
return errors.Is(err, pgx.ErrNoRows)
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package postgres
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
func New(ctx context.Context, url string) (*pgxpool.Pool, error) {
|
||||
cfg, err := pgxpool.ParseConfig(url)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse database url: %w", err)
|
||||
}
|
||||
|
||||
cfg.MaxConns = 10
|
||||
cfg.ConnConfig.ConnectTimeout = 5 * time.Second
|
||||
cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000"
|
||||
|
||||
pool, err := pgxpool.NewWithConfig(ctx, cfg)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("create pool: %w", err)
|
||||
}
|
||||
|
||||
pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
defer cancel()
|
||||
if err := pool.Ping(pingCtx); err != nil {
|
||||
pool.Close()
|
||||
return nil, fmt.Errorf("ping database: %w", err)
|
||||
}
|
||||
|
||||
return pool, nil
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package redis
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"time"
|
||||
|
||||
goredis "github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
func New(ctx context.Context, log *slog.Logger, url string) (*goredis.Client, error) {
|
||||
opts, err := goredis.ParseURL(url)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse redis url: %w", err)
|
||||
}
|
||||
|
||||
opts.DialTimeout = 1 * time.Second
|
||||
opts.ReadTimeout = 200 * time.Millisecond
|
||||
opts.WriteTimeout = 200 * time.Millisecond
|
||||
opts.MaxRetries = -1
|
||||
|
||||
client := goredis.NewClient(opts)
|
||||
|
||||
pingCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
|
||||
defer cancel()
|
||||
if err := client.Ping(pingCtx).Err(); err != nil {
|
||||
log.Warn("redis unavailable, running without cache", "error", err)
|
||||
}
|
||||
|
||||
return client, nil
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"log/slog"
|
||||
"time"
|
||||
|
||||
"mtusi2026-messenger/internal/credentials"
|
||||
"mtusi2026-messenger/internal/db"
|
||||
"mtusi2026-messenger/internal/model"
|
||||
"mtusi2026-messenger/internal/postgres"
|
||||
|
||||
"github.com/google/uuid"
|
||||
goredis "github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
const sessionCacheTTL = 60 * time.Second
|
||||
const cacheOpTimeout = 300 * time.Millisecond
|
||||
|
||||
var (
|
||||
ErrInvalidCredentials = errors.New("invalid credentials")
|
||||
ErrUnauthorized = errors.New("unauthorized")
|
||||
)
|
||||
|
||||
type authQueries interface {
|
||||
CreateSession(ctx context.Context, arg db.CreateSessionParams) error
|
||||
DeleteSession(ctx context.Context, tokenHash string) (int64, error)
|
||||
GetActiveSession(ctx context.Context, tokenHash string) (db.GetActiveSessionRow, error)
|
||||
GetUserByUsername(ctx context.Context, username string) (db.User, error)
|
||||
}
|
||||
|
||||
type AuthService struct {
|
||||
q authQueries
|
||||
cache *goredis.Client
|
||||
sessionTTL time.Duration
|
||||
log *slog.Logger
|
||||
}
|
||||
|
||||
func NewAuthService(q authQueries, cache *goredis.Client, sessionTTL time.Duration, log *slog.Logger) *AuthService {
|
||||
return &AuthService{
|
||||
q: q,
|
||||
cache: cache,
|
||||
sessionTTL: sessionTTL,
|
||||
log: log,
|
||||
}
|
||||
}
|
||||
|
||||
var dummyHash, _ = credentials.HashPassword("dummy-password-for-timing")
|
||||
|
||||
func (s *AuthService) Login(ctx context.Context, username, plain string) (model.Session, error) {
|
||||
user, err := s.q.GetUserByUsername(ctx, username)
|
||||
if postgres.IsNotFound(err) {
|
||||
_ = credentials.VerifyPassword(dummyHash, plain)
|
||||
return model.Session{}, ErrInvalidCredentials
|
||||
}
|
||||
if err != nil {
|
||||
return model.Session{}, err
|
||||
}
|
||||
|
||||
if err := credentials.VerifyPassword(user.PasswordHash, plain); err != nil {
|
||||
if errors.Is(err, credentials.ErrPasswordMismatch) {
|
||||
return model.Session{}, ErrInvalidCredentials
|
||||
}
|
||||
return model.Session{}, err
|
||||
}
|
||||
|
||||
token := credentials.NewToken()
|
||||
expiresAt := time.Now().UTC().Add(s.sessionTTL)
|
||||
|
||||
err = s.q.CreateSession(ctx, db.CreateSessionParams{
|
||||
TokenHash: credentials.HashToken(token),
|
||||
UserID: user.ID,
|
||||
ExpiresAt: expiresAt,
|
||||
})
|
||||
if err != nil {
|
||||
return model.Session{}, err
|
||||
}
|
||||
|
||||
return model.Session{
|
||||
Token: token,
|
||||
ExpiresAt: expiresAt,
|
||||
User: model.User{
|
||||
ID: user.ID,
|
||||
Username: user.Username,
|
||||
DisplayName: user.DisplayName,
|
||||
CreatedAt: user.CreatedAt.UTC(),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *AuthService) Authenticate(ctx context.Context, token string) (uuid.UUID, error) {
|
||||
tokenHash := credentials.HashToken(token)
|
||||
key := cacheKey(tokenHash)
|
||||
|
||||
cctx, cancel := context.WithTimeout(ctx, cacheOpTimeout)
|
||||
val, err := s.cache.Get(cctx, key).Result()
|
||||
cancel()
|
||||
|
||||
if err == nil {
|
||||
id, perr := uuid.Parse(val)
|
||||
if perr == nil {
|
||||
return id, nil
|
||||
}
|
||||
s.log.Warn("session cache value is not a uuid", "error", perr)
|
||||
} else if !errors.Is(err, goredis.Nil) {
|
||||
s.log.Warn("session cache get failed, falling back to database", "error", err)
|
||||
}
|
||||
|
||||
row, err := s.q.GetActiveSession(ctx, tokenHash)
|
||||
if postgres.IsNotFound(err) {
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
if err != nil {
|
||||
return uuid.Nil, err
|
||||
}
|
||||
|
||||
ttl := min(time.Until(row.ExpiresAt), sessionCacheTTL)
|
||||
if ttl > 0 {
|
||||
cctx, cancel = context.WithTimeout(ctx, cacheOpTimeout)
|
||||
if err := s.cache.Set(cctx, key, row.UserID.String(), ttl).Err(); err != nil {
|
||||
s.log.Warn("session cache set failed", "error", err)
|
||||
}
|
||||
cancel()
|
||||
}
|
||||
|
||||
return row.UserID, nil
|
||||
}
|
||||
|
||||
func (s *AuthService) Logout(ctx context.Context, token string) error {
|
||||
tokenHash := credentials.HashToken(token)
|
||||
|
||||
n, err := s.q.DeleteSession(ctx, tokenHash)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
cctx, cancel := context.WithTimeout(ctx, cacheOpTimeout)
|
||||
defer cancel()
|
||||
if err := s.cache.Del(cctx, cacheKey(tokenHash)).Err(); err != nil {
|
||||
s.log.Warn("session cache delete failed", "error", err)
|
||||
}
|
||||
|
||||
if n == 0 {
|
||||
return ErrUnauthorized
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func cacheKey(tokenHash string) string {
|
||||
return "session:" + tokenHash
|
||||
}
|
||||
@@ -0,0 +1,208 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"slices"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"mtusi2026-messenger/internal/db"
|
||||
"mtusi2026-messenger/internal/model"
|
||||
"mtusi2026-messenger/internal/postgres"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrChatNotFound = errors.New("chat not found")
|
||||
ErrNotChatMember = errors.New("caller must be a member of member_ids")
|
||||
ErrDuplicateMember = errors.New("member_ids contains duplicates")
|
||||
ErrUnknownMember = errors.New("member_ids contains unknown user")
|
||||
)
|
||||
|
||||
type chatQueries interface {
|
||||
AddChatMembers(ctx context.Context, arg db.AddChatMembersParams) error
|
||||
CreateChat(ctx context.Context, arg db.CreateChatParams) (db.Chat, error)
|
||||
GetChat(ctx context.Context, arg db.GetChatParams) (db.GetChatRow, error)
|
||||
ListChatsAfter(ctx context.Context, arg db.ListChatsAfterParams) ([]db.ListChatsAfterRow, error)
|
||||
ListChatsFirstPage(ctx context.Context, arg db.ListChatsFirstPageParams) ([]db.ListChatsFirstPageRow, error)
|
||||
}
|
||||
|
||||
type txBeginner interface {
|
||||
Begin(ctx context.Context) (pgx.Tx, error)
|
||||
}
|
||||
|
||||
type ChatService struct {
|
||||
pool txBeginner
|
||||
q chatQueries
|
||||
withTx func(pgx.Tx) chatQueries
|
||||
}
|
||||
|
||||
func NewChatService(pool *pgxpool.Pool, q *db.Queries) *ChatService {
|
||||
return &ChatService{
|
||||
pool: pool,
|
||||
q: q,
|
||||
withTx: func(tx pgx.Tx) chatQueries {
|
||||
return q.WithTx(tx)
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ChatService) Create(
|
||||
ctx context.Context,
|
||||
userID uuid.UUID,
|
||||
title string,
|
||||
memberIDs []uuid.UUID,
|
||||
) (model.Chat, error) {
|
||||
if !slices.Contains(memberIDs, userID) {
|
||||
return model.Chat{}, ErrNotChatMember
|
||||
}
|
||||
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return model.Chat{}, err
|
||||
}
|
||||
defer tx.Rollback(ctx)
|
||||
|
||||
q := s.withTx(tx)
|
||||
|
||||
id, err := uuid.NewV7()
|
||||
if err != nil {
|
||||
return model.Chat{}, err
|
||||
}
|
||||
|
||||
row, err := q.CreateChat(ctx, db.CreateChatParams{
|
||||
ID: id,
|
||||
Title: title,
|
||||
})
|
||||
if err != nil {
|
||||
return model.Chat{}, err
|
||||
}
|
||||
|
||||
err = q.AddChatMembers(ctx, db.AddChatMembersParams{
|
||||
ChatID: row.ID,
|
||||
UserIds: memberIDs,
|
||||
})
|
||||
switch postgres.ErrCode(err) {
|
||||
case postgres.CodeUniqueViolation:
|
||||
return model.Chat{}, ErrDuplicateMember
|
||||
case postgres.CodeForeignKeyViolation:
|
||||
return model.Chat{}, ErrUnknownMember
|
||||
}
|
||||
if err != nil {
|
||||
return model.Chat{}, err
|
||||
}
|
||||
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return model.Chat{}, err
|
||||
}
|
||||
|
||||
ids := slices.Clone(memberIDs)
|
||||
slices.SortFunc(ids, func(a, b uuid.UUID) int {
|
||||
return bytes.Compare(a[:], b[:])
|
||||
})
|
||||
|
||||
return model.Chat{
|
||||
ID: row.ID,
|
||||
Title: row.Title,
|
||||
CreatedAt: row.CreatedAt,
|
||||
MemberIDs: ids,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *ChatService) Get(
|
||||
ctx context.Context,
|
||||
userID uuid.UUID,
|
||||
chatID uuid.UUID,
|
||||
) (model.Chat, error) {
|
||||
row, err := s.q.GetChat(ctx, db.GetChatParams{
|
||||
ID: chatID,
|
||||
UserID: userID,
|
||||
})
|
||||
if postgres.IsNotFound(err) {
|
||||
return model.Chat{}, ErrChatNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return model.Chat{}, err
|
||||
}
|
||||
|
||||
return model.Chat{
|
||||
ID: row.ID,
|
||||
Title: row.Title,
|
||||
CreatedAt: row.CreatedAt,
|
||||
MemberIDs: row.MemberIds,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *ChatService) List(
|
||||
ctx context.Context,
|
||||
userID uuid.UUID,
|
||||
limit int,
|
||||
cursor *string,
|
||||
) ([]model.Chat, *string, error) {
|
||||
var chats []model.Chat
|
||||
|
||||
if cursor == nil {
|
||||
rows, err := s.q.ListChatsFirstPage(ctx, db.ListChatsFirstPageParams{
|
||||
UserID: userID,
|
||||
Lim: int32(limit + 1),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
chats = make([]model.Chat, 0, len(rows))
|
||||
for _, r := range rows {
|
||||
chats = append(chats, model.Chat{
|
||||
ID: r.ID,
|
||||
Title: r.Title,
|
||||
CreatedAt: r.CreatedAt,
|
||||
MemberIDs: r.MemberIds,
|
||||
})
|
||||
}
|
||||
} else {
|
||||
decoded, derr := decodeCursor(*cursor, uuid.Nil)
|
||||
if derr != nil {
|
||||
return nil, nil, ErrInvalidCursor
|
||||
}
|
||||
|
||||
rows, err := s.q.ListChatsAfter(ctx, db.ListChatsAfterParams{
|
||||
UserID: userID,
|
||||
AfterCreatedAt: decoded.CreatedAt,
|
||||
AfterID: decoded.ID,
|
||||
Lim: int32(limit + 1),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
chats = make([]model.Chat, 0, len(rows))
|
||||
for _, r := range rows {
|
||||
chats = append(chats, model.Chat{
|
||||
ID: r.ID,
|
||||
Title: r.Title,
|
||||
CreatedAt: r.CreatedAt,
|
||||
MemberIDs: r.MemberIds,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
hasMore := len(chats) > limit
|
||||
if hasMore {
|
||||
chats = chats[:limit]
|
||||
}
|
||||
|
||||
var next *string
|
||||
if hasMore {
|
||||
last := chats[len(chats)-1]
|
||||
c := encodeCursor(Cursor{
|
||||
CreatedAt: last.CreatedAt,
|
||||
ID: last.ID,
|
||||
})
|
||||
next = &c
|
||||
}
|
||||
|
||||
return chats, next, nil
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
var ErrInvalidCursor = errors.New("invalid cursor")
|
||||
|
||||
type Cursor struct {
|
||||
ChatID uuid.UUID `json:"chat_id"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
ID uuid.UUID `json:"id"`
|
||||
}
|
||||
|
||||
func encodeCursor(cursor Cursor) string {
|
||||
data, _ := json.Marshal(cursor)
|
||||
return base64.RawURLEncoding.EncodeToString(data)
|
||||
}
|
||||
|
||||
func decodeCursor(raw string, chatID uuid.UUID) (Cursor, error) {
|
||||
data, err := base64.RawURLEncoding.DecodeString(raw)
|
||||
if err != nil {
|
||||
return Cursor{}, ErrInvalidCursor
|
||||
}
|
||||
|
||||
var cursor Cursor
|
||||
if err := json.Unmarshal(data, &cursor); err != nil {
|
||||
return Cursor{}, ErrInvalidCursor
|
||||
}
|
||||
|
||||
if cursor.ID == uuid.Nil || cursor.CreatedAt.IsZero() || cursor.ChatID != chatID {
|
||||
return Cursor{}, ErrInvalidCursor
|
||||
}
|
||||
|
||||
return cursor, nil
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026-messenger/internal/db"
|
||||
"mtusi2026-messenger/internal/model"
|
||||
"mtusi2026-messenger/internal/postgres"
|
||||
)
|
||||
|
||||
var ErrMessageChatNotFound = errors.New("chat not found")
|
||||
|
||||
type messageQueries interface {
|
||||
CreateMessage(ctx context.Context, arg db.CreateMessageParams) (db.Message, error)
|
||||
IsChatMember(ctx context.Context, arg db.IsChatMemberParams) (bool, error)
|
||||
ListMessagesAfter(ctx context.Context, arg db.ListMessagesAfterParams) ([]db.Message, error)
|
||||
ListMessagesFirstPage(ctx context.Context, arg db.ListMessagesFirstPageParams) ([]db.Message, error)
|
||||
}
|
||||
|
||||
type MessageService struct {
|
||||
q messageQueries
|
||||
}
|
||||
|
||||
func NewMessageService(q *db.Queries) *MessageService {
|
||||
return &MessageService{q: q}
|
||||
}
|
||||
|
||||
func (s *MessageService) Create(
|
||||
ctx context.Context,
|
||||
userID uuid.UUID,
|
||||
chatID uuid.UUID,
|
||||
text string,
|
||||
) (model.Message, error) {
|
||||
id, err := uuid.NewV7()
|
||||
if err != nil {
|
||||
return model.Message{}, err
|
||||
}
|
||||
|
||||
row, err := s.q.CreateMessage(ctx, db.CreateMessageParams{
|
||||
ID: id,
|
||||
ChatID: chatID,
|
||||
SenderID: userID,
|
||||
Text: text,
|
||||
})
|
||||
if postgres.IsNotFound(err) {
|
||||
return model.Message{}, ErrMessageChatNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return model.Message{}, err
|
||||
}
|
||||
|
||||
return model.Message{
|
||||
ID: row.ID,
|
||||
ChatID: row.ChatID,
|
||||
SenderID: row.SenderID,
|
||||
Text: row.Text,
|
||||
CreatedAt: row.CreatedAt,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *MessageService) List(
|
||||
ctx context.Context,
|
||||
userID uuid.UUID,
|
||||
chatID uuid.UUID,
|
||||
limit int,
|
||||
cursor *string,
|
||||
) ([]model.Message, *string, error) {
|
||||
isMember, err := s.q.IsChatMember(ctx, db.IsChatMemberParams{
|
||||
ChatID: chatID,
|
||||
UserID: userID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
if !isMember {
|
||||
return nil, nil, ErrMessageChatNotFound
|
||||
}
|
||||
|
||||
var rows []db.Message
|
||||
|
||||
if cursor == nil {
|
||||
rows, err = s.q.ListMessagesFirstPage(ctx, db.ListMessagesFirstPageParams{
|
||||
ChatID: chatID,
|
||||
Lim: int32(limit + 1),
|
||||
})
|
||||
} else {
|
||||
decoded, derr := decodeCursor(*cursor, chatID)
|
||||
if derr != nil {
|
||||
return nil, nil, ErrInvalidCursor
|
||||
}
|
||||
|
||||
rows, err = s.q.ListMessagesAfter(ctx, db.ListMessagesAfterParams{
|
||||
ChatID: chatID,
|
||||
AfterCreatedAt: decoded.CreatedAt,
|
||||
AfterID: decoded.ID,
|
||||
Lim: int32(limit + 1),
|
||||
})
|
||||
}
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
hasMore := len(rows) > limit
|
||||
if hasMore {
|
||||
rows = rows[:limit]
|
||||
}
|
||||
|
||||
messages := make([]model.Message, 0, len(rows))
|
||||
for _, r := range rows {
|
||||
messages = append(messages, model.Message{
|
||||
ID: r.ID,
|
||||
ChatID: r.ChatID,
|
||||
SenderID: r.SenderID,
|
||||
Text: r.Text,
|
||||
CreatedAt: r.CreatedAt,
|
||||
})
|
||||
}
|
||||
|
||||
var next *string
|
||||
if hasMore {
|
||||
last := messages[len(messages)-1]
|
||||
c := encodeCursor(Cursor{
|
||||
ChatID: chatID,
|
||||
CreatedAt: last.CreatedAt,
|
||||
ID: last.ID,
|
||||
})
|
||||
next = &c
|
||||
}
|
||||
|
||||
return messages, next, nil
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026-messenger/internal/credentials"
|
||||
"mtusi2026-messenger/internal/db"
|
||||
"mtusi2026-messenger/internal/model"
|
||||
"mtusi2026-messenger/internal/postgres"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrUsernameTaken = errors.New("username already taken")
|
||||
ErrUserNotFound = errors.New("user not found")
|
||||
)
|
||||
|
||||
type userQueries interface {
|
||||
CreateUser(ctx context.Context, arg db.CreateUserParams) (db.CreateUserRow, error)
|
||||
GetUser(ctx context.Context, id uuid.UUID) (db.GetUserRow, error)
|
||||
}
|
||||
|
||||
type UserService struct {
|
||||
q userQueries
|
||||
}
|
||||
|
||||
func NewUserService(q userQueries) *UserService {
|
||||
return &UserService{q: q}
|
||||
}
|
||||
|
||||
func (s *UserService) Create(
|
||||
ctx context.Context,
|
||||
username, displayName, plain string,
|
||||
) (model.User, error) {
|
||||
hash, err := credentials.HashPassword(plain)
|
||||
if err != nil {
|
||||
return model.User{}, err
|
||||
}
|
||||
|
||||
id, err := uuid.NewV7()
|
||||
if err != nil {
|
||||
return model.User{}, err
|
||||
}
|
||||
|
||||
row, err := s.q.CreateUser(ctx, db.CreateUserParams{
|
||||
ID: id,
|
||||
Username: username,
|
||||
DisplayName: displayName,
|
||||
PasswordHash: hash,
|
||||
})
|
||||
if err != nil {
|
||||
if postgres.ErrCode(err) == postgres.CodeUniqueViolation {
|
||||
return model.User{}, ErrUsernameTaken
|
||||
}
|
||||
return model.User{}, err
|
||||
}
|
||||
|
||||
return model.User{
|
||||
ID: row.ID,
|
||||
Username: row.Username,
|
||||
DisplayName: row.DisplayName,
|
||||
CreatedAt: row.CreatedAt.UTC(),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *UserService) GetByID(ctx context.Context, id uuid.UUID) (model.User, error) {
|
||||
row, err := s.q.GetUser(ctx, id)
|
||||
if postgres.IsNotFound(err) {
|
||||
return model.User{}, ErrUserNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return model.User{}, err
|
||||
}
|
||||
|
||||
return model.User{
|
||||
ID: row.ID,
|
||||
Username: row.Username,
|
||||
DisplayName: row.DisplayName,
|
||||
CreatedAt: row.CreatedAt.UTC(),
|
||||
}, nil
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
docker compose restart postgres redis api
|
||||
@@ -0,0 +1,30 @@
|
||||
version: "2"
|
||||
sql:
|
||||
- engine: "postgresql"
|
||||
queries: "db/queries"
|
||||
schema: "db/migrations"
|
||||
gen:
|
||||
go:
|
||||
package: "db"
|
||||
out: "internal/db"
|
||||
sql_package: "pgx/v5"
|
||||
emit_empty_slices: true
|
||||
emit_pointers_for_null_types: true
|
||||
overrides:
|
||||
- db_type: "uuid"
|
||||
go_type: "github.com/google/uuid.UUID"
|
||||
- db_type: "uuid"
|
||||
nullable: true
|
||||
go_type:
|
||||
import: "github.com/google/uuid"
|
||||
type: "UUID"
|
||||
pointer: true
|
||||
|
||||
- db_type: "timestamptz"
|
||||
go_type: "time.Time"
|
||||
- db_type: "timestamptz"
|
||||
nullable: true
|
||||
go_type:
|
||||
import: "time"
|
||||
type: "Time"
|
||||
pointer: true
|
||||
@@ -0,0 +1,55 @@
|
||||
//go:build contract
|
||||
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
func TestCreateChatRollback(t *testing.T) {
|
||||
data, err := os.ReadFile("../secrets/test_database_url.txt")
|
||||
if err != nil {
|
||||
t.Fatalf("read secrets/test_database_url: %v", err)
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
conn, err := pgx.Connect(ctx, strings.TrimSpace(string(data)))
|
||||
if err != nil {
|
||||
t.Fatalf("connect to database: %v", err)
|
||||
}
|
||||
defer conn.Close(ctx)
|
||||
|
||||
creator := createUser(t)
|
||||
title := "rollback-" + uuid.NewString()
|
||||
|
||||
body, err := json.Marshal(map[string]any{
|
||||
"title": title,
|
||||
"member_ids": []uuid.UUID{creator.ID, uuid.New()},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("marshal body: %v", err)
|
||||
}
|
||||
|
||||
resp := doRequest(t, http.MethodPost, "/api/v1/chats", creator.Token, body)
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode < 400 || resp.StatusCode >= 500 {
|
||||
t.Fatalf("expected 4xx, got %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
var n int
|
||||
err = conn.QueryRow(ctx, "SELECT count(*) FROM chats WHERE title = $1", title).Scan(&n)
|
||||
if err != nil {
|
||||
t.Fatalf("count chats: %v", err)
|
||||
}
|
||||
if n != 0 {
|
||||
t.Fatalf("expected no chat rows after failed creation, found %d", n)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
//go:build contract
|
||||
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"testing"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
)
|
||||
|
||||
func TestInvalidJSON(t *testing.T) {
|
||||
resp := doRequest(t, http.MethodPost, "/api/v1/users", "", []byte(`{"username": "broken",`))
|
||||
requireStatus(t, resp, http.StatusBadRequest)
|
||||
|
||||
var apiErr dto.ErrorResponse
|
||||
mustDecode(t, resp, &apiErr)
|
||||
|
||||
if apiErr.Error.Code != dto.ErrorCodeInvalidRequest {
|
||||
t.Errorf("expected code %q, got %q", dto.ErrorCodeInvalidRequest, apiErr.Error.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestForeignChat(t *testing.T) {
|
||||
user1 := createUser(t)
|
||||
user2 := createUser(t)
|
||||
user3 := createUser(t)
|
||||
|
||||
chat := createChat(t, user1, user1.ID, user2.ID)
|
||||
|
||||
resp := doRequest(t, http.MethodGet, "/api/v1/chats/"+chat.ID.String(), user3.Token, nil)
|
||||
requireStatus(t, resp, http.StatusNotFound)
|
||||
|
||||
resp = sendMessage(t, user3, chat.ID, "should not land")
|
||||
requireStatus(t, resp, http.StatusNotFound)
|
||||
}
|
||||
|
||||
func TestEmptyMessage(t *testing.T) {
|
||||
user := createUser(t)
|
||||
chat := createChat(t, user, user.ID)
|
||||
|
||||
for _, text := range []string{"", " ", "\t\n"} {
|
||||
resp := sendMessage(t, user, chat.ID, text)
|
||||
requireStatus(t, resp, http.StatusBadRequest)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDuplicateUsername(t *testing.T) {
|
||||
user := createUser(t)
|
||||
|
||||
body, err := json.Marshal(map[string]string{
|
||||
"username": user.Username,
|
||||
"display_name": "Someone else",
|
||||
"password": testPassword,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("marshal body: %v", err)
|
||||
}
|
||||
|
||||
resp := doRequest(t, http.MethodPost, "/api/v1/users", "", body)
|
||||
requireStatus(t, resp, http.StatusConflict)
|
||||
|
||||
var apiErr dto.ErrorResponse
|
||||
mustDecode(t, resp, &apiErr)
|
||||
|
||||
if apiErr.Error.Code != dto.ErrorCodeConflict {
|
||||
t.Errorf("expected code %q, got %q", dto.ErrorCodeConflict, apiErr.Error.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPagination(t *testing.T) {
|
||||
user := createUser(t)
|
||||
chat := createChat(t, user, user.ID)
|
||||
|
||||
const total = 25
|
||||
const pageSize = 4
|
||||
|
||||
sent := make(map[string]bool, total)
|
||||
for i := 0; i < total; i++ {
|
||||
resp := sendMessage(t, user, chat.ID, "msg")
|
||||
requireStatus(t, resp, http.StatusCreated)
|
||||
|
||||
var msg dto.MessageResponse
|
||||
mustDecode(t, resp, &msg)
|
||||
sent[msg.ID.String()] = true
|
||||
}
|
||||
|
||||
seen := make(map[string]bool, total)
|
||||
cursor := ""
|
||||
pages := 0
|
||||
|
||||
for {
|
||||
path := "/api/v1/chats/" + chat.ID.String() + "/messages?limit=" + strconv.Itoa(pageSize)
|
||||
if cursor != "" {
|
||||
path += "&cursor=" + url.QueryEscape(cursor)
|
||||
}
|
||||
|
||||
resp := doRequest(t, http.MethodGet, path, user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusOK)
|
||||
|
||||
var page dto.MessagePageResponse
|
||||
mustDecode(t, resp, &page)
|
||||
pages++
|
||||
|
||||
for _, msg := range page.Items {
|
||||
id := msg.ID.String()
|
||||
if seen[id] {
|
||||
t.Fatalf("duplicate message id across pages: %s", id)
|
||||
}
|
||||
seen[id] = true
|
||||
}
|
||||
|
||||
if page.NextCursor == nil {
|
||||
break
|
||||
}
|
||||
cursor = *page.NextCursor
|
||||
|
||||
if pages > total {
|
||||
t.Fatalf("too many pages: got %d, expected at most %d", pages, total)
|
||||
}
|
||||
}
|
||||
|
||||
if len(seen) != total {
|
||||
t.Fatalf("expected %d unique messages across all pages, got %d", total, len(seen))
|
||||
}
|
||||
for id := range sent {
|
||||
if !seen[id] {
|
||||
t.Fatalf("message %s sent but never seen while paginating", id)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
//go:build failure
|
||||
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"os/exec"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func compose(t *testing.T, args ...string) {
|
||||
t.Helper()
|
||||
|
||||
cmd := exec.Command("docker", append([]string{"compose"}, args...)...)
|
||||
cmd.Dir = ".."
|
||||
if out, err := cmd.CombinedOutput(); err != nil {
|
||||
t.Fatalf("docker compose %v: %v\n%s", args, err, out)
|
||||
}
|
||||
}
|
||||
|
||||
func stopService(t *testing.T, name string) {
|
||||
t.Helper()
|
||||
|
||||
compose(t, "stop", name)
|
||||
t.Cleanup(func() {
|
||||
compose(t, "start", name)
|
||||
waitReady(t)
|
||||
})
|
||||
}
|
||||
|
||||
func waitReady(t *testing.T) {
|
||||
t.Helper()
|
||||
|
||||
deadline := time.Now().Add(60 * time.Second)
|
||||
for time.Now().Before(deadline) {
|
||||
resp, err := httpClient.Get(*baseURL + "/health/ready")
|
||||
if err == nil {
|
||||
resp.Body.Close()
|
||||
if resp.StatusCode == http.StatusOK {
|
||||
return
|
||||
}
|
||||
}
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
}
|
||||
t.Fatal("service did not become ready in 60s")
|
||||
}
|
||||
|
||||
func TestRedisDown(t *testing.T) {
|
||||
user := createUser(t)
|
||||
|
||||
stopService(t, "redis")
|
||||
|
||||
// настоящий токен
|
||||
resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusOK)
|
||||
resp.Body.Close()
|
||||
|
||||
// выдуманный токен
|
||||
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "forged-"+user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusUnauthorized)
|
||||
resp.Body.Close()
|
||||
|
||||
// без токена
|
||||
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "", nil)
|
||||
requireStatus(t, resp, http.StatusUnauthorized)
|
||||
resp.Body.Close()
|
||||
}
|
||||
|
||||
func TestDatabaseDown(t *testing.T) {
|
||||
user := createUser(t) // токен ещё не использован, ключа в Redis нет
|
||||
|
||||
stopService(t, "postgres")
|
||||
|
||||
// ключа в кэше нет, проверить сессию негде
|
||||
resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusServiceUnavailable)
|
||||
resp.Body.Close()
|
||||
|
||||
// выдуманный токен
|
||||
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "forged-"+user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusServiceUnavailable)
|
||||
resp.Body.Close()
|
||||
|
||||
// без токена
|
||||
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "", nil)
|
||||
requireStatus(t, resp, http.StatusUnauthorized)
|
||||
resp.Body.Close()
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
)
|
||||
|
||||
var baseURL = flag.String("base-url", "http://127.0.0.1:8080", "base URL of the running server")
|
||||
|
||||
var httpClient = &http.Client{
|
||||
Timeout: 10 * time.Second,
|
||||
Transport: &http.Transport{
|
||||
MaxIdleConns: 200,
|
||||
IdleConnTimeout: 30 * time.Second,
|
||||
MaxIdleConnsPerHost: 200,
|
||||
MaxConnsPerHost: 200,
|
||||
},
|
||||
}
|
||||
|
||||
type testUser struct {
|
||||
dto.UserResponse
|
||||
Token string
|
||||
}
|
||||
|
||||
const testPassword = "correct-horse-battery"
|
||||
|
||||
func doRequest(t *testing.T, method, path, token string, body []byte) *http.Response {
|
||||
t.Helper()
|
||||
|
||||
req, err := http.NewRequest(method, *baseURL+path, bytes.NewReader(body))
|
||||
if err != nil {
|
||||
t.Fatalf("build request: %v", err)
|
||||
}
|
||||
|
||||
if body != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
|
||||
resp, err := httpClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("%s %s: request failed: %v", method, path, err)
|
||||
}
|
||||
|
||||
return resp
|
||||
}
|
||||
|
||||
func mustDecode(t *testing.T, resp *http.Response, dst any) {
|
||||
t.Helper()
|
||||
defer resp.Body.Close()
|
||||
|
||||
data, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
t.Fatalf("read body: %v", err)
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, dst); err != nil {
|
||||
t.Fatalf("decode body %q: %v", data, err)
|
||||
}
|
||||
}
|
||||
|
||||
func requireStatus(t *testing.T, resp *http.Response, expected int) {
|
||||
t.Helper()
|
||||
|
||||
if resp.StatusCode != expected {
|
||||
data, _ := io.ReadAll(resp.Body)
|
||||
resp.Body.Close()
|
||||
|
||||
t.Fatalf(
|
||||
"expected status %d, got %d, body: %s",
|
||||
expected,
|
||||
resp.StatusCode,
|
||||
data,
|
||||
)
|
||||
}
|
||||
|
||||
if resp.Header.Get("X-Request-Id") == "" {
|
||||
t.Errorf("missing X-Request-Id header")
|
||||
}
|
||||
}
|
||||
|
||||
func createUser(t *testing.T) testUser {
|
||||
t.Helper()
|
||||
|
||||
username := "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:12]
|
||||
|
||||
body, err := json.Marshal(map[string]string{
|
||||
"username": username,
|
||||
"display_name": "Test " + username,
|
||||
"password": testPassword,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("marshal user: %v", err)
|
||||
}
|
||||
|
||||
resp := doRequest(t, http.MethodPost, "/api/v1/users", "", body)
|
||||
requireStatus(t, resp, http.StatusCreated)
|
||||
|
||||
var u dto.UserResponse
|
||||
mustDecode(t, resp, &u)
|
||||
|
||||
req, err := http.NewRequest(
|
||||
http.MethodPost,
|
||||
*baseURL+"/api/v1/auth/sessions",
|
||||
nil,
|
||||
)
|
||||
if err != nil {
|
||||
t.Fatalf("build login request: %v", err)
|
||||
}
|
||||
req.SetBasicAuth(username, testPassword)
|
||||
|
||||
resp, err = httpClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("login request failed: %v", err)
|
||||
}
|
||||
requireStatus(t, resp, http.StatusCreated)
|
||||
|
||||
var session dto.SessionResponse
|
||||
mustDecode(t, resp, &session)
|
||||
|
||||
return testUser{UserResponse: u, Token: session.Token}
|
||||
}
|
||||
|
||||
func createChat(
|
||||
t *testing.T,
|
||||
creator testUser,
|
||||
memberIDs ...uuid.UUID,
|
||||
) dto.ChatResponse {
|
||||
t.Helper()
|
||||
|
||||
body, err := json.Marshal(map[string]any{
|
||||
"title": "Test chat " + uuid.NewString()[:8],
|
||||
"member_ids": memberIDs,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("marshal chat: %v", err)
|
||||
}
|
||||
|
||||
resp := doRequest(
|
||||
t,
|
||||
http.MethodPost,
|
||||
"/api/v1/chats",
|
||||
creator.Token,
|
||||
body,
|
||||
)
|
||||
|
||||
requireStatus(t, resp, http.StatusCreated)
|
||||
|
||||
var c dto.ChatResponse
|
||||
mustDecode(t, resp, &c)
|
||||
|
||||
return c
|
||||
}
|
||||
|
||||
func sendMessage(
|
||||
t *testing.T,
|
||||
actor testUser,
|
||||
chatID uuid.UUID,
|
||||
text string,
|
||||
) *http.Response {
|
||||
t.Helper()
|
||||
|
||||
body, err := json.Marshal(map[string]string{
|
||||
"text": text,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("marshal message: %v", err)
|
||||
}
|
||||
|
||||
return doRequest(
|
||||
t,
|
||||
http.MethodPost,
|
||||
fmt.Sprintf("/api/v1/chats/%v/messages", chatID.String()),
|
||||
actor.Token,
|
||||
body,
|
||||
)
|
||||
}
|
||||
|
||||
func sendLoadMessage(
|
||||
actor testUser,
|
||||
chatID uuid.UUID,
|
||||
text string,
|
||||
) (*http.Response, error) {
|
||||
body, err := json.Marshal(map[string]string{
|
||||
"text": text,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
req, err := http.NewRequest(
|
||||
http.MethodPost,
|
||||
*baseURL+"/api/v1/chats/"+chatID.String()+"/messages",
|
||||
bytes.NewReader(body),
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("Authorization", "Bearer "+actor.Token)
|
||||
|
||||
return httpClient.Do(req)
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
//go:build load
|
||||
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"io"
|
||||
"net/http"
|
||||
"sort"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
workers = flag.Int("workers", 20, "number of concurrent workers")
|
||||
duration = flag.Duration("duration", 5*time.Second, "test duration")
|
||||
rate = flag.Int("rate", 20, "maximum requests per second per worker")
|
||||
)
|
||||
|
||||
func TestLoad(t *testing.T) {
|
||||
var (
|
||||
statuses = make(map[int]int64)
|
||||
requestErrors int64
|
||||
latencies []time.Duration
|
||||
statusMu sync.Mutex
|
||||
latencyMu sync.Mutex
|
||||
wg sync.WaitGroup
|
||||
)
|
||||
|
||||
user1 := createUser(t)
|
||||
user2 := createUser(t)
|
||||
chat := createChat(t, user1, user1.ID, user2.ID)
|
||||
|
||||
start := time.Now()
|
||||
deadline := start.Add(*duration)
|
||||
|
||||
interval := time.Second / time.Duration(*rate)
|
||||
|
||||
for worker := 0; worker < *workers; worker++ {
|
||||
wg.Add(1)
|
||||
|
||||
go func(workerID int) {
|
||||
defer wg.Done()
|
||||
|
||||
actor := user1
|
||||
if workerID%2 == 1 {
|
||||
actor = user2
|
||||
}
|
||||
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
|
||||
for time.Now().Before(deadline) {
|
||||
<-ticker.C
|
||||
|
||||
if time.Now().After(deadline) {
|
||||
return
|
||||
}
|
||||
|
||||
requestStart := time.Now()
|
||||
|
||||
resp, err := sendLoadMessage(
|
||||
actor,
|
||||
chat.ID,
|
||||
"load-msg",
|
||||
)
|
||||
|
||||
latency := time.Since(requestStart)
|
||||
|
||||
if err != nil {
|
||||
if atomic.CompareAndSwapInt64(&requestErrors, 0, 1) {
|
||||
t.Logf("first transport error: %v", err)
|
||||
}
|
||||
atomic.AddInt64(&requestErrors, 1)
|
||||
continue
|
||||
}
|
||||
|
||||
statusMu.Lock()
|
||||
statuses[resp.StatusCode]++
|
||||
statusMu.Unlock()
|
||||
|
||||
if resp.StatusCode == http.StatusCreated {
|
||||
latencyMu.Lock()
|
||||
latencies = append(latencies, latency)
|
||||
latencyMu.Unlock()
|
||||
}
|
||||
|
||||
io.Copy(io.Discard, resp.Body)
|
||||
resp.Body.Close()
|
||||
}
|
||||
}(worker)
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
|
||||
elapsed := time.Since(start)
|
||||
|
||||
var total int64
|
||||
for _, count := range statuses {
|
||||
total += count
|
||||
}
|
||||
total += requestErrors
|
||||
|
||||
t.Logf("duration: %.3fs", elapsed.Seconds())
|
||||
t.Logf("workers: %d", *workers)
|
||||
t.Logf("rate per worker: %d req/s", *rate)
|
||||
t.Logf("target rate: %d req/s", *workers**rate)
|
||||
t.Logf("total requests: %d", total)
|
||||
|
||||
for status, count := range statuses {
|
||||
t.Logf("HTTP %d: %d", status, count)
|
||||
}
|
||||
|
||||
t.Logf("request errors: %d", requestErrors)
|
||||
|
||||
successful := statuses[http.StatusCreated]
|
||||
|
||||
t.Logf("successful RPS: %.2f",
|
||||
float64(successful)/elapsed.Seconds(),
|
||||
)
|
||||
|
||||
if len(latencies) > 0 {
|
||||
sort.Slice(latencies, func(i, j int) bool {
|
||||
return latencies[i] < latencies[j]
|
||||
})
|
||||
|
||||
t.Logf("successful latency p50: %s", percentile(latencies, 0.50))
|
||||
t.Logf("successful latency p95: %s", percentile(latencies, 0.95))
|
||||
t.Logf("successful latency p99: %s", percentile(latencies, 0.99))
|
||||
}
|
||||
}
|
||||
|
||||
func percentile(values []time.Duration, p float64) time.Duration {
|
||||
index := int(float64(len(values)-1) * p)
|
||||
return values[index]
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
//go:build race
|
||||
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"mtusi2026-messenger/internal/dto"
|
||||
)
|
||||
|
||||
func TestConcurrentMessages(t *testing.T) {
|
||||
const clients = 10
|
||||
const messagesPerClient = 10
|
||||
const total = clients * messagesPerClient
|
||||
|
||||
user1 := createUser(t)
|
||||
user2 := createUser(t)
|
||||
chat := createChat(t, user1, user1.ID, user2.ID)
|
||||
|
||||
var wg sync.WaitGroup
|
||||
var mu sync.Mutex
|
||||
sentIDs := make(map[string]bool, total)
|
||||
|
||||
start := make(chan struct{})
|
||||
|
||||
for worker := 0; worker < clients; worker++ {
|
||||
wg.Add(1)
|
||||
|
||||
go func(workerID int) {
|
||||
defer wg.Done()
|
||||
|
||||
actor := user1
|
||||
if workerID%2 == 1 {
|
||||
actor = user2
|
||||
}
|
||||
|
||||
<-start
|
||||
|
||||
for i := 0; i < messagesPerClient; i++ {
|
||||
resp := sendMessage(t, actor, chat.ID, "race-msg")
|
||||
if resp.StatusCode != http.StatusCreated {
|
||||
t.Errorf("worker %d msg %d: expected 201, got %d", workerID, i, resp.StatusCode)
|
||||
resp.Body.Close()
|
||||
continue
|
||||
}
|
||||
|
||||
var m dto.MessageResponse
|
||||
mustDecode(t, resp, &m)
|
||||
|
||||
mu.Lock()
|
||||
sentIDs[m.ID.String()] = true
|
||||
mu.Unlock()
|
||||
}
|
||||
}(worker)
|
||||
}
|
||||
|
||||
close(start)
|
||||
wg.Wait()
|
||||
|
||||
if t.Failed() {
|
||||
t.Fatal("one or more send requests failed, see errors above")
|
||||
}
|
||||
|
||||
if len(sentIDs) != total {
|
||||
t.Fatalf("expected %d successful sends, got %d unique ids", total, len(sentIDs))
|
||||
}
|
||||
|
||||
seen := make(map[string]bool, total)
|
||||
|
||||
path := "/api/v1/chats/" + chat.ID.String() + "/messages?limit=100"
|
||||
resp := doRequest(t, http.MethodGet, path, user1.Token, nil)
|
||||
requireStatus(t, resp, http.StatusOK)
|
||||
|
||||
var page dto.MessagePageResponse
|
||||
mustDecode(t, resp, &page)
|
||||
|
||||
if page.NextCursor != nil {
|
||||
t.Fatalf("expected next_cursor to be nil, history may contain more than %d messages", total)
|
||||
}
|
||||
|
||||
for _, msg := range page.Items {
|
||||
id := msg.ID.String()
|
||||
if seen[id] {
|
||||
t.Fatalf("duplicate message id in history: %s", id)
|
||||
}
|
||||
if !sentIDs[id] {
|
||||
t.Fatalf("message %s in history was never sent by this test", id)
|
||||
}
|
||||
seen[id] = true
|
||||
}
|
||||
|
||||
if len(seen) != total {
|
||||
t.Fatalf("expected exactly %d unique messages in history, got %d", total, len(seen))
|
||||
}
|
||||
|
||||
t.Logf("PASS: %d concurrent clients sent %d messages, exactly %d unique messages persisted",
|
||||
clients, total, len(seen))
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
//go:build race
|
||||
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
func TestConcurrentRegistration(t *testing.T) {
|
||||
const workers = 20
|
||||
|
||||
username := "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:12]
|
||||
|
||||
body, err := json.Marshal(map[string]string{
|
||||
"username": username,
|
||||
"display_name": "Racer",
|
||||
"password": testPassword,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("marshal body: %v", err)
|
||||
}
|
||||
|
||||
start := make(chan struct{})
|
||||
statuses := make(chan int, workers)
|
||||
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < workers; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
<-start
|
||||
|
||||
req, err := http.NewRequest(http.MethodPost, *baseURL+"/api/v1/users", bytes.NewReader(body))
|
||||
if err != nil {
|
||||
t.Errorf("build request: %v", err)
|
||||
return
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
resp, err := httpClient.Do(req)
|
||||
if err != nil {
|
||||
t.Errorf("request failed: %v", err)
|
||||
return
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
statuses <- resp.StatusCode
|
||||
}()
|
||||
}
|
||||
|
||||
close(start)
|
||||
wg.Wait()
|
||||
close(statuses)
|
||||
|
||||
created, conflict := 0, 0
|
||||
for s := range statuses {
|
||||
switch s {
|
||||
case http.StatusCreated:
|
||||
created++
|
||||
case http.StatusConflict:
|
||||
conflict++
|
||||
default:
|
||||
t.Errorf("unexpected status %d", s)
|
||||
}
|
||||
}
|
||||
|
||||
if created != 1 || conflict != workers-1 {
|
||||
t.Fatalf("expected 1 created and %d conflict, got %d created and %d conflict", workers-1, created, conflict)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
//go:build failure
|
||||
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"os/exec"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
const shortTTLContainer = "api-short-ttl"
|
||||
const shortTTLURL = "http://localhost:8081"
|
||||
|
||||
func TestSessionExpiry(t *testing.T) {
|
||||
_ = exec.Command("docker", "rm", "-f", shortTTLContainer).Run()
|
||||
|
||||
compose(t, "run", "-d", "--no-deps", "--name", shortTTLContainer,
|
||||
"-e", "SESSION_TTL_SECONDS=3",
|
||||
"-p", "127.0.0.1:8081:8080", "api")
|
||||
t.Cleanup(func() {
|
||||
_ = exec.Command("docker", "rm", "-f", shortTTLContainer).Run()
|
||||
})
|
||||
|
||||
old := *baseURL
|
||||
*baseURL = shortTTLURL
|
||||
t.Cleanup(func() { *baseURL = old })
|
||||
|
||||
waitReady(t)
|
||||
|
||||
user := createUser(t)
|
||||
|
||||
resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusOK)
|
||||
resp.Body.Close()
|
||||
|
||||
time.Sleep(4 * time.Second)
|
||||
|
||||
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusUnauthorized)
|
||||
resp.Body.Close()
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
//go:build contract
|
||||
|
||||
package studenttests_test
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func basicLogin(t *testing.T, username, password string) *http.Response {
|
||||
t.Helper()
|
||||
|
||||
req, err := http.NewRequest(http.MethodPost, *baseURL+"/api/v1/auth/sessions", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("build login request: %v", err)
|
||||
}
|
||||
req.SetBasicAuth(username, password)
|
||||
|
||||
resp, err := httpClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatalf("login request failed: %v", err)
|
||||
}
|
||||
return resp
|
||||
}
|
||||
|
||||
func TestLoginWrongPassword(t *testing.T) {
|
||||
user := createUser(t)
|
||||
|
||||
resp := basicLogin(t, user.Username, "wrong-"+testPassword)
|
||||
requireStatus(t, resp, http.StatusUnauthorized)
|
||||
resp.Body.Close()
|
||||
|
||||
resp = basicLogin(t, "no_such_user_"+user.Username, testPassword)
|
||||
requireStatus(t, resp, http.StatusUnauthorized)
|
||||
resp.Body.Close()
|
||||
}
|
||||
|
||||
func TestLogout(t *testing.T) {
|
||||
user := createUser(t)
|
||||
|
||||
resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusOK)
|
||||
resp.Body.Close()
|
||||
|
||||
resp = doRequest(t, http.MethodDelete, "/api/v1/auth/sessions/current", user.Token, nil)
|
||||
if resp.StatusCode >= 300 {
|
||||
t.Fatalf("logout: unexpected status %d", resp.StatusCode)
|
||||
}
|
||||
resp.Body.Close()
|
||||
|
||||
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusUnauthorized)
|
||||
resp.Body.Close()
|
||||
|
||||
resp = doRequest(t, http.MethodDelete, "/api/v1/auth/sessions/current", user.Token, nil)
|
||||
requireStatus(t, resp, http.StatusUnauthorized)
|
||||
resp.Body.Close()
|
||||
}
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
LOAD_ARGS = $(if $(LOAD_WORKERS),-workers=$(LOAD_WORKERS),) \
|
||||
$(if $(LOAD_DURATION),-duration=$(LOAD_DURATION),) \
|
||||
$(if $(LOAD_RATE),-rate=$(LOAD_RATE),)
|
||||
|
||||
.PHONY: help-go contract-go race-go load-go failure-go
|
||||
|
||||
help-go:
|
||||
@echo "contract-go: contract tests"
|
||||
@echo "race-go: concurrency tests (-race)"
|
||||
@echo "load-go: load test"
|
||||
@echo "failure-go: dependency failure tests (stops redis/postgres containers)"
|
||||
|
||||
contract-go:
|
||||
go test -tags=contract ./student-tests/... -v -args -base-url=$(BASE_URL)
|
||||
|
||||
race-go:
|
||||
go test -tags=race ./student-tests/... -race -v -args -base-url=$(BASE_URL)
|
||||
|
||||
load-go:
|
||||
go test -tags=load ./student-tests/... -v -args -base-url=$(BASE_URL) $(LOAD_ARGS)
|
||||
|
||||
failure-go:
|
||||
go test -tags=failure ./student-tests/... -v -args -base-url=$(BASE_URL)
|
||||
@@ -0,0 +1,21 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="ru">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<title>MTUSI Messenger API</title>
|
||||
<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist/swagger-ui.css">
|
||||
</head>
|
||||
<body>
|
||||
<div id="swagger-ui"></div>
|
||||
|
||||
<script src="https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js"></script>
|
||||
<script>
|
||||
window.onload = () => {
|
||||
SwaggerUIBundle({
|
||||
url: "/contracts/openapi.json",
|
||||
dom_id: "#swagger-ui"
|
||||
});
|
||||
};
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
Reference in New Issue
Block a user